atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>G-SS-Hacker</title>
  
  <subtitle>---A Cyber Driver---</subtitle>
  <link href="/G-SS-Hacker.github.io/atom.xml" rel="self"/>
  
  <link href="https://g-ss-hacker.github.io/"/>
  <updated>2020-08-01T05:05:11.617Z</updated>
  <id>https://g-ss-hacker.github.io/</id>
  
  <author>
    <name>G-SS-Hacker</name>
    
  </author>
  
  <generator uri="https://hexo.io/">Hexo</generator>
  
  <entry>
    <title>IP地址分类</title>
    <link href="https://g-ss-hacker.github.io/IP%E5%9C%B0%E5%9D%80%E5%88%86%E7%B1%BB/"/>
    <id>https://g-ss-hacker.github.io/IP%E5%9C%B0%E5%9D%80%E5%88%86%E7%B1%BB/</id>
    <published>2020-08-01T04:28:04.000Z</published>
    <updated>2020-08-01T05:05:11.617Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://gitee.com/G-SS-Hacker/images/raw/master/wave.jpg" alt="wave"></p><blockquote><p>图：神奈川冲浪里</p></blockquote><h1 id="IP地址分类"><a href="#IP地址分类" class="headerlink" title="IP地址分类"></a>IP地址分类</h1><p><font color="grey"> <em>Guderian出品</em> </font></p><p><img src="https://gitee.com/G-SS-Hacker/images/raw/master/image-20200801113023708.png" alt="image-20200801113023708"></p><p><img src="https://gitee.com/G-SS-Hacker/images/raw/master/image-20200801122155103.png" alt="image-20200801122155103"></p><ul><li>IP地址分为主要类型A、B、C和特殊类型D、E五类。</li><li>IP地址由两部分组成：网络号和主机号。网络号标识了它属于哪一个网络，主机号标识了它属于网络中的哪一台主机。</li><li>尽管IP地址主机号的每个域取值<code>0 - 255</code>，但主机号所有域不能都是<code>0</code>或<code>255</code>。<a id="more"></a></li><li>在IP地址3种主要类型里，各保留了3个区域作为私有地址：<ul><li>A类地址：<code>10.0.0.0 - 10.255.255.255</code> </li><li>B类地址：<code>172.16.0.0 - 172.31.255.255</code> </li><li>C类地址：<code>192.168.0.0 - 192.168.255.255</code></li></ul></li><li>本机地址：<code>127.0.0.1</code>等价于<code>localhost</code>或本机IP。</li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://gitee.com/G-SS-Hacker/images/raw/master/wave.jpg&quot; alt=&quot;wave&quot;&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;图：神奈川冲浪里&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h1 id=&quot;IP地址分类&quot;&gt;&lt;a href=&quot;#IP地址分类&quot; class=&quot;headerlink&quot; title=&quot;IP地址分类&quot;&gt;&lt;/a&gt;IP地址分类&lt;/h1&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian出品&lt;/em&gt; &lt;/font&gt;&lt;/p&gt;

&lt;p&gt;&lt;img src=&quot;https://gitee.com/G-SS-Hacker/images/raw/master/image-20200801113023708.png&quot; alt=&quot;image-20200801113023708&quot;&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;https://gitee.com/G-SS-Hacker/images/raw/master/image-20200801122155103.png&quot; alt=&quot;image-20200801122155103&quot;&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;IP地址分为主要类型A、B、C和特殊类型D、E五类。&lt;/li&gt;
&lt;li&gt;IP地址由两部分组成：网络号和主机号。网络号标识了它属于哪一个网络，主机号标识了它属于网络中的哪一台主机。&lt;/li&gt;
&lt;li&gt;尽管IP地址主机号的每个域取值&lt;code&gt;0 - 255&lt;/code&gt;，但主机号所有域不能都是&lt;code&gt;0&lt;/code&gt;或&lt;code&gt;255&lt;/code&gt;。
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="计算机网络" scheme="https://G-SS-Hacker.github.io/tags/%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%BD%91%E7%BB%9C/"/>
    
  </entry>
  
  <entry>
    <title>二阶常系数线性微分方程</title>
    <link href="https://g-ss-hacker.github.io/%E4%BA%8C%E9%98%B6%E5%B8%B8%E7%B3%BB%E6%95%B0%E7%BA%BF%E6%80%A7%E5%BE%AE%E5%88%86%E6%96%B9%E7%A8%8B/"/>
    <id>https://g-ss-hacker.github.io/%E4%BA%8C%E9%98%B6%E5%B8%B8%E7%B3%BB%E6%95%B0%E7%BA%BF%E6%80%A7%E5%BE%AE%E5%88%86%E6%96%B9%E7%A8%8B/</id>
    <published>2020-07-14T15:08:40.000Z</published>
    <updated>2020-07-14T15:09:20.792Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://gitee.com/G-SS-Hacker/images/raw/master/image-20200714225203591.png" alt="image-20200714225203591"></p><a id="more"></a><blockquote><p>Licensed under cc0 license. Feel free to share it with others.😎</p></blockquote>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://gitee.com/G-SS-Hacker/images/raw/master/image-20200714225203591.png&quot; alt=&quot;image-20200714225203591&quot;&gt;&lt;/p&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="微积分" scheme="https://G-SS-Hacker.github.io/tags/%E5%BE%AE%E7%A7%AF%E5%88%86/"/>
    
  </entry>
  
  <entry>
    <title>静电场</title>
    <link href="https://g-ss-hacker.github.io/%E9%9D%99%E7%94%B5%E5%9C%BA/"/>
    <id>https://g-ss-hacker.github.io/%E9%9D%99%E7%94%B5%E5%9C%BA/</id>
    <published>2020-05-22T04:07:58.000Z</published>
    <updated>2020-05-22T05:51:34.776Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/05/22/RJKr698Vwmpgicq.png" alt="bojack10.png"></p><h1 id="静电场"><a href="#静电场" class="headerlink" title="静电场"></a><font color="2F5496">静电场</font></h1><p></p><p><font color="grey"> <em>茗</em> 与 <em>Guderian</em> 出品 </font></p><p></p><h2 id="电荷-库仑定律"><a href="#电荷-库仑定律" class="headerlink" title="电荷 库仑定律"></a><font color="2F5496">电荷 库仑定律</font></h2><p><strong><font color="dark" red>电荷量：</font></strong>物体所带电荷的量值，常用$Q$或$q$表示，单位$C$（库仑）</p><p><strong><font color="dark" red>元电荷：</font></strong>电荷量的最小单元，<font size="4rem">$e=1.602\times{10}^{-19}C$</font></p><p><strong><font color="dark" red>电荷守恒定律：</font></strong>如果系统与外界没有电荷交换，那么不管在系统中发生了什么变化，系统所带电荷量的代数和将保持不变。</p><p><strong><font color="dark" red>点电荷：</font></strong>电荷集中的几何点（理想化模型）</p><p><strong><font color="dark" red>库仑定律：</font></strong><font size="4rem">$F=\frac{1}{4\pi\varepsilon_0}\frac{qq_0}{r^2}\hat e_r$</font></p><blockquote><p>其中<font size="4rem">$\varepsilon_0=8.854\times{10}^{-12}C^2\cdot N^{-1}\cdot m^2$</font>，称为真空介电常数，也称为真空电容率</p></blockquote><h2 id="电场-电场强度"><a href="#电场-电场强度" class="headerlink" title="电场 电场强度"></a><font color="2F5496">电场 电场强度</font></h2><p><strong><font color="dark" red>电场：</font></strong>带电体周围存在着的一种特殊物质</p><p><strong><font color="dark" red>电场强度：</font></strong><font size="4rem">$E=\frac{F}{q_0}$</font> 单位：<font size="4rem">$N\cdot C^{-1}$</font>或<font size="4rem">$V\cdot m^{-1}$</font></p><blockquote><p>电场中任意场点处的电场强度在量值和方向上等于单位点电荷在该点处所受的电场力</p></blockquote><p><strong><font color="dark" red>电场强度叠加原理：</font></strong><font size="4rem">$E=E_1+E_2+\cdots+E_n$</font></p><blockquote><p>多个点电荷（或带电体）共同激发的电场中，某场点处的电场强度为每一个点电荷单独存在时在该点处各自所激发的电场强度的矢量和</p></blockquote><h2 id="真空中的高斯定理"><a href="#真空中的高斯定理" class="headerlink" title="真空中的高斯定理"></a><font color="2F5496">真空中的高斯定理</font></h2><p><strong><font color="dark" red>电场强度通量：</font></strong><font size="5rem">$E=\frac{d\Phi_\tau}{dS_\bot}$</font></p><p><strong><font color="dark" red>真空中高斯定理：</font></strong>真空中通过任意闭合曲面的电场强度通量，在数值上等于此闭合曲面所包围的电荷量的代数和除以<font size="4rem">$\varepsilon_0$</font>，而与曲面的形状和曲面外的电荷无关</p><p><img src="https://i.loli.net/2020/05/22/ghW1NeKJV9GbDS3.png" alt="微信截图_20200522115455.png"></p><blockquote><p>注：<font size="4rem">$\int_{S内}\mathrm{d}q$</font>为闭合曲面内的电荷，而$E$为空间所有电荷激发的总电场强度</p></blockquote><a id="more"></a><h2 id="电势"><a href="#电势" class="headerlink" title="电势"></a><font color="2F5496">电势</font></h2><p><strong><font color="dark" red>静电场力的功：</font></strong>试验电荷在静电场中移动时，电场力所做的功仅与这试验电荷电荷量的大小以及路径的起点和终点位置有关，而与路径无关</p><blockquote><p>说明静电场力是保守力</p></blockquote><p><strong><font color="dark" red>静电场的环路定理：</font></strong>静电场的环流为零：<font size="4rem">$\oint_{l}^{ }E\cdot dl=0$</font></p><blockquote><p>说明静电场是保守场</p></blockquote><p><strong><font color="dark" red>电势能：</font></strong><font size="4rem">$W_a-W_b={-A}_{ab}=q_0\int_{a}^{b}{E\cdot dl}$</font></p><p><strong><font color="dark" red>电势：</font></strong><font size="4rem">$U_a=\frac{W_a}{q_0}=\int_{a}^{b}{E\cdot dl}$ </font> ，（其中$b$为电势零点）</p><p>电场中某点的电势在量值上等于放在该点的单位正电荷的电势能，也等于单位正电荷从该点经过任意路径移动到零电势参考点处时电场力所做的功</p><p><strong><font color="dark" red>电势叠加原理：</font></strong>令电势零点为无限远处，<font size="4rem">$U_P=\int_{l}^{ }dU=\int_{l}^{ }\frac{dq}{4\pi\varepsilon_0r}$</font></p><h2 id="电场强度与电势的微分关系"><a href="#电场强度与电势的微分关系" class="headerlink" title="电场强度与电势的微分关系"></a><font color="2F5496">电场强度与电势的微分关系</font></h2><p><strong><font color="dark" red>电场强度与电势的微分关系：</font></strong><font size="4rem">$E=-(i\frac{\partial}{\partial x}+j\frac{\partial}{\partial y}+k\frac{\partial}{\partial z})U$</font></p>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/22/RJKr698Vwmpgicq.png&quot; alt=&quot;bojack10.png&quot;&gt;&lt;/p&gt;
&lt;h1 id=&quot;静电场&quot;&gt;&lt;a href=&quot;#静电场&quot; class=&quot;headerlink&quot; title=&quot;静电场&quot;&gt;&lt;/a&gt;&lt;font color=&quot;2F5496&quot;&gt;静电场&lt;/font&gt;&lt;/h1&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;茗&lt;/em&gt; 与 &lt;em&gt;Guderian&lt;/em&gt; 出品 &lt;/font&gt;&lt;/p&gt;&lt;p&gt;&lt;/p&gt;
&lt;h2 id=&quot;电荷-库仑定律&quot;&gt;&lt;a href=&quot;#电荷-库仑定律&quot; class=&quot;headerlink&quot; title=&quot;电荷 库仑定律&quot;&gt;&lt;/a&gt;&lt;font color=&quot;2F5496&quot;&gt;电荷 库仑定律&lt;/font&gt;&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;电荷量：&lt;/font&gt;&lt;/strong&gt;物体所带电荷的量值，常用$Q$或$q$表示，单位$C$（库仑）&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;元电荷：&lt;/font&gt;&lt;/strong&gt;电荷量的最小单元，&lt;font size=&quot;4rem&quot;&gt;$e=1.602\times{10}^{-19}C$&lt;/font&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;电荷守恒定律：&lt;/font&gt;&lt;/strong&gt;如果系统与外界没有电荷交换，那么不管在系统中发生了什么变化，系统所带电荷量的代数和将保持不变。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;点电荷：&lt;/font&gt;&lt;/strong&gt;电荷集中的几何点（理想化模型）&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;库仑定律：&lt;/font&gt;&lt;/strong&gt;&lt;font size=&quot;4rem&quot;&gt;$F=\frac{1}{4\pi\varepsilon_0}\frac{qq_0}{r^2}\hat e_r$&lt;/font&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;其中&lt;font size=&quot;4rem&quot;&gt;$\varepsilon_0=8.854\times{10}^{-12}C^2\cdot N^{-1}\cdot m^2$&lt;/font&gt;，称为真空介电常数，也称为真空电容率&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&quot;电场-电场强度&quot;&gt;&lt;a href=&quot;#电场-电场强度&quot; class=&quot;headerlink&quot; title=&quot;电场 电场强度&quot;&gt;&lt;/a&gt;&lt;font color=&quot;2F5496&quot;&gt;电场 电场强度&lt;/font&gt;&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;电场：&lt;/font&gt;&lt;/strong&gt;带电体周围存在着的一种特殊物质&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;电场强度：&lt;/font&gt;&lt;/strong&gt;&lt;font size=&quot;4rem&quot;&gt;$E=\frac{F}{q_0}$&lt;/font&gt; 单位：&lt;font size=&quot;4rem&quot;&gt;$N\cdot C^{-1}$&lt;/font&gt;或&lt;font size=&quot;4rem&quot;&gt;$V\cdot m^{-1}$&lt;/font&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;电场中任意场点处的电场强度在量值和方向上等于单位点电荷在该点处所受的电场力&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;电场强度叠加原理：&lt;/font&gt;&lt;/strong&gt;&lt;font size=&quot;4rem&quot;&gt;$E=E_1+E_2+\cdots+E_n$&lt;/font&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;多个点电荷（或带电体）共同激发的电场中，某场点处的电场强度为每一个点电荷单独存在时在该点处各自所激发的电场强度的矢量和&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&quot;真空中的高斯定理&quot;&gt;&lt;a href=&quot;#真空中的高斯定理&quot; class=&quot;headerlink&quot; title=&quot;真空中的高斯定理&quot;&gt;&lt;/a&gt;&lt;font color=&quot;2F5496&quot;&gt;真空中的高斯定理&lt;/font&gt;&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;电场强度通量：&lt;/font&gt;&lt;/strong&gt;&lt;font size=&quot;5rem&quot;&gt;$E=\frac{d\Phi_\tau}{dS_\bot}$&lt;/font&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;真空中高斯定理：&lt;/font&gt;&lt;/strong&gt;真空中通过任意闭合曲面的电场强度通量，在数值上等于此闭合曲面所包围的电荷量的代数和除以&lt;font size=&quot;4rem&quot;&gt;$\varepsilon_0$&lt;/font&gt;，而与曲面的形状和曲面外的电荷无关&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/22/ghW1NeKJV9GbDS3.png&quot; alt=&quot;微信截图_20200522115455.png&quot;&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;注：&lt;font size=&quot;4rem&quot;&gt;$\int_{S内}\mathrm{d}q$&lt;/font&gt;为闭合曲面内的电荷，而$E$为空间所有电荷激发的总电场强度&lt;/p&gt;
&lt;/blockquote&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="大物" scheme="https://G-SS-Hacker.github.io/tags/%E5%A4%A7%E7%89%A9/"/>
    
  </entry>
  
  <entry>
    <title>静电场中的导体和电介质</title>
    <link href="https://g-ss-hacker.github.io/%E9%9D%99%E7%94%B5%E5%9C%BA%E4%B8%AD%E7%9A%84%E5%AF%BC%E4%BD%93%E5%92%8C%E7%94%B5%E4%BB%8B%E8%B4%A8/"/>
    <id>https://g-ss-hacker.github.io/%E9%9D%99%E7%94%B5%E5%9C%BA%E4%B8%AD%E7%9A%84%E5%AF%BC%E4%BD%93%E5%92%8C%E7%94%B5%E4%BB%8B%E8%B4%A8/</id>
    <published>2020-05-21T15:48:34.000Z</published>
    <updated>2020-05-23T08:13:27.577Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/05/21/bw9mDLGyX4BdVjp.jpg" alt="bojack6.jpg"></p><h1 id="静电场中的导体和电介质"><a href="#静电场中的导体和电介质" class="headerlink" title="静电场中的导体和电介质"></a><font color="2F5496">静电场中的导体和电介质</font></h1><p></p><p><font color="grey"> <em>茗</em> 与 <em>Guderian</em> 出品 </font></p><p></p><h2 id="静电场中的导体和电介质-1"><a href="#静电场中的导体和电介质-1" class="headerlink" title="静电场中的导体和电介质"></a><font color="2F5496">静电场中的导体和电介质</font></h2><p><strong><font color="dark" red>静电感应：</font></strong>在电场的作用下导体上的电荷重新分布的现象 </p><p><strong><font color="dark" red>感生电荷：</font></strong>静电感应所产生的电荷（感生电荷代数和为零）</p><p><strong><font color="dark" red>静电平衡：</font></strong></p><ol><li>处于静电平衡的导体内部电场强度处处为零；导体表面外附近的电场强度与导体表面垂直；</li><li>处于静电平衡的导体是一个等势体；导体表面是一个等势面</li></ol><p><strong><font color="dark" red>静电平衡时导体上电荷分布：</font></strong></p><ol><li>静电平衡导体内各处的净电荷为零，导体自身带电或其感生电荷都只能分布于导体表面</li><li>静电平衡导体表面外附近的电场强度$E$的大小与该处该处表面上的电荷面密度<font size="4rem">$\sigma$</font>的关系为<font size="4rem">$E=\frac{\sigma}{\varepsilon_0}$</font></li></ol><p><strong><font color="dark" red>静电屏蔽：</font></strong></p><ol><li>若空腔导体内无带电体，静电平衡状态下导体腔内表面处处无电荷，电荷只分布在外表面，且腔内无电场</li><li>若空腔导体内有带电体，在腔内表面出现与腔内带电体等量异号的感生电荷，外表面出现等量同号感生电荷</li></ol><p><strong><font color="dark" red>静电应用：</font></strong></p><ol><li>范德格拉夫起电机</li><li>静电集尘</li><li>静电喷漆</li></ol><h2 id="电容和电容器"><a href="#电容和电容器" class="headerlink" title="电容和电容器"></a><font color="2F5496">电容和电容器</font></h2><p><strong><font color="dark" red>孤立导体的电容：</font></strong><font size="4rem"> $\frac{Q}{U}=C$  </font>，$C$为电容，单位$F$（法拉），<font size="4rem">$1F={10}^6\mu F={10}^{12}pF$</font></p><p><strong><font color="dark" red>电容器：</font></strong><font size="4rem">$C=\frac{Q}{U_{AB}}$</font>（两极板带电分别为$+Q$,$-Q$）</p><p><strong><font color="dark" red>平板电容器：</font></strong></p><ul><li><font size="4rem">$E=\frac{\sigma}{\varepsilon_0}=\frac{Q}{\varepsilon_0S}$</font></li><li><font size="4rem">$U_{AB}=\int{E\cdot d\ l=Ed=\frac{Qd}{\varepsilon_0S}}$</font></li><li><font size="4rem">$C=\frac{Q}{U_{AB}}=\frac{\varepsilon_0S}{d}$</font></li></ul><p><strong><font color="dark" red>圆柱形电容器：</font></strong></p><ul><li><font size="4rem">$E=\frac{\lambda}{2\pi\varepsilon_0r}$</font>（高斯定理）</li><li><font size="4rem">$U_{AB}=\int_{R_A}^{R_B}{E\cdot d\ r=}\frac{\lambda}{2\pi\varepsilon_0}ln\frac{R_B}{R_A}$</font></li><li><font size="4rem">$C=\frac{Q}{U_{AB}}=\frac{2\pi\varepsilon_0L}{ln\frac{R_B}{R_A}}$</font></li></ul><p><strong><font color="dark" red>球形电容器：</font></strong></p><ul><li><font size="4rem">$E=\frac{Q}{4\pi\varepsilon_0r^2}$</font></li><li><font size="4rem">$U_{AB}=\int_{R_A}^{R_B}{E\cdot d\ l=}\frac{Q}{4\pi\varepsilon_0}（1RA-1RB）$</font></li><li><font size="4rem">$C=\frac{Q}{U_{AB}}=4\pi\varepsilon_0\frac{R_A R_B}{R_B - R_A}$</font></li></ul><p><strong><font color="dark" red>电容器并联：</font></strong><font size="4rem">$C=\sum_{i=1}^{N}C_i$</font></p><p><strong><font color="dark" red>电容器串联：</font></strong><font size="4rem">$\frac{1}{C}=\sum_{i=1}^{N}\frac{1}{C_i}$</font></p><a id="more"></a><h2 id="静电场中的电介质"><a href="#静电场中的电介质" class="headerlink" title="静电场中的电介质"></a><font color="2F5496">静电场中的电介质</font></h2><p><strong><font color="dark" red>电介质：</font></strong>大量中性分子组成的绝缘体，可分为无极分子和有极分子</p><p><strong><font color="dark" red>无极分子：</font></strong>外电场不存在时，分子正负电荷中心是重合的</p><p><strong><font color="dark" red>有极分子：</font></strong>外电场不存在时，分子正负电荷中心不重合的，其电偶极矩称固有极矩</p><p><strong><font color="dark" red>位移极化：</font></strong>在外加电场的作用下无极分子正、负电荷中心发生相对位移，形成的电偶极矩称为感生电矩</p><p><strong><font color="dark" red>取向极化：</font></strong>在外加电场作用下分子的固有电矩受力矩作用，力图使分子旋转到与外场相同的方向上，温度越低极化效应越显著</p><blockquote><p>注：取向极化是有极分子特有的；位移极化在任何电介质中都存在</p></blockquote><p><strong><font color="dark" red>电极化强度$P$：</font></strong>$P$等于单位体积内电偶极矩的矢量和，单位$C\cdot m^{-2}$，<font size="4rem">$P=\frac{\mathrm{\Sigma}p_i}{\mathrm{\Delta V}}$</font>（$P$是宏观量）</p><p><strong><font color="dark" red>极化电荷（束缚电荷）：</font></strong>电介质的某些部位出现因极化而产生的电荷（不是自由电荷）</p><blockquote><p>注：物理性质均匀的电介质，极化电荷集中在电介质表面，电介质内没有静电荷；电介质的电极化程度越高，电介质表面的极化电荷面密度越大</p></blockquote><p><strong><font color="dark" red>退极化场：</font></strong><font size="4rem">$E=E_0-E^\prime=\frac{E_0}{\varepsilon_r}$</font></p><p><strong><font color="dark" red>有电介质时的高斯定理：</font></strong></p><p><img src="https://i.loli.net/2020/05/22/oK7MEx5k28ueQ1Z.png" alt="10.png"></p><p>通过任意闭合曲面的电位移通量，等于该闭合曲面所包围的自由电荷的代数和</p><p><strong><font color="dark" red>电场边界条件：</font></strong>在界面无自由电荷的情况下，界面两侧的</p><ul><li><strong>电位移法</strong>向分量连续，切向分量不连续；</li><li><strong>电场强度</strong>切向分量连续，法向分量不连续</li></ul><h2 id="静电场的能量"><a href="#静电场的能量" class="headerlink" title="静电场的能量"></a><font color="2F5496">静电场的能量</font></h2><p><strong><font color="dark" red>点电荷之间的相互作用能：</font></strong><font size="4rem">$W_{int}=\frac{1}{2}\left(q_1U_{12}+q_2U_{21}\right)$</font></p><p><strong><font color="dark" red>多个电荷体系的互能：</font></strong><font size="4rem">$W_{int}=\frac{1}{2}\sum_{i=1}^{N}{q_iU_i}$</font></p><p><strong><font color="dark" red>电荷连续分布带电体的静电能：</font></strong></p><ul><li><font size="4rem">$W_e=\frac{1}{2}\iiint\rho_eUdV$</font></li><li><font size="4rem">$W_e=\frac{1}{2}\iint\sigma_eUdS$</font></li><li><font size="4rem">$W_e=\frac{1}{2}\int\lambda_eUdl$</font></li></ul><p><strong><font color="dark" red>电容器的储能：</font></strong><font size="4rem">$W_e=\frac{1}{2}QU_{AB}=\frac{1}{2}CU_{AB}^2=\frac{Q^2}{2C}$</font></p><p><strong><font color="dark" red>能量密度：</font></strong></p><ul><li><font size="4rem">$w_e$</font>：电场中单位体积的能量，单位<font size="4rem">$J\cdot\ m^{-3}$</font></li><li>静电能<font size="4rem">$W_e=w_eV=\frac{1}{2}\varepsilon_0 E^2V=\frac{1}{2}D\cdot EV$</font></li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/21/bw9mDLGyX4BdVjp.jpg&quot; alt=&quot;bojack6.jpg&quot;&gt;&lt;/p&gt;
&lt;h1 id=&quot;静电场中的导体和电介质&quot;&gt;&lt;a href=&quot;#静电场中的导体和电介质&quot; class=&quot;headerlink&quot; title=&quot;静电场中的导体和电介质&quot;&gt;&lt;/a&gt;&lt;font color=&quot;2F5496&quot;&gt;静电场中的导体和电介质&lt;/font&gt;&lt;/h1&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;茗&lt;/em&gt; 与 &lt;em&gt;Guderian&lt;/em&gt; 出品 &lt;/font&gt;&lt;/p&gt;&lt;p&gt;&lt;/p&gt;
&lt;h2 id=&quot;静电场中的导体和电介质-1&quot;&gt;&lt;a href=&quot;#静电场中的导体和电介质-1&quot; class=&quot;headerlink&quot; title=&quot;静电场中的导体和电介质&quot;&gt;&lt;/a&gt;&lt;font color=&quot;2F5496&quot;&gt;静电场中的导体和电介质&lt;/font&gt;&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;静电感应：&lt;/font&gt;&lt;/strong&gt;在电场的作用下导体上的电荷重新分布的现象 &lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;感生电荷：&lt;/font&gt;&lt;/strong&gt;静电感应所产生的电荷（感生电荷代数和为零）&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;静电平衡：&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;处于静电平衡的导体内部电场强度处处为零；导体表面外附近的电场强度与导体表面垂直；&lt;/li&gt;
&lt;li&gt;处于静电平衡的导体是一个等势体；导体表面是一个等势面&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;静电平衡时导体上电荷分布：&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;静电平衡导体内各处的净电荷为零，导体自身带电或其感生电荷都只能分布于导体表面&lt;/li&gt;
&lt;li&gt;静电平衡导体表面外附近的电场强度$E$的大小与该处该处表面上的电荷面密度&lt;font size=&quot;4rem&quot;&gt;$\sigma$&lt;/font&gt;的关系为&lt;font size=&quot;4rem&quot;&gt;$E=\frac{\sigma}{\varepsilon_0}$&lt;/font&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;静电屏蔽：&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;若空腔导体内无带电体，静电平衡状态下导体腔内表面处处无电荷，电荷只分布在外表面，且腔内无电场&lt;/li&gt;
&lt;li&gt;若空腔导体内有带电体，在腔内表面出现与腔内带电体等量异号的感生电荷，外表面出现等量同号感生电荷&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;静电应用：&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;范德格拉夫起电机&lt;/li&gt;
&lt;li&gt;静电集尘&lt;/li&gt;
&lt;li&gt;静电喷漆&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&quot;电容和电容器&quot;&gt;&lt;a href=&quot;#电容和电容器&quot; class=&quot;headerlink&quot; title=&quot;电容和电容器&quot;&gt;&lt;/a&gt;&lt;font color=&quot;2F5496&quot;&gt;电容和电容器&lt;/font&gt;&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;孤立导体的电容：&lt;/font&gt;&lt;/strong&gt;&lt;font size=&quot;4rem&quot;&gt; $\frac{Q}{U}=C$  &lt;/font&gt;，$C$为电容，单位$F$（法拉），&lt;font size=&quot;4rem&quot;&gt;$1F={10}^6\mu F={10}^{12}pF$&lt;/font&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;电容器：&lt;/font&gt;&lt;/strong&gt;&lt;font size=&quot;4rem&quot;&gt;$C=\frac{Q}{U_{AB}}$&lt;/font&gt;（两极板带电分别为$+Q$,$-Q$）&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;平板电容器：&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;font size=&quot;4rem&quot;&gt;$E=\frac{\sigma}{\varepsilon_0}=\frac{Q}{\varepsilon_0S}$&lt;/font&gt;&lt;/li&gt;
&lt;li&gt;&lt;font size=&quot;4rem&quot;&gt;$U_{AB}=\int{E\cdot d\ l=Ed=\frac{Qd}{\varepsilon_0S}}$&lt;/font&gt;&lt;/li&gt;
&lt;li&gt;&lt;font size=&quot;4rem&quot;&gt;$C=\frac{Q}{U_{AB}}=\frac{\varepsilon_0S}{d}$&lt;/font&gt;

&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;圆柱形电容器：&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;font size=&quot;4rem&quot;&gt;$E=\frac{\lambda}{2\pi\varepsilon_0r}$&lt;/font&gt;（高斯定理）&lt;/li&gt;
&lt;li&gt;&lt;font size=&quot;4rem&quot;&gt;$U_{AB}=\int_{R_A}^{R_B}{E\cdot d\ r=}\frac{\lambda}{2\pi\varepsilon_0}ln\frac{R_B}{R_A}$&lt;/font&gt;&lt;/li&gt;
&lt;li&gt;&lt;font size=&quot;4rem&quot;&gt;$C=\frac{Q}{U_{AB}}=\frac{2\pi\varepsilon_0L}{ln\frac{R_B}{R_A}}$&lt;/font&gt;

&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;球形电容器：&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;font size=&quot;4rem&quot;&gt;$E=\frac{Q}{4\pi\varepsilon_0r^2}$&lt;/font&gt;&lt;/li&gt;
&lt;li&gt;&lt;font size=&quot;4rem&quot;&gt;$U_{AB}=\int_{R_A}^{R_B}{E\cdot d\ l=}\frac{Q}{4\pi\varepsilon_0}（1RA-1RB）$&lt;/font&gt;&lt;/li&gt;
&lt;li&gt;&lt;font size=&quot;4rem&quot;&gt;$C=\frac{Q}{U_{AB}}=4\pi\varepsilon_0\frac{R_A R_B}{R_B - R_A}$&lt;/font&gt;

&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;电容器并联：&lt;/font&gt;&lt;/strong&gt;&lt;font size=&quot;4rem&quot;&gt;$C=\sum_{i=1}^{N}C_i$&lt;/font&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;dark&quot; red&gt;电容器串联：&lt;/font&gt;&lt;/strong&gt;&lt;font size=&quot;4rem&quot;&gt;$\frac{1}{C}=\sum_{i=1}^{N}\frac{1}{C_i}$&lt;/font&gt;&lt;/p&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="大物" scheme="https://G-SS-Hacker.github.io/tags/%E5%A4%A7%E7%89%A9/"/>
    
  </entry>
  
  <entry>
    <title>题解：字符串模式匹配</title>
    <link href="https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E5%AD%97%E7%AC%A6%E4%B8%B2%E6%A8%A1%E5%BC%8F%E5%8C%B9%E9%85%8D/"/>
    <id>https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E5%AD%97%E7%AC%A6%E4%B8%B2%E6%A8%A1%E5%BC%8F%E5%8C%B9%E9%85%8D/</id>
    <published>2020-05-20T02:31:47.000Z</published>
    <updated>2020-05-20T02:33:58.564Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/05/20/BTbYxM4zrER3mJH.jpg" alt="批注 2020-05-20 090942.jpg"></p><h1 id="题解：字符串模式匹配"><a href="#题解：字符串模式匹配" class="headerlink" title="题解：字符串模式匹配"></a>题解：字符串模式匹配</h1><p><font color="grey"> <em>Guderian出品</em> </font></p><blockquote><p>前置知识：<a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/KMP%E7%AE%97%E6%B3%95/">KMP算法</a></p></blockquote><h2 id="说明"><a href="#说明" class="headerlink" title="说明"></a>说明</h2><p>模式匹配是指给定主串<code>t</code>和子串<code>s</code>， 在主串<code>t</code>中寻找子串<code>s</code>的过程， 其中<code>s</code>称为模式。 如果匹配成功， 返回<code>s</code>在<code>t</code>中的位置， 否则返回<code>-1</code>。 </p><h2 id="分析"><a href="#分析" class="headerlink" title="分析"></a>分析</h2><p><code>KMP</code>算法用 <code>next</code> 数组对匹配过程进行了优化。 <code>KMP</code> 算法的伪代码描述如下：</p><p>1． 在串<code>t</code>和串<code>s</code>中， 分别设比较的起始下标<code>i=j=0</code>。</p><p>2． 如果串<code>t</code>和串<code>s</code>都还有字符， 则循环执行下列操作：</p><p>（1） 如果<code>j=-l</code>或者<code>t[i]=s[j]</code>， 则将<code>i</code>和<code>j</code>分别加<code>1</code>，继续比较<code>t</code>和<code>s</code>的下一个字符；</p><p>（2） 否则， 将<code>j</code>向右滑动到<code>next[j]</code>的位置， 即<code>j=next[j]</code>。</p><p>3． 如果<code>s</code>中所有字符均已比较完毕， 则返回匹配的起始位置（从<code>1</code>开始） ； 否则返回<code>-1</code>．其中， <code>next</code>数组根据子串<code>s</code>求解。 求解<code>next</code>数组的代码已由<code>get_next</code>函数给出。 </p><a id="more"></a><h2 id="实现"><a href="#实现" class="headerlink" title="实现"></a>实现</h2><p><strong><font color="#012060">（1）常量和变量说明</font></strong></p><p><code>t</code>，<code>s</code>：长度为<code>lt</code>和<code>ls</code>的字符串</p><p><code>next[]</code>：<code>next</code>数组，长度为<code>ls</code></p><p><strong><font color="#012060">（2）C语言程序</font></strong></p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdlib.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;string.h&gt;</span></span></span><br><span class="line"></span><br><span class="line"><span class="comment">/*求 next[]的值*/</span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">get_next</span><span class="params">( <span class="keyword">int</span> *next, <span class="keyword">char</span> *s, <span class="keyword">int</span> ls)</span> </span>&#123;</span><br><span class="line">    <span class="keyword">int</span> i=<span class="number">0</span>, j=<span class="number">-1</span>;</span><br><span class="line">    next[<span class="number">0</span>]=<span class="number">-1</span>;<span class="comment">/*初始化 next[0]*/</span></span><br><span class="line">    <span class="keyword">while</span>(i &lt; ls)&#123;<span class="comment">/*还有字符*/</span></span><br><span class="line">        <span class="keyword">if</span>(j==<span class="number">-1</span> || s[i]==s[j])&#123;<span class="comment">/*匹配*/</span></span><br><span class="line">            j++;</span><br><span class="line">            i++;</span><br><span class="line">            <span class="keyword">if</span>(s[i]==s[j])</span><br><span class="line">                next[i]=next[j];</span><br><span class="line">            <span class="keyword">else</span></span><br><span class="line">                next[i]=j;</span><br><span class="line">        &#125;</span><br><span class="line">        <span class="keyword">else</span></span><br><span class="line">            j=next[j];</span><br><span class="line">    &#125;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">kmp</span><span class="params">( <span class="keyword">int</span> *next, <span class="keyword">char</span> *t,<span class="keyword">char</span> *s, <span class="keyword">int</span> lt, <span class="keyword">int</span> ls )</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">int</span> i= <span class="number">0</span>,j =<span class="number">0</span> ;</span><br><span class="line">    <span class="keyword">while</span> (i &lt; lt &amp;&amp; j &lt; ls)</span><br><span class="line">    &#123;</span><br><span class="line">        <span class="keyword">if</span>( j==<span class="number">-1</span> || t[i]==s[j] )</span><br><span class="line">        &#123;</span><br><span class="line">            i ++ ;</span><br><span class="line">            j ++ ;</span><br><span class="line">        &#125;</span><br><span class="line">        <span class="keyword">else</span></span><br><span class="line">            j=next[j];</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="keyword">if</span> (j &gt;= ls)</span><br><span class="line">        <span class="keyword">return</span> i+<span class="number">1</span>-ls;</span><br><span class="line">    <span class="keyword">else</span></span><br><span class="line">        <span class="keyword">return</span> <span class="number">-1</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong><font color="#012060">（3）复杂度分析</font></strong></p><ul><li>时间复杂度：$O(ls+lt)$<ul><li>预处理$ O(ls)$，匹配$ O(lt)$</li></ul></li><li>空间复杂度：$O(ls)$</li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/20/BTbYxM4zrER3mJH.jpg&quot; alt=&quot;批注 2020-05-20 090942.jpg&quot;&gt;&lt;/p&gt;
&lt;h1 id=&quot;题解：字符串模式匹配&quot;&gt;&lt;a href=&quot;#题解：字符串模式匹配&quot; class=&quot;headerlink&quot; title=&quot;题解：字符串模式匹配&quot;&gt;&lt;/a&gt;题解：字符串模式匹配&lt;/h1&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian出品&lt;/em&gt; &lt;/font&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;前置知识：&lt;a href=&quot;https://g-ss-hacker.github.io/G-SS-Hacker.github.io/KMP%E7%AE%97%E6%B3%95/&quot;&gt;KMP算法&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&quot;说明&quot;&gt;&lt;a href=&quot;#说明&quot; class=&quot;headerlink&quot; title=&quot;说明&quot;&gt;&lt;/a&gt;说明&lt;/h2&gt;&lt;p&gt;模式匹配是指给定主串&lt;code&gt;t&lt;/code&gt;和子串&lt;code&gt;s&lt;/code&gt;， 在主串&lt;code&gt;t&lt;/code&gt;中寻找子串&lt;code&gt;s&lt;/code&gt;的过程， 其中&lt;code&gt;s&lt;/code&gt;称为模式。 如果匹配成功， 返回&lt;code&gt;s&lt;/code&gt;在&lt;code&gt;t&lt;/code&gt;中的位置， 否则返回&lt;code&gt;-1&lt;/code&gt;。 &lt;/p&gt;
&lt;h2 id=&quot;分析&quot;&gt;&lt;a href=&quot;#分析&quot; class=&quot;headerlink&quot; title=&quot;分析&quot;&gt;&lt;/a&gt;分析&lt;/h2&gt;&lt;p&gt;&lt;code&gt;KMP&lt;/code&gt;算法用 &lt;code&gt;next&lt;/code&gt; 数组对匹配过程进行了优化。 &lt;code&gt;KMP&lt;/code&gt; 算法的伪代码描述如下：&lt;/p&gt;
&lt;p&gt;1． 在串&lt;code&gt;t&lt;/code&gt;和串&lt;code&gt;s&lt;/code&gt;中， 分别设比较的起始下标&lt;code&gt;i=j=0&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;2． 如果串&lt;code&gt;t&lt;/code&gt;和串&lt;code&gt;s&lt;/code&gt;都还有字符， 则循环执行下列操作：&lt;/p&gt;
&lt;p&gt;（1） 如果&lt;code&gt;j=-l&lt;/code&gt;或者&lt;code&gt;t[i]=s[j]&lt;/code&gt;， 则将&lt;code&gt;i&lt;/code&gt;和&lt;code&gt;j&lt;/code&gt;分别加&lt;code&gt;1&lt;/code&gt;，继续比较&lt;code&gt;t&lt;/code&gt;和&lt;code&gt;s&lt;/code&gt;的下一个字符；&lt;/p&gt;
&lt;p&gt;（2） 否则， 将&lt;code&gt;j&lt;/code&gt;向右滑动到&lt;code&gt;next[j]&lt;/code&gt;的位置， 即&lt;code&gt;j=next[j]&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;3． 如果&lt;code&gt;s&lt;/code&gt;中所有字符均已比较完毕， 则返回匹配的起始位置（从&lt;code&gt;1&lt;/code&gt;开始） ； 否则返回&lt;code&gt;-1&lt;/code&gt;．其中， &lt;code&gt;next&lt;/code&gt;数组根据子串&lt;code&gt;s&lt;/code&gt;求解。 求解&lt;code&gt;next&lt;/code&gt;数组的代码已由&lt;code&gt;get_next&lt;/code&gt;函数给出。 &lt;/p&gt;
    
    </summary>
    
    
      <category term="题解" scheme="https://G-SS-Hacker.github.io/categories/%E9%A2%98%E8%A7%A3/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
      <category term="算法" scheme="https://G-SS-Hacker.github.io/tags/%E7%AE%97%E6%B3%95/"/>
    
  </entry>
  
  <entry>
    <title>题解：找出假币</title>
    <link href="https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E6%89%BE%E5%87%BA%E5%81%87%E5%B8%81/"/>
    <id>https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E6%89%BE%E5%87%BA%E5%81%87%E5%B8%81/</id>
    <published>2020-05-20T01:12:06.000Z</published>
    <updated>2020-05-20T01:13:10.524Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/05/20/J1aFGUHLrijpDIn.jpg" alt="批注 2020-05-20 090515.jpg"></p><h1 id="题解：找出假币"><a href="#题解：找出假币" class="headerlink" title="题解：找出假币"></a>题解：找出假币</h1><p><font color="grey"> <em>Guderian出品</em> </font></p><h2 id="说明"><a href="#说明" class="headerlink" title="说明"></a>说明</h2><p>假币问题： 有$ n $枚硬币， 其中有一枚是假币， 己知假币的重量较轻。 现只有一个天平， 要求用尽量少的比较次数找出这枚假币。 </p><h2 id="分析"><a href="#分析" class="headerlink" title="分析"></a>分析</h2><p><strong><font color="#012060">算法设计策略：分治法</font></strong></p><p>将 n 枚硬币分成相等的两部分:</p><p>(1)当$ n $为偶数时， 将前后两部分， 即$ 1…n/2 $和$ n/2+1…n$， 放在天平的两端， 较轻的一端里有假币， 继续在较轻的这部分硬币中用同样的方法找出假币:</p><p>(2)当$ n $为奇数时， 将前后两部分， 即$1..(n -1)/2$和$(n+1)/2+1…n$， 放在天平的两端， 较轻的一端里有假币， 继续在较轻的这部分硬币中用同样的方法找出假币； 若两端重量相等， 则中间的硬币， 即第$ (n+1)/2 $枚硬币是假币。 </p><h2 id="实现"><a href="#实现" class="headerlink" title="实现"></a>实现</h2><p><strong><font color="#012060">（1）常量和变量说明</font></strong></p><p><code>coins[]</code>：硬币数组</p><p><code>first</code>，<code>last</code>：当前考虑的硬币数组中的第一个和最后一个下标</p><a id="more"></a><p><strong><font color="#012060">（2）C语言程序</font></strong></p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;stdio.h&gt; </span></span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">getCounterfeitCoin</span><span class="params">(<span class="keyword">int</span> coins[],<span class="keyword">int</span> first,<span class="keyword">int</span> last)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">int</span> firstSum = <span class="number">0</span>,lastSum = <span class="number">0</span>;</span><br><span class="line">    <span class="keyword">int</span> ì;</span><br><span class="line">    <span class="keyword">if</span>(first==last<span class="number">-1</span>)&#123; <span class="comment">/*只剩两枚硬币*/</span></span><br><span class="line">        <span class="keyword">if</span>(coins[first] &lt; coins[last])</span><br><span class="line">            <span class="keyword">return</span> first;</span><br><span class="line">        <span class="keyword">return</span> last;</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="keyword">if</span>((last - first + <span class="number">1</span>) % <span class="number">2</span> ==<span class="number">0</span>)&#123; <span class="comment">/*偶数枚硬币*/</span></span><br><span class="line">        <span class="keyword">for</span>(i = first;i &lt;first+(last-first)/<span class="number">2</span>+<span class="number">1</span>;i++)&#123;</span><br><span class="line">            firstSum += coins[i];</span><br><span class="line">        &#125;</span><br><span class="line">        <span class="keyword">for</span>(i=first + (last-first) / <span class="number">2</span> + <span class="number">1</span>;i &lt; last +<span class="number">1</span>;i++)&#123;</span><br><span class="line">            lastSum += coins[i];</span><br><span class="line">        &#125;</span><br><span class="line">        <span class="keyword">if</span>(firstSum&lt;lastSum)&#123;</span><br><span class="line">            <span class="keyword">return</span> getCounterfeitCoin(coins,first,first+(last-first)/<span class="number">2</span>);</span><br><span class="line">        &#125;<span class="keyword">else</span>&#123;</span><br><span class="line">            <span class="keyword">return</span> getCounterfeitCoin(coins,first+(last-first)/<span class="number">2</span>+<span class="number">1</span>,last);</span><br><span class="line">        &#125;</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="keyword">else</span>&#123; <span class="comment">/*奇数枚硬币*/</span></span><br><span class="line">        <span class="keyword">for</span>(i=first;i&lt;first+(last-first)/<span class="number">2</span>;i++)&#123;</span><br><span class="line">            firstSum+=coins[i];</span><br><span class="line">        &#125;</span><br><span class="line">        <span class="keyword">for</span>(i=first+(last-first)/<span class="number">2</span>+<span class="number">1</span>;i&lt;last+<span class="number">1</span>;i++)&#123;</span><br><span class="line">            lastSum+=coins[i];</span><br><span class="line">        &#125;</span><br><span class="line">        <span class="keyword">if</span>(firstSum&lt;lastSum)&#123;</span><br><span class="line">            <span class="keyword">return</span> getCounterfeitCoin(coins,first,first+(last-first)/<span class="number">2</span><span class="number">-1</span>);</span><br><span class="line">        &#125;<span class="keyword">else</span> <span class="keyword">if</span>(firstSum&gt;lastSum)&#123;</span><br><span class="line">            <span class="keyword">return</span> getCounterfeitCoin(coins,first+(last-first)/<span class="number">2</span>+<span class="number">1</span>,last);</span><br><span class="line">        &#125;<span class="keyword">else</span>&#123;</span><br><span class="line">            <span class="keyword">return</span> first+(last-first)/<span class="number">2</span>;</span><br><span class="line">        &#125;</span><br><span class="line">    &#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><blockquote><p>例：若输入的硬币数为30， 则最少的比较次数为2 ， 最多的比较次数为4。</p></blockquote><p><strong><font color="#012060">（3）复杂度分析</font></strong></p><ul><li>时间复杂度：$O(n\log n)$<ul><li><strong><font color="red">二分法</font></strong>本身耗时$O(\log n)$，<strong><font color="red">每次顺序求和操作</font></strong>耗时$O(n)$，总计时间复杂度$O(n\log n)$</li></ul></li><li>空间复杂度：$O( n )$</li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/20/J1aFGUHLrijpDIn.jpg&quot; alt=&quot;批注 2020-05-20 090515.jpg&quot;&gt;&lt;/p&gt;
&lt;h1 id=&quot;题解：找出假币&quot;&gt;&lt;a href=&quot;#题解：找出假币&quot; class=&quot;headerlink&quot; title=&quot;题解：找出假币&quot;&gt;&lt;/a&gt;题解：找出假币&lt;/h1&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian出品&lt;/em&gt; &lt;/font&gt;&lt;/p&gt;

&lt;h2 id=&quot;说明&quot;&gt;&lt;a href=&quot;#说明&quot; class=&quot;headerlink&quot; title=&quot;说明&quot;&gt;&lt;/a&gt;说明&lt;/h2&gt;&lt;p&gt;假币问题： 有$ n $枚硬币， 其中有一枚是假币， 己知假币的重量较轻。 现只有一个天平， 要求用尽量少的比较次数找出这枚假币。 &lt;/p&gt;
&lt;h2 id=&quot;分析&quot;&gt;&lt;a href=&quot;#分析&quot; class=&quot;headerlink&quot; title=&quot;分析&quot;&gt;&lt;/a&gt;分析&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;#012060&quot;&gt;算法设计策略：分治法&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;将 n 枚硬币分成相等的两部分:&lt;/p&gt;
&lt;p&gt;(1)当$ n $为偶数时， 将前后两部分， 即$ 1…n/2 $和$ n/2+1…n$， 放在天平的两端， 较轻的一端里有假币， 继续在较轻的这部分硬币中用同样的方法找出假币:&lt;/p&gt;
&lt;p&gt;(2)当$ n $为奇数时， 将前后两部分， 即$1..(n -1)/2$和$(n+1)/2+1…n$， 放在天平的两端， 较轻的一端里有假币， 继续在较轻的这部分硬币中用同样的方法找出假币； 若两端重量相等， 则中间的硬币， 即第$ (n+1)/2 $枚硬币是假币。 &lt;/p&gt;
&lt;h2 id=&quot;实现&quot;&gt;&lt;a href=&quot;#实现&quot; class=&quot;headerlink&quot; title=&quot;实现&quot;&gt;&lt;/a&gt;实现&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;#012060&quot;&gt;（1）常量和变量说明&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;coins[]&lt;/code&gt;：硬币数组&lt;/p&gt;
&lt;p&gt;&lt;code&gt;first&lt;/code&gt;，&lt;code&gt;last&lt;/code&gt;：当前考虑的硬币数组中的第一个和最后一个下标&lt;/p&gt;
    
    </summary>
    
    
      <category term="题解" scheme="https://G-SS-Hacker.github.io/categories/%E9%A2%98%E8%A7%A3/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
      <category term="算法" scheme="https://G-SS-Hacker.github.io/tags/%E7%AE%97%E6%B3%95/"/>
    
  </entry>
  
  <entry>
    <title>题解：求解无向图上的哈密尔顿回路</title>
    <link href="https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E6%B1%82%E8%A7%A3%E6%97%A0%E5%90%91%E5%9B%BE%E4%B8%8A%E7%9A%84%E5%93%88%E5%AF%86%E5%B0%94%E9%A1%BF%E5%9B%9E%E8%B7%AF/"/>
    <id>https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E6%B1%82%E8%A7%A3%E6%97%A0%E5%90%91%E5%9B%BE%E4%B8%8A%E7%9A%84%E5%93%88%E5%AF%86%E5%B0%94%E9%A1%BF%E5%9B%9E%E8%B7%AF/</id>
    <published>2020-05-19T13:33:18.000Z</published>
    <updated>2020-05-19T13:37:48.632Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://s1.ax1x.com/2020/05/19/YIykSU.jpg" alt="YIykSU.jpg"></p><h1 id="题解：求解无向图上的哈密尔顿回路"><a href="#题解：求解无向图上的哈密尔顿回路" class="headerlink" title="题解：求解无向图上的哈密尔顿回路"></a>题解：求解无向图上的哈密尔顿回路</h1><p><font color="grey"> <em>Guderian出品</em> </font></p><h2 id="说明"><a href="#说明" class="headerlink" title="说明"></a>说明</h2><p>一个无向连通图$ G $点上的哈密尔顿（Hamiltion） 回路是指从图$ G $上的某个顶点出发， 经过图上所有其他顶点一次且仅一次， 最后回到该顶点的路径。  </p><h2 id="分析"><a href="#分析" class="headerlink" title="分析"></a>分析</h2><p><strong><font color="#012060">算法设计策略：回溯法+深度优先搜索+记忆化搜索</font></strong></p><p>假设图$ G $存在一个从顶点$ V_0 $出发的哈密尔顿回路$ V_1-V_2-V_3-…-V_{n-1}-V_0$。算法从顶点$ V_0 $出发， 访问该顶点的一个未被访问的邻接顶点$ V_1$， 接着从顶点$ V_1 $出发， 访问$ V_1 $一个未被访问的邻接顶点$ V_2$，以此类推。对顶点$ V_i$， 重复进行以下操作： 访问$ V_i $的一个未被访问的邻接接点$ V_{i+1}$； 若$ V_i $的所有邻接顶点均已被访问， 则返回到顶点$ V_{i-1}$， 考虑$V_{i-1} $的下一个未被访问的邻接顶点， 仍记为$ V_i$； 知道找到一条哈密尔顿回路或者找不到哈密尔顿回路， 算法结束。 </p><h2 id="实现"><a href="#实现" class="headerlink" title="实现"></a>实现</h2><p><strong><font color="#012060">（1）常量和变量说明</font></strong></p><p><code>n</code>：图$G$中的顶点数</p><p><code>c[][]</code>：图$G$的邻接矩阵</p><p><code>k</code>：统计变量，当前已经访问的顶点数为<code>k+1</code></p><p><code>x[k]</code>：第<code>k</code>个访问的顶点编号，从<code>0</code>开始</p><p><code>visited[x[k]]</code>：第<code>k</code>个顶点的访问标志，<code>0</code>表示未访问，<code>1</code>表示已访问</p><a id="more"></a><p><strong><font color="#012060">（2）C语言程序</font></strong></p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;stdio.h&gt; </span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;stdlib.h&gt; </span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> MAX 4  </span></span><br><span class="line"><span class="function">Void <span class="title">Hamilton</span><span class="params">(<span class="keyword">int</span> n,<span class="keyword">int</span> x[MAX],<span class="keyword">int</span> c[MAX][MAX])</span></span>&#123;</span><br><span class="line">    <span class="keyword">int</span> i; </span><br><span class="line">    <span class="keyword">int</span> visited[MAX]; </span><br><span class="line">    <span class="keyword">int</span> k; <span class="comment">/*初始化x数组和visited数组*/</span> </span><br><span class="line">    <span class="keyword">for</span>(i=<span class="number">0</span>;i&lt;n;i++)&#123; </span><br><span class="line">        x[i]=<span class="number">0</span>; </span><br><span class="line">        Visited[i]=<span class="number">0</span>; </span><br><span class="line">    &#125; </span><br><span class="line">    <span class="comment">/*访问起初顶点*/</span> </span><br><span class="line">    k=<span class="number">0</span>;   </span><br><span class="line">    visited[<span class="number">0</span>]=<span class="number">1</span>;</span><br><span class="line">    x[<span class="number">0</span>]=<span class="number">0</span>; </span><br><span class="line">    k=k+<span class="number">1</span>; </span><br><span class="line">    <span class="comment">/*访问其它顶点*/</span> </span><br><span class="line">    <span class="keyword">while</span>(k&gt;<span class="number">0</span>)&#123; </span><br><span class="line">        x[k]=x[k]+<span class="number">1</span>; </span><br><span class="line">        <span class="keyword">while</span>(x[k]&lt;n)&#123; </span><br><span class="line">            <span class="keyword">if</span>(visited[x[k]]==<span class="number">0</span> &amp;&amp;c[x[k<span class="number">-1</span>]][x[k]]==<span class="number">1</span>)&#123;<span class="comment">/*邻接顶点x[k]未被访问过*/</span> </span><br><span class="line">                <span class="keyword">break</span>;</span><br><span class="line">            &#125; </span><br><span class="line">            <span class="keyword">else</span>&#123; </span><br><span class="line">                x[k]=x[k]+<span class="number">1</span>; </span><br><span class="line">            &#125; </span><br><span class="line">        &#125; </span><br><span class="line">        <span class="keyword">if</span>(x[k]&lt;n&amp;&amp;k==n<span class="number">-1</span>&amp;&amp;c[x[<span class="number">0</span>]][x[k]]==<span class="number">1</span>)&#123;<span class="comment">/*找到一条哈密尔顿回路*/</span> </span><br><span class="line">            <span class="keyword">for</span>(k=<span class="number">0</span>;k&lt;n;k++)&#123; </span><br><span class="line">                <span class="built_in">printf</span>(“%d--”,x[k]);<span class="comment">/*输出哈密尔顿回路*/</span> </span><br><span class="line">            &#125; </span><br><span class="line">            <span class="built_in">printf</span>(“%d\n”,x[<span class="number">0</span>]); </span><br><span class="line">            <span class="keyword">return</span>; </span><br><span class="line">        &#125; </span><br><span class="line">        <span class="keyword">else</span> <span class="keyword">if</span>(x[k]&amp;&amp;k&lt;n<span class="number">-1</span>)&#123;<span class="comment">/*设置当前顶点的访问标志，继续下一个顶点*/</span>    </span><br><span class="line">            visited[x[k]]=<span class="number">1</span>  ; </span><br><span class="line">            k=k+<span class="number">1</span>; </span><br><span class="line">        &#125; </span><br><span class="line">        <span class="keyword">else</span> &#123;<span class="comment">/*没有未被访问过的领接顶点，回退到上一个顶点*/</span> </span><br><span class="line">            x[k]=<span class="number">0</span>; </span><br><span class="line">            visited[x[k]]=<span class="number">0</span>;    </span><br><span class="line">            k=k<span class="number">-1</span> ; </span><br><span class="line">        &#125; </span><br><span class="line">    &#125; </span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong><font color="#012060">（3）复杂度分析</font></strong></p><ul><li>时间复杂度：$O(n^n)$<strong><font color="red">（爆搜）</font></strong></li><li>空间复杂度：$O( n ^2)$</li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://s1.ax1x.com/2020/05/19/YIykSU.jpg&quot; alt=&quot;YIykSU.jpg&quot;&gt;&lt;/p&gt;
&lt;h1 id=&quot;题解：求解无向图上的哈密尔顿回路&quot;&gt;&lt;a href=&quot;#题解：求解无向图上的哈密尔顿回路&quot; class=&quot;headerlink&quot; title=&quot;题解：求解无向图上的哈密尔顿回路&quot;&gt;&lt;/a&gt;题解：求解无向图上的哈密尔顿回路&lt;/h1&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian出品&lt;/em&gt; &lt;/font&gt;&lt;/p&gt;

&lt;h2 id=&quot;说明&quot;&gt;&lt;a href=&quot;#说明&quot; class=&quot;headerlink&quot; title=&quot;说明&quot;&gt;&lt;/a&gt;说明&lt;/h2&gt;&lt;p&gt;一个无向连通图$ G $点上的哈密尔顿（Hamiltion） 回路是指从图$ G $上的某个顶点出发， 经过图上所有其他顶点一次且仅一次， 最后回到该顶点的路径。  &lt;/p&gt;
&lt;h2 id=&quot;分析&quot;&gt;&lt;a href=&quot;#分析&quot; class=&quot;headerlink&quot; title=&quot;分析&quot;&gt;&lt;/a&gt;分析&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;#012060&quot;&gt;算法设计策略：回溯法+深度优先搜索+记忆化搜索&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;假设图$ G $存在一个从顶点$ V_0 $出发的哈密尔顿回路$ V_1-V_2-V_3-…-V_{n-1}-V_0$。算法从顶点$ V_0 $出发， 访问该顶点的一个未被访问的邻接顶点$ V_1$， 接着从顶点$ V_1 $出发， 访问$ V_1 $一个未被访问的邻接顶点$ V_2$，以此类推。对顶点$ V_i$， 重复进行以下操作： 访问$ V_i $的一个未被访问的邻接接点$ V_{i+1}$； 若$ V_i $的所有邻接顶点均已被访问， 则返回到顶点$ V_{i-1}$， 考虑$V_{i-1} $的下一个未被访问的邻接顶点， 仍记为$ V_i$； 知道找到一条哈密尔顿回路或者找不到哈密尔顿回路， 算法结束。 &lt;/p&gt;
&lt;h2 id=&quot;实现&quot;&gt;&lt;a href=&quot;#实现&quot; class=&quot;headerlink&quot; title=&quot;实现&quot;&gt;&lt;/a&gt;实现&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;#012060&quot;&gt;（1）常量和变量说明&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;n&lt;/code&gt;：图$G$中的顶点数&lt;/p&gt;
&lt;p&gt;&lt;code&gt;c[][]&lt;/code&gt;：图$G$的邻接矩阵&lt;/p&gt;
&lt;p&gt;&lt;code&gt;k&lt;/code&gt;：统计变量，当前已经访问的顶点数为&lt;code&gt;k+1&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;x[k]&lt;/code&gt;：第&lt;code&gt;k&lt;/code&gt;个访问的顶点编号，从&lt;code&gt;0&lt;/code&gt;开始&lt;/p&gt;
&lt;p&gt;&lt;code&gt;visited[x[k]]&lt;/code&gt;：第&lt;code&gt;k&lt;/code&gt;个顶点的访问标志，&lt;code&gt;0&lt;/code&gt;表示未访问，&lt;code&gt;1&lt;/code&gt;表示已访问&lt;/p&gt;
    
    </summary>
    
    
      <category term="题解" scheme="https://G-SS-Hacker.github.io/categories/%E9%A2%98%E8%A7%A3/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
      <category term="算法" scheme="https://G-SS-Hacker.github.io/tags/%E7%AE%97%E6%B3%95/"/>
    
      <category term="数据结构" scheme="https://G-SS-Hacker.github.io/tags/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/"/>
    
  </entry>
  
  <entry>
    <title>题解：切割钢条</title>
    <link href="https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E5%88%87%E5%89%B2%E9%92%A2%E6%9D%A1/"/>
    <id>https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E5%88%87%E5%89%B2%E9%92%A2%E6%9D%A1/</id>
    <published>2020-05-18T05:00:19.000Z</published>
    <updated>2020-05-18T05:00:56.628Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/05/18/k6lIfuVKJMeCq5B.png" alt="微信截图_20200518125348.png"></p><h1 id="题解：切割钢条"><a href="#题解：切割钢条" class="headerlink" title="题解：切割钢条"></a>题解：切割钢条</h1><blockquote><p>故宫 by Gigi</p></blockquote><p><font color="grey"> <em>Guderian出品</em> </font></p><h2 id="说明"><a href="#说明" class="headerlink" title="说明"></a>说明</h2><p>某公司购买长钢条，将其切割后进行出售。切割钢条的成本可以忽略不计，钢条的长度为整英寸。已知价格表$ P$，其中中 $P_i（i＝1，2，…，m）$表示长度为$i$英寸的钢条的价格。现要求解使销售收益最大的切割方案 。</p><h2 id="分析"><a href="#分析" class="headerlink" title="分析"></a>分析</h2><p><strong><font color="#012060">算法设计策略：动态规划</font></strong></p><p>假设长钢条的长度为$ n $英寸，最佳切割方案的最左边切割段长度为$ i $英寸，则继续求解剩余长度为$ n－i $英寸钢条的最佳切割方案。考虑所有可能的$ i$，得到的最大收益$ r_n$对应的切割方案即为最佳切割方案。$r_n$的递归定义如下：</p><script type="math/tex; mode=display">r_n =\max_{1≤ i ≤n}(p_i +r_{n-i})</script><p>对此递归式，给出<font color="dark" red>自顶向下</font>和<font color="dark" red>自底向上</font>两种实现方式。</p><a id="more"></a><h2 id="实现"><a href="#实现" class="headerlink" title="实现"></a>实现</h2><p><strong><font color="#012060">（1）常量和变量说明</font></strong></p><p><code>n</code>：长钢条的长度</p><p><code>p[]</code>：价格数组</p><p><strong><font color="#012060">（2）C语言程序</font></strong></p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> LEN 100</span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">Top_Down_Cut_Rod</span><span class="params">(<span class="keyword">int</span> p[],<span class="keyword">int</span> n)</span></span>&#123; <span class="comment">/*自顶向下*/</span></span><br><span class="line">    <span class="keyword">int</span> r=<span class="number">0</span>;</span><br><span class="line">    <span class="keyword">int</span> i;</span><br><span class="line">    <span class="keyword">if</span>(n==<span class="number">0</span>)&#123;</span><br><span class="line">        <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="keyword">for</span>(i=<span class="number">1</span>;i&lt;=n;i++)&#123;</span><br><span class="line">        <span class="keyword">int</span> tmp=p[i]+Top_Down_Cut_Rod(p,n-i);</span><br><span class="line">        r= (r&gt;=tmp) ? r : tmp;</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="keyword">return</span> r;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">Bottom_Up_Cut_Rod</span><span class="params">(<span class="keyword">int</span> p[],<span class="keyword">int</span> n)</span></span>&#123; <span class="comment">/*自底向上*/</span></span><br><span class="line">    <span class="keyword">int</span> r[LEN]=&#123;<span class="number">0</span>&#125;;</span><br><span class="line">    <span class="keyword">int</span> temp=<span class="number">0</span>;</span><br><span class="line">    <span class="keyword">int</span> i,j;</span><br><span class="line">    <span class="keyword">for</span>(j=<span class="number">1</span>;j&lt;=n;j++)&#123;</span><br><span class="line">        temp=<span class="number">0</span>;</span><br><span class="line">        <span class="keyword">for</span>(i=<span class="number">1</span>;i&lt;=j;i++)&#123;</span><br><span class="line">            temp=(temp&gt;=p[i]+r[j-i]) ? temp : (p[i]+r[j-i]);</span><br><span class="line">        &#125;</span><br><span class="line">        r[j]=(temp&gt;=p[j]) ? temp : p[j];</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="keyword">return</span> r[n];</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="comment">/*示例数据*/</span></span><br><span class="line">    <span class="keyword">int</span> p[<span class="number">11</span>]=&#123;<span class="number">0</span>,<span class="number">1</span>,<span class="number">2</span>,<span class="number">1</span>,<span class="number">8</span>,<span class="number">3</span>,<span class="number">5</span>,<span class="number">2</span>,<span class="number">5</span>,<span class="number">3</span>,<span class="number">9</span>&#125;;</span><br><span class="line">    <span class="keyword">int</span> a = Top_Down_Cut_Rod(p,<span class="number">10</span>);</span><br><span class="line">    <span class="keyword">int</span> b = Bottom_Up_Cut_Rod(p,<span class="number">10</span>);</span><br><span class="line">    <span class="built_in">printf</span>(<span class="string">"%d %d\n"</span>,a,b);</span><br><span class="line">    <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong><font color="#012060">（3）复杂度分析</font></strong></p><ul><li><p><font color="dark" red>自顶向下（爆搜）</font></p><ul><li>时间复杂度：$O(2^n)$</li><li>空间复杂度：$O(1)$</li></ul></li><li><p><font color="dark" red>自底向上</font></p><ul><li>时间复杂度：$O(n^2)$</li><li>空间复杂度：$O(n)$</li></ul></li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/18/k6lIfuVKJMeCq5B.png&quot; alt=&quot;微信截图_20200518125348.png&quot;&gt;&lt;/p&gt;
&lt;h1 id=&quot;题解：切割钢条&quot;&gt;&lt;a href=&quot;#题解：切割钢条&quot; class=&quot;headerlink&quot; title=&quot;题解：切割钢条&quot;&gt;&lt;/a&gt;题解：切割钢条&lt;/h1&gt;&lt;blockquote&gt;
&lt;p&gt;故宫 by Gigi&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian出品&lt;/em&gt; &lt;/font&gt;&lt;/p&gt;

&lt;h2 id=&quot;说明&quot;&gt;&lt;a href=&quot;#说明&quot; class=&quot;headerlink&quot; title=&quot;说明&quot;&gt;&lt;/a&gt;说明&lt;/h2&gt;&lt;p&gt;某公司购买长钢条，将其切割后进行出售。切割钢条的成本可以忽略不计，钢条的长度为整英寸。已知价格表$ P$，其中中 $P_i（i＝1，2，…，m）$表示长度为$i$英寸的钢条的价格。现要求解使销售收益最大的切割方案 。&lt;/p&gt;
&lt;h2 id=&quot;分析&quot;&gt;&lt;a href=&quot;#分析&quot; class=&quot;headerlink&quot; title=&quot;分析&quot;&gt;&lt;/a&gt;分析&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;#012060&quot;&gt;算法设计策略：动态规划&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;假设长钢条的长度为$ n $英寸，最佳切割方案的最左边切割段长度为$ i $英寸，则继续求解剩余长度为$ n－i $英寸钢条的最佳切割方案。考虑所有可能的$ i$，得到的最大收益$ r_n$对应的切割方案即为最佳切割方案。$r_n$的递归定义如下：&lt;/p&gt;
&lt;script type=&quot;math/tex; mode=display&quot;&gt;
r_n =\max_{1≤ i ≤n}(p_i +r_{n-i})&lt;/script&gt;&lt;p&gt;对此递归式，给出&lt;font color=&quot;dark&quot; red&gt;自顶向下&lt;/font&gt;和&lt;font color=&quot;dark&quot; red&gt;自底向上&lt;/font&gt;两种实现方式。&lt;/p&gt;
    
    </summary>
    
    
      <category term="题解" scheme="https://G-SS-Hacker.github.io/categories/%E9%A2%98%E8%A7%A3/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
      <category term="算法" scheme="https://G-SS-Hacker.github.io/tags/%E7%AE%97%E6%B3%95/"/>
    
  </entry>
  
  <entry>
    <title>题解：字符配对</title>
    <link href="https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E5%AD%97%E7%AC%A6%E9%85%8D%E5%AF%B9/"/>
    <id>https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9A%E5%AD%97%E7%AC%A6%E9%85%8D%E5%AF%B9/</id>
    <published>2020-05-18T02:34:13.000Z</published>
    <updated>2020-05-18T03:43:52.160Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/05/18/Z7wS1oQqyAaNkfG.jpg" alt="aurora.jpg"></p><h1 id="题解：字符配对"><a href="#题解：字符配对" class="headerlink" title="题解：字符配对"></a>题解：字符配对</h1><blockquote><p>Aurora</p></blockquote><p></p><p><font color="grey"> <em>Guderian出品</em> </font></p><p></p><h2 id="说明"><a href="#说明" class="headerlink" title="说明"></a>说明</h2><p>给定一个字符$B=b_1 b_2\dots b_n$，其中$b_i \in \{A,C,G,U\}$。$B$上的二级结构是一组字符对集合$S=\{(b_i,b_j)\}$，其中$i,j\in \{1,2,\dots ,n\}$，并满足以下四个条件：</p><p>（1）$S$中的每对字符是$(A,U),(U,A),(C,G),(G,C)$四种组合之一；</p><p>（2）$S$中的每对字符之间至少有四个字符将其隔开，即$i&lt;j-4$；</p><p>（3）$S$中的每一个字符（记为$b_k$）的配对存在两种情况：$b_k$不参与任何配对；$b_k$和$b_t$配对，其中$t&lt;k-4$；</p><p>（4）（不交叉原则）若$(b_i,b_j)$和$(b_k,b_l)$是$S$种的两个字符对，且$i&lt;k$，则$i&lt;k&lt;j&lt;l$不成立。</p><p>$B$的具有最大可能字符对数的二级结构$S$被称为最优配对方案，求解最优配对方案中的字符对数的方法如下：</p><p>假设用$C(i,j)$表示字符序列$b_i b_{i+1} \dots b_j$的最优配对方案（即二级结构$S$）中的字符对数，则$C(i,j)$可以递归定义为：</p><script type="math/tex; mode=display">C(i,j)=\begin{cases} \max(C(i,j-1),\max(C(i,t-1)+1+C(t+1,j-1))), &b_t和b_j匹配且i<j-4\\0 ，&\text{否则}\end{cases}</script><h2 id="分析"><a href="#分析" class="headerlink" title="分析"></a>分析</h2><p>题目的第3个条件容易引起歧义，一种不影响作答的理解是：<font color="blue">$B$上的字符要么不配对，要配对就要相隔至少4个字符。</font>当然可以直接忽略这个条件，因为题目已经给出了足够多的信息了。</p><p>显然题目说明最后的方程是动态规划算法中的<font color="dark" red>状态转移方程</font>，这提示我们这道题目的算法思想是<font color="dark" red>动态规划</font>。因此我们采取的做法是：<font color="blue">从较小的区间开始，转移到较大的区间，直到覆盖$B$中所有字符。</font></p><a id="more"></a><h2 id="实现"><a href="#实现" class="headerlink" title="实现"></a>实现</h2><p><strong><font color="#012060">（1）常量和变量说明</font></strong></p><p><code>n</code>：字符序列长度</p><p><code>B[]</code>：字符序列</p><p><code>C[][]</code>：最有配对数量数组</p><p><strong><font color="#012060">（2）C语言程序</font></strong></p><blockquote><p>不带主函数，未经调试</p></blockquote><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;stdlib.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> LEN 100</span></span><br><span class="line"></span><br><span class="line"><span class="comment">/*判断两个字符是否配对*/</span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">isMatch</span><span class="params">(<span class="keyword">char</span> a,<span class="keyword">char</span> b)</span> </span>&#123;</span><br><span class="line">    <span class="keyword">if</span>((a==<span class="string">'A'</span>&amp;&amp;b==<span class="string">'U'</span>)||(a==<span class="string">'U'</span>&amp;&amp;b==<span class="string">'A'</span>))</span><br><span class="line">        <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line">    <span class="keyword">if</span>((a==<span class="string">'C'</span>&amp;&amp;b==<span class="string">'G'</span>)||(a==<span class="string">'G'</span>&amp;&amp;b==<span class="string">'C'</span>))</span><br><span class="line">        <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line">    <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="comment">/*求最大配对数*/</span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">RNA_2</span><span class="params">(CHAR B[LEN],<span class="keyword">int</span> n)</span> </span>&#123;</span><br><span class="line">    <span class="keyword">int</span> i,j,k,t;</span><br><span class="line">    <span class="keyword">int</span> max;</span><br><span class="line">    <span class="keyword">int</span> C[LEN][LEN]=&#123;<span class="number">0</span>&#125;;</span><br><span class="line">    </span><br><span class="line">    <span class="keyword">for</span>(k=<span class="number">5</span>;k&lt;=n;i++)&#123;</span><br><span class="line">        <span class="keyword">for</span>(i=<span class="number">1</span>;i&lt;=n-k;i++)&#123;</span><br><span class="line">            j=i+k;</span><br><span class="line">            max=C[LEN][LEN];</span><br><span class="line">            <span class="keyword">for</span>(t=i;y&lt;=j<span class="number">-4</span>;t++)&#123;</span><br><span class="line">                <span class="keyword">if</span>(isMatch(B[t][j])&amp;&amp;max&lt;C[i][t<span class="number">-1</span>]+<span class="number">1</span>+C[t+<span class="number">1</span>][j<span class="number">-1</span>])</span><br><span class="line">                    max=C[i][t<span class="number">-1</span>]+<span class="number">1</span>+C[t+<span class="number">1</span>][j<span class="number">-1</span>];</span><br><span class="line">            &#125;</span><br><span class="line">            C[i][j]=max;</span><br><span class="line">            <span class="built_in">printf</span>(<span class="string">"C[%d][%d]=%d--"</span>,i,j,Ci][j]);</span><br><span class="line">        &#125;</span><br><span class="line">    &#125;</span><br><span class="line">    <span class="keyword">return</span> max;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong><font color="#012060">（3）复杂度分析</font></strong></p><ul><li>时间复杂度：$O(n^3)$</li><li>空间复杂度：$O(n^2)$</li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/18/Z7wS1oQqyAaNkfG.jpg&quot; alt=&quot;aurora.jpg&quot;&gt;&lt;/p&gt;
&lt;h1 id=&quot;题解：字符配对&quot;&gt;&lt;a href=&quot;#题解：字符配对&quot; class=&quot;headerlink&quot; title=&quot;题解：字符配对&quot;&gt;&lt;/a&gt;题解：字符配对&lt;/h1&gt;&lt;blockquote&gt;
&lt;p&gt;Aurora&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;/p&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian出品&lt;/em&gt; &lt;/font&gt;&lt;/p&gt;&lt;p&gt;&lt;/p&gt;
&lt;h2 id=&quot;说明&quot;&gt;&lt;a href=&quot;#说明&quot; class=&quot;headerlink&quot; title=&quot;说明&quot;&gt;&lt;/a&gt;说明&lt;/h2&gt;&lt;p&gt;给定一个字符$B=b_1 b_2\dots b_n$，其中$b_i \in \{A,C,G,U\}$。$B$上的二级结构是一组字符对集合$S=\{(b_i,b_j)\}$，其中$i,j\in \{1,2,\dots ,n\}$，并满足以下四个条件：&lt;/p&gt;
&lt;p&gt;（1）$S$中的每对字符是$(A,U),(U,A),(C,G),(G,C)$四种组合之一；&lt;/p&gt;
&lt;p&gt;（2）$S$中的每对字符之间至少有四个字符将其隔开，即$i&amp;lt;j-4$；&lt;/p&gt;
&lt;p&gt;（3）$S$中的每一个字符（记为$b_k$）的配对存在两种情况：$b_k$不参与任何配对；$b_k$和$b_t$配对，其中$t&amp;lt;k-4$；&lt;/p&gt;
&lt;p&gt;（4）（不交叉原则）若$(b_i,b_j)$和$(b_k,b_l)$是$S$种的两个字符对，且$i&amp;lt;k$，则$i&amp;lt;k&amp;lt;j&amp;lt;l$不成立。&lt;/p&gt;
&lt;p&gt;$B$的具有最大可能字符对数的二级结构$S$被称为最优配对方案，求解最优配对方案中的字符对数的方法如下：&lt;/p&gt;
&lt;p&gt;假设用$C(i,j)$表示字符序列$b_i b_{i+1} \dots b_j$的最优配对方案（即二级结构$S$）中的字符对数，则$C(i,j)$可以递归定义为：&lt;/p&gt;
&lt;script type=&quot;math/tex; mode=display&quot;&gt;
C(i,j)=\begin{cases} \max(C(i,j-1),\max(C(i,t-1)+1+C(t+1,j-1))), &amp;b_t和b_j匹配且i&lt;j-4\\0 ，&amp;\text{否则}\end{cases}&lt;/script&gt;&lt;h2 id=&quot;分析&quot;&gt;&lt;a href=&quot;#分析&quot; class=&quot;headerlink&quot; title=&quot;分析&quot;&gt;&lt;/a&gt;分析&lt;/h2&gt;&lt;p&gt;题目的第3个条件容易引起歧义，一种不影响作答的理解是：&lt;font color=&quot;blue&quot;&gt;$B$上的字符要么不配对，要配对就要相隔至少4个字符。&lt;/font&gt;当然可以直接忽略这个条件，因为题目已经给出了足够多的信息了。&lt;/p&gt;
&lt;p&gt;显然题目说明最后的方程是动态规划算法中的&lt;font color=&quot;dark&quot; red&gt;状态转移方程&lt;/font&gt;，这提示我们这道题目的算法思想是&lt;font color=&quot;dark&quot; red&gt;动态规划&lt;/font&gt;。因此我们采取的做法是：&lt;font color=&quot;blue&quot;&gt;从较小的区间开始，转移到较大的区间，直到覆盖$B$中所有字符。&lt;/font&gt;&lt;/p&gt;
    
    </summary>
    
    
      <category term="题解" scheme="https://G-SS-Hacker.github.io/categories/%E9%A2%98%E8%A7%A3/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
      <category term="算法" scheme="https://G-SS-Hacker.github.io/tags/%E7%AE%97%E6%B3%95/"/>
    
  </entry>
  
  <entry>
    <title>题解：N皇后问题</title>
    <link href="https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9AN%E7%9A%87%E5%90%8E%E9%97%AE%E9%A2%98/"/>
    <id>https://g-ss-hacker.github.io/%E9%A2%98%E8%A7%A3%EF%BC%9AN%E7%9A%87%E5%90%8E%E9%97%AE%E9%A2%98/</id>
    <published>2020-05-17T13:30:13.000Z</published>
    <updated>2020-05-18T02:34:44.862Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/05/17/D8B16OHzsWKGNU5.jpg" alt="68755095_922332204766510_5658196280891932672_n.jpg"></p><h1 id="题解：N皇后问题"><a href="#题解：N皇后问题" class="headerlink" title="题解：N皇后问题"></a>题解：N皇后问题</h1><p></p><p><font color="grey"> <em>Guderian出品</em> </font></p><p></p><h2 id="说明"><a href="#说明" class="headerlink" title="说明"></a>说明</h2><p>n皇后问题描述为：在一个$n \times n$的棋盘上摆放$n$个皇后，要求任意两个皇后不能冲突，即任意两个皇后不再同一行、同一列、同一斜线上。</p><p><img src="https://i.loli.net/2020/05/18/Jtjxh49zop7A5C3.png" alt="图片.png"></p><h2 id="分析"><a href="#分析" class="headerlink" title="分析"></a>分析</h2><p><strong><font color="#012060">算法设计策略：回溯法</font></strong></p><p>将第$i$个皇后摆放在第$i$行，$i$从$1$开始，每个皇后都从第$1$列开始尝试。尝试时判断再该列摆放皇后是否与前面的皇后有冲突，如果没有冲突，则在该列摆放皇后，并考虑摆放下一个皇后；如果有冲突，则考虑下一列。</p><p>如果该行没有合适的位置，回溯到上一个皇后，考虑在原来位置的下一个位置上继续尝试摆放皇后，以此类推，直到找到所有合理的摆放方案。</p><a id="more"></a><h2 id="实现"><a href="#实现" class="headerlink" title="实现"></a>实现</h2><h3 id="解法一-新手回溯：朴素算法"><a href="#解法一-新手回溯：朴素算法" class="headerlink" title="解法一  新手回溯：朴素算法"></a><font color="dark" red>解法一  新手回溯：朴素算法</font></h3><p><strong><font color="#012060">（1）常量和变量说明</font></strong></p><ul><li><code>n</code>：皇后数，棋盘规模为$n\times n$</li><li><code>queen[]</code>：皇后的摆放位置数组，<code>queen[i]</code>表示第$i$个皇后的位置，<code>1&lt;=queen[i]&lt;=n</code></li></ul><p><strong><font color="#012060">（2）C语言程序</font></strong></p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;math.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> n 4</span></span><br><span class="line"><span class="keyword">int</span> queen[n+<span class="number">1</span>];</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Show</span><span class="params">()</span>                 <span class="comment">//输出所有皇后摆放方案</span></span></span><br><span class="line"><span class="function"></span>&#123; </span><br><span class="line">    <span class="built_in">printf</span>(<span class="string">"("</span>);</span><br><span class="line">    <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i &lt;= n; i++)</span><br><span class="line">        <span class="built_in">printf</span>(<span class="string">" %d"</span>, queen[i]);</span><br><span class="line">    <span class="built_in">printf</span>(<span class="string">")\n"</span>);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">Place</span><span class="params">(<span class="keyword">int</span> j)</span>            <span class="comment">//检查当前列能否放置皇后，不能返回0，能返回1</span></span></span><br><span class="line"><span class="function"></span>&#123; </span><br><span class="line">    <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i &lt; j; i++)  <span class="comment">//检查与已经摆放的皇后是否在通一列或者同一斜线上</span></span><br><span class="line">        <span class="keyword">if</span>(queen[i] == queen[j] || <span class="built_in">fabs</span>(queen[i]-queen[j]) == (j - i))</span><br><span class="line">            <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">    <span class="keyword">return</span> <span class="number">1</span>;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Nqueen</span><span class="params">(<span class="keyword">int</span> j)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i &lt;= n; i++)</span><br><span class="line">    &#123;</span><br><span class="line">        queen[j] = i;</span><br><span class="line">        <span class="keyword">if</span>(Place(j))</span><br><span class="line">            <span class="keyword">if</span>(j == n)      <span class="comment">//如果所有皇后都摆放好，则输出当前摆放方案</span></span><br><span class="line">                Show();</span><br><span class="line">            <span class="keyword">else</span>            <span class="comment">//否则继续摆放下一个皇后</span></span><br><span class="line">                Nqueen(j + <span class="number">1</span>);</span><br><span class="line">    &#125;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    Nqueen(<span class="number">1</span>);</span><br><span class="line">    <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong><font color="#012060">（3）复杂度分析</font></strong></p><ul><li>时间复杂度：$O(n!)$到$O(n^n)$</li><li>空间复杂度：$O( n )$</li></ul><h3 id="解法二-优化回溯：记忆化搜索"><a href="#解法二-优化回溯：记忆化搜索" class="headerlink" title="解法二  优化回溯：记忆化搜索"></a><font color="dark" red>解法二  优化回溯：记忆化搜索</font></h3><p><strong><font color="#012060">（1）常量和变量说明</font></strong></p><ul><li><code>column[]</code>：标记数组，对于第$i$列，<code>column[i]</code>为$0$说明没有皇后，为$1$说明有皇后</li><li><code>diagonal1[]</code>：标记数组，对于第$i$条主对角线，<code>diagonal1[]</code>为$0$说明没有皇后，为$1$说明有皇后</li><li><code>diagonal2[]</code>：标记数组，对于第$i$条次对角线，<code>diagonal2[]</code>为$0$说明没有皇后，为$1$说明有皇后</li></ul><p><strong><font color="#012060">（2）C语言程序</font></strong></p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span><span class="meta-string">&lt;math.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> n 4</span></span><br><span class="line"><span class="keyword">int</span> queen[n+<span class="number">1</span>],column[n+<span class="number">1</span>],diagonal1[<span class="number">2</span>*n+<span class="number">1</span>],diagonal2[<span class="number">2</span>*n+<span class="number">1</span>]; <span class="comment">//设置标记，回溯时不用枚举queen[]</span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Show</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123; </span><br><span class="line">    <span class="built_in">printf</span>(<span class="string">"("</span>);</span><br><span class="line">    <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i &lt;= n; i++)</span><br><span class="line">        <span class="built_in">printf</span>(<span class="string">" %d"</span>, queen[i]);</span><br><span class="line">    <span class="built_in">printf</span>(<span class="string">")\n"</span>);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Nqueen</span><span class="params">(<span class="keyword">int</span> j)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">1</span>; i &lt;= n; i++)</span><br><span class="line">        <span class="keyword">if</span>(column[i] + diagonal1[i - j + n] + diagonal2[i + j] == <span class="number">0</span>)</span><br><span class="line">        &#123;</span><br><span class="line">            queen[j] = i;</span><br><span class="line">            column[i] = <span class="number">1</span>, diagonal1[i - j + n] = <span class="number">1</span>, diagonal2[i + j] = <span class="number">1</span>;</span><br><span class="line">            <span class="keyword">if</span>(j &lt; n) </span><br><span class="line">                Nqueen(j + <span class="number">1</span>);</span><br><span class="line">            <span class="keyword">else</span></span><br><span class="line">                Show();</span><br><span class="line">            column[i] = <span class="number">0</span>, diagonal1[i - j + n] = <span class="number">0</span>, diagonal2[i + j] = <span class="number">0</span>;</span><br><span class="line">        &#125;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    Nqueen(<span class="number">1</span>);</span><br><span class="line">    <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p><strong><font color="#012060">（3）复杂度分析</font></strong></p><ul><li>时间复杂度：不超过$O(n!)$</li><li>空间复杂度：$O( n )$</li></ul><h3 id="对比"><a href="#对比" class="headerlink" title="对比"></a><font color="dark" red>对比</font></h3><p>当$n$较小时，<strong><font color="dark" red face="Yahei">解法二</font></strong>比<strong><font color="dark" red face="Yahei">解法一</font></strong>快至少$20$倍。</p>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/17/D8B16OHzsWKGNU5.jpg&quot; alt=&quot;68755095_922332204766510_5658196280891932672_n.jpg&quot;&gt;&lt;/p&gt;
&lt;h1 id=&quot;题解：N皇后问题&quot;&gt;&lt;a href=&quot;#题解：N皇后问题&quot; class=&quot;headerlink&quot; title=&quot;题解：N皇后问题&quot;&gt;&lt;/a&gt;题解：N皇后问题&lt;/h1&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian出品&lt;/em&gt; &lt;/font&gt;&lt;/p&gt;&lt;p&gt;&lt;/p&gt;
&lt;h2 id=&quot;说明&quot;&gt;&lt;a href=&quot;#说明&quot; class=&quot;headerlink&quot; title=&quot;说明&quot;&gt;&lt;/a&gt;说明&lt;/h2&gt;&lt;p&gt;n皇后问题描述为：在一个$n \times n$的棋盘上摆放$n$个皇后，要求任意两个皇后不能冲突，即任意两个皇后不再同一行、同一列、同一斜线上。&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/18/Jtjxh49zop7A5C3.png&quot; alt=&quot;图片.png&quot;&gt;&lt;/p&gt;
&lt;h2 id=&quot;分析&quot;&gt;&lt;a href=&quot;#分析&quot; class=&quot;headerlink&quot; title=&quot;分析&quot;&gt;&lt;/a&gt;分析&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;&lt;font color=&quot;#012060&quot;&gt;算法设计策略：回溯法&lt;/font&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;将第$i$个皇后摆放在第$i$行，$i$从$1$开始，每个皇后都从第$1$列开始尝试。尝试时判断再该列摆放皇后是否与前面的皇后有冲突，如果没有冲突，则在该列摆放皇后，并考虑摆放下一个皇后；如果有冲突，则考虑下一列。&lt;/p&gt;
&lt;p&gt;如果该行没有合适的位置，回溯到上一个皇后，考虑在原来位置的下一个位置上继续尝试摆放皇后，以此类推，直到找到所有合理的摆放方案。&lt;/p&gt;
    
    </summary>
    
    
      <category term="题解" scheme="https://G-SS-Hacker.github.io/categories/%E9%A2%98%E8%A7%A3/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
      <category term="算法" scheme="https://G-SS-Hacker.github.io/tags/%E7%AE%97%E6%B3%95/"/>
    
      <category term="数据结构" scheme="https://G-SS-Hacker.github.io/tags/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/"/>
    
  </entry>
  
  <entry>
    <title>C语言常用字符串函数</title>
    <link href="https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%B8%B8%E7%94%A8%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%87%BD%E6%95%B0/"/>
    <id>https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%B8%B8%E7%94%A8%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%87%BD%E6%95%B0/</id>
    <published>2020-05-07T12:00:11.000Z</published>
    <updated>2020-05-21T02:11:51.831Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/05/07/ctH2PnCKya6ATUj.jpg" alt></p><h1 id="C语言常用字符串函数"><a href="#C语言常用字符串函数" class="headerlink" title="C语言常用字符串函数"></a>C语言常用字符串函数</h1><blockquote><p>图：猎鹰重型🚀，SpaceX Falcon Heavy</p></blockquote><p></p><p><font color="grey"> <em>Guderian</em>出品 </font></p><br><strong>用的时候要</strong><code>#include&lt;string.h&gt;</code><p></p><h2 id="1-计算长度"><a href="#1-计算长度" class="headerlink" title="1 计算长度"></a>1 计算长度</h2><p>Prototype: <code>int strlen(const *char str)</code></p><p>Usage: 返回<code>\0</code>以前的字符串长度。</p><h2 id="2-计算占用内存"><a href="#2-计算占用内存" class="headerlink" title="2 计算占用内存"></a>2 计算占用内存</h2><p>Prototype 1: <code>unsigned int szieof(object)</code></p><p>Prototype 2: <code>unsigned int szieof object</code></p><p>Prototype 3: <code>unsigned int szieof(type_name)</code></p><p>Usage: 返回<strong>对象</strong>或<strong>类型</strong>占用内存空间的大小</p><h2 id="3-比较字符串"><a href="#3-比较字符串" class="headerlink" title="3 比较字符串"></a>3 比较字符串</h2><blockquote><p>关于字符串大小：<a href="https://www.php.cn/faq/415854.html" target="_blank" rel="noopener">https://www.php.cn/faq/415854.html</a></p></blockquote><p>Prototype: <code>int strcmp(const char *str1,const char *str2)</code></p><p>Usage: 若<code>str1</code>比<code>str2</code>大，返回值大于<code>0</code>；若<code>str1</code>比<code>str2</code>小，返回值小于<code>0</code>；若<code>str1</code>大小与<code>str2</code>相等，返回值为<code>0</code></p><h2 id="4-复制字符串"><a href="#4-复制字符串" class="headerlink" title="4 复制字符串"></a>4 复制字符串</h2><blockquote><p>可不要写出<code>str1 = str2</code>这样的代码，这可不是在复制数字</p></blockquote><p>Prototype: <code>char *strcpy(char *str1, const char *str2)</code></p><p>Usage: 把串<code>str2</code>以<code>\0</code>截止的字符串写入串<code>str1</code>中，返回<code>str1</code>首地址，用的时候注意不要越界</p><a id="more"></a><h2 id="5-拼接字符串"><a href="#5-拼接字符串" class="headerlink" title="5 拼接字符串"></a>5 拼接字符串</h2><p>Prototype: <code>char *strcat(char *str1, const char *str2)</code>和<code>char *strncat(char *str1, const char *str2,int n)</code></p><p>Usage: 第一种，把<code>str2</code>拼到<code>str1</code>末尾；第二种，把<code>str2</code>前<code>n</code>个字符拼到<code>str1</code>末尾，返回<code>str1</code>首地址</p><h2 id="6-字符串匹配"><a href="#6-字符串匹配" class="headerlink" title="6 字符串匹配"></a>6 字符串匹配</h2><p>Prototype: <code>char *strstr(const char *str1, const char *str2)</code></p><p>Usage: 返回在<code>str1</code>中第一次出现<code>str2</code>字符串的位置，如果未找到则返回<code>null</code></p><hr><font size="5rem" face="rage">Guderian Present</font>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/05/07/ctH2PnCKya6ATUj.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h1 id=&quot;C语言常用字符串函数&quot;&gt;&lt;a href=&quot;#C语言常用字符串函数&quot; class=&quot;headerlink&quot; title=&quot;C语言常用字符串函数&quot;&gt;&lt;/a&gt;C语言常用字符串函数&lt;/h1&gt;&lt;blockquote&gt;
&lt;p&gt;图：猎鹰重型🚀，SpaceX Falcon Heavy&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;/p&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian&lt;/em&gt;出品 &lt;/font&gt;&lt;/p&gt;&lt;br&gt;&lt;strong&gt;用的时候要&lt;/strong&gt;&lt;code&gt;#include&amp;lt;string.h&amp;gt;&lt;/code&gt;&lt;p&gt;&lt;/p&gt;
&lt;h2 id=&quot;1-计算长度&quot;&gt;&lt;a href=&quot;#1-计算长度&quot; class=&quot;headerlink&quot; title=&quot;1 计算长度&quot;&gt;&lt;/a&gt;1 计算长度&lt;/h2&gt;&lt;p&gt;Prototype: &lt;code&gt;int strlen(const *char str)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;Usage: 返回&lt;code&gt;\0&lt;/code&gt;以前的字符串长度。&lt;/p&gt;
&lt;h2 id=&quot;2-计算占用内存&quot;&gt;&lt;a href=&quot;#2-计算占用内存&quot; class=&quot;headerlink&quot; title=&quot;2 计算占用内存&quot;&gt;&lt;/a&gt;2 计算占用内存&lt;/h2&gt;&lt;p&gt;Prototype 1: &lt;code&gt;unsigned int szieof(object)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;Prototype 2: &lt;code&gt;unsigned int szieof object&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;Prototype 3: &lt;code&gt;unsigned int szieof(type_name)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;Usage: 返回&lt;strong&gt;对象&lt;/strong&gt;或&lt;strong&gt;类型&lt;/strong&gt;占用内存空间的大小&lt;/p&gt;
&lt;h2 id=&quot;3-比较字符串&quot;&gt;&lt;a href=&quot;#3-比较字符串&quot; class=&quot;headerlink&quot; title=&quot;3 比较字符串&quot;&gt;&lt;/a&gt;3 比较字符串&lt;/h2&gt;&lt;blockquote&gt;
&lt;p&gt;关于字符串大小：&lt;a href=&quot;https://www.php.cn/faq/415854.html&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;https://www.php.cn/faq/415854.html&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Prototype: &lt;code&gt;int strcmp(const char *str1,const char *str2)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;Usage: 若&lt;code&gt;str1&lt;/code&gt;比&lt;code&gt;str2&lt;/code&gt;大，返回值大于&lt;code&gt;0&lt;/code&gt;；若&lt;code&gt;str1&lt;/code&gt;比&lt;code&gt;str2&lt;/code&gt;小，返回值小于&lt;code&gt;0&lt;/code&gt;；若&lt;code&gt;str1&lt;/code&gt;大小与&lt;code&gt;str2&lt;/code&gt;相等，返回值为&lt;code&gt;0&lt;/code&gt;&lt;/p&gt;
&lt;h2 id=&quot;4-复制字符串&quot;&gt;&lt;a href=&quot;#4-复制字符串&quot; class=&quot;headerlink&quot; title=&quot;4 复制字符串&quot;&gt;&lt;/a&gt;4 复制字符串&lt;/h2&gt;&lt;blockquote&gt;
&lt;p&gt;可不要写出&lt;code&gt;str1 = str2&lt;/code&gt;这样的代码，这可不是在复制数字&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;Prototype: &lt;code&gt;char *strcpy(char *str1, const char *str2)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;Usage: 把串&lt;code&gt;str2&lt;/code&gt;以&lt;code&gt;\0&lt;/code&gt;截止的字符串写入串&lt;code&gt;str1&lt;/code&gt;中，返回&lt;code&gt;str1&lt;/code&gt;首地址，用的时候注意不要越界&lt;/p&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
  </entry>
  
  <entry>
    <title>黎曼积分</title>
    <link href="https://g-ss-hacker.github.io/%E9%BB%8E%E6%9B%BC%E7%A7%AF%E5%88%86/"/>
    <id>https://g-ss-hacker.github.io/%E9%BB%8E%E6%9B%BC%E7%A7%AF%E5%88%86/</id>
    <published>2020-04-24T09:24:50.000Z</published>
    <updated>2020-05-04T07:56:20.590Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/04/24/F9EzJhxudkUG5R6.jpg" alt></p><h1 id="黎曼积分"><a href="#黎曼积分" class="headerlink" title="黎曼积分"></a>黎曼积分</h1><blockquote><p>图：silhouette of mountains and spectacular view from the mountain top </p></blockquote><p></p><p><font color="grey"> <em>Guderian出品</em> </font></p><br>设$f(p)$是几何形体上的点函数，黎曼积分<font size="4rem">$\int_\Omega f(p) \mathrm{d} \Omega=\lim_{\lambda \to0} \sum_{i=1}^{n}f(p_i)\Delta\Omega_i$ </font>具体分为四类：<p></p><h2 id="二重积分"><a href="#二重积分" class="headerlink" title="二重积分"></a>二重积分</h2><h3 id="x-型域"><a href="#x-型域" class="headerlink" title="x-型域"></a>x-型域</h3><font size="4rem">$\iint_\sigma f(x,y)\mathrm{d}\sigma=\iint_\sigma f(x,y)\mathrm{d}x\mathrm{d}y=\int_a^b\mathrm{d}x\int_{y_1(x)}^{y_2(x)} f(x,y)\mathrm{d}y$</font><h3 id="y-型域"><a href="#y-型域" class="headerlink" title="y-型域"></a>y-型域</h3><font size="4rem">$\iint_\sigma f(x,y)\mathrm{d}\sigma=\iint_\sigma f(x,y)\mathrm{d}x\mathrm{d}y=\int_c^d\mathrm{d}y\int_{x_1(x)}^{x_2(x)} f(x,y)\mathrm{d}x$</font><h3 id="极坐标"><a href="#极坐标" class="headerlink" title="极坐标"></a>极坐标</h3><font size="4rem">$\iint_\sigma f(x,y)\mathrm{d}\sigma=\iint f(r,\theta)r\mathrm{d}r\mathrm{d}\theta=\int_\alpha^\beta\mathrm{d}\theta\int_{r_1(\theta)}^{r_2(\theta)}f(r,\theta)r\mathrm{d}r$</font><a id="more"></a><h2 id="三重积分"><a href="#三重积分" class="headerlink" title="三重积分"></a>三重积分</h2><h3 id="投影法"><a href="#投影法" class="headerlink" title="投影法"></a>投影法</h3><font size="4rem">$\iiint_V f(x,y,z)\mathrm{d}x\mathrm{d}y\mathrm{d}z=\iint_{\sigma_{xy}}\mathrm{d}x\mathrm{d}y\int_{z_1(x,y)}^{z_2(x,y)}f(x,y,z)\mathrm{d}z$</font><h3 id="截面法"><a href="#截面法" class="headerlink" title="截面法"></a>截面法</h3><font size="4rem">$\iiint_V f(x,y,z)\mathrm{d}x\mathrm{d}y\mathrm{d}z=\int_a^b\mathrm{d}z\iint_{\sigma_z}f(x,y,z)\mathrm{d}x\mathrm{d}y$</font><h3 id="柱坐标系"><a href="#柱坐标系" class="headerlink" title="柱坐标系"></a>柱坐标系</h3><font color="darkred">变换关系：</font>    <font size="4rem">$x=r\cos\theta$，    $y=r\sin\theta$</font><br><font color="darkred">体积微元：</font>    $\mathrm{d}V=r\mathrm{d}r\mathrm{d}\theta\mathrm{d}z$<br><font size="4rem">$\iiint_V f(x,y,z)\mathrm{d}x\mathrm{d}y\mathrm{d}z=\int_\alpha^\beta\mathrm{d}\theta\int_{r_1(\theta)}^{r_2(\theta)}r\mathrm{d}r\int_{z_1(r,\theta)}^{z_2(r,\theta)}f(r\cos\theta,r\sin \theta,z) \mathrm{d}z$</font><h3 id="球坐标系"><a href="#球坐标系" class="headerlink" title="球坐标系"></a>球坐标系</h3><font color="darkred">变换关系：</font>    <font size="4rem">$x=\rho\sin\phi\cos\theta$，    $y=\rho\sin\phi\sin\theta$，    $z=\rho\cos\theta$</font><br><font color="darkred">体积微元：</font>    <font size="4rem">$\mathrm{d}V=\rho^2\sin\phi\mathrm{d}\rho\mathrm{d}\phi\mathrm{d}\theta$</font><br><font size="4rem">$\iiint_V f(x,y,z)\mathrm{d}x\mathrm{d}y\mathrm{d}z=\int_\alpha^\beta\mathrm{d}\theta\int_{\phi_1(\theta)}^{\phi_2(\theta)}\sin\phi\mathrm{d}\phi\int_{\rho_1(\theta,\phi)}^{\phi_2{\theta,\phi}}f(\rho\sin\phi\cos\theta,\rho\sin\phi\sin\theta,\rho\cos\theta)\rho^2\mathrm{d}\rho$</font><h2 id="第一型曲线积分"><a href="#第一型曲线积分" class="headerlink" title="第一型曲线积分"></a>第一型曲线积分</h2><font size="4rem">$\int_lf(x,y,z)\mathrm{d}s=\int_\alpha^\beta f(x(t),y(t),z(t))\sqrt{x'^2(t)+y'^2(t)+z'^2(t)}\mathrm{d}t$</font><h2 id="第一型曲面积分"><a href="#第一型曲面积分" class="headerlink" title="第一型曲面积分"></a>第一型曲面积分</h2><font size="4rem">$\iint_Sf(x,y,z)\mathrm{d}S=\iint_{\sigma_{xy}}f(x,y,z(x,y))\sqrt{1+(\frac{\partial z}{\partial x})^2+(\frac{\partial z}{\partial y})^2}\mathrm{d}\sigma$</font><h2 id="黎曼积分的应用"><a href="#黎曼积分的应用" class="headerlink" title="黎曼积分的应用"></a>黎曼积分的应用</h2><h3 id="曲面面积"><a href="#曲面面积" class="headerlink" title="曲面面积"></a>曲面面积</h3><p>等价于积分函数为$1$的第一型曲面积分</p><font size="4rem">$S=\iint_S\mathrm{d}S=\iint_{\sigma_{xy}}\sqrt{1+(\frac{\partial z}{\partial x})^2+(\frac{\partial z}{\partial y})^2}\mathrm{d}\sigma$</font><h3 id="曲顶柱体体积"><a href="#曲顶柱体体积" class="headerlink" title="曲顶柱体体积"></a>曲顶柱体体积</h3><p>等价于积分函数为$1$的三重积分</p><font size="4rem">$V=\iiint_V\mathrm{d}V=\iint_{\sigma_{xy}}z(x,y)\mathrm{d}\sigma$</font><h3 id="质心"><a href="#质心" class="headerlink" title="质心"></a>质心</h3><p>等价于积分函数$\mu(p)$为质量密度（及其与$x,y,z$乘积）的三重积分</p><font size="5rem">$\bar{x}=\frac{\int_\Omega\mu(p)x\mathrm{d}\Omega}{\int_\Omega\mu(p)\mathrm{d}\Omega}$，    $\bar{y}=\frac{\int_\Omega\mu(p)y\mathrm{d}\Omega}{\int_\Omega\mu(p)\mathrm{d}\Omega}$，    $\bar{z}=\frac{\int_\Omega\mu(p)z\mathrm{d}\Omega}{\int_\Omega\mu(p)\mathrm{d}\Omega}$</font><h3 id="转动惯量"><a href="#转动惯量" class="headerlink" title="转动惯量"></a>转动惯量</h3><p>仅针对坐标轴，等价于积分函数为质量密度$\mu(p)$与另外两个变量平方和的乘积的三重积分</p><font size="4rem">$I_x=\int_\Omega\mu(p)(y^2+z^2)\mathrm{d}\Omega$，$I_y=\int_\Omega\mu(p)(x^2+z^2)\mathrm{d}\Omega$，$I_z=\int_\Omega\mu(p)(x^2+y^2)\mathrm{d}\Omega$</font><hr><font size="5rem" face="rage">Presented by Guderian</font>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/04/24/F9EzJhxudkUG5R6.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h1 id=&quot;黎曼积分&quot;&gt;&lt;a href=&quot;#黎曼积分&quot; class=&quot;headerlink&quot; title=&quot;黎曼积分&quot;&gt;&lt;/a&gt;黎曼积分&lt;/h1&gt;&lt;blockquote&gt;
&lt;p&gt;图：silhouette of mountains and spectacular view from the mountain top &lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;/p&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian出品&lt;/em&gt; &lt;/font&gt;&lt;/p&gt;&lt;br&gt;设$f(p)$是几何形体上的点函数，黎曼积分&lt;font size=&quot;4rem&quot;&gt;$\int_\Omega f(p) \mathrm{d} \Omega=\lim_{\lambda \to0} \sum_{i=1}^{n}f(p_i)\Delta\Omega_i$ &lt;/font&gt;具体分为四类：&lt;p&gt;&lt;/p&gt;
&lt;h2 id=&quot;二重积分&quot;&gt;&lt;a href=&quot;#二重积分&quot; class=&quot;headerlink&quot; title=&quot;二重积分&quot;&gt;&lt;/a&gt;二重积分&lt;/h2&gt;&lt;h3 id=&quot;x-型域&quot;&gt;&lt;a href=&quot;#x-型域&quot; class=&quot;headerlink&quot; title=&quot;x-型域&quot;&gt;&lt;/a&gt;x-型域&lt;/h3&gt;&lt;font size=&quot;4rem&quot;&gt;$\iint_\sigma f(x,y)\mathrm{d}\sigma=\iint_\sigma f(x,y)\mathrm{d}x\mathrm{d}y=\int_a^b\mathrm{d}x\int_{y_1(x)}^{y_2(x)} f(x,y)\mathrm{d}y$&lt;/font&gt;

&lt;h3 id=&quot;y-型域&quot;&gt;&lt;a href=&quot;#y-型域&quot; class=&quot;headerlink&quot; title=&quot;y-型域&quot;&gt;&lt;/a&gt;y-型域&lt;/h3&gt;&lt;font size=&quot;4rem&quot;&gt;$\iint_\sigma f(x,y)\mathrm{d}\sigma=\iint_\sigma f(x,y)\mathrm{d}x\mathrm{d}y=\int_c^d\mathrm{d}y\int_{x_1(x)}^{x_2(x)} f(x,y)\mathrm{d}x$&lt;/font&gt;

&lt;h3 id=&quot;极坐标&quot;&gt;&lt;a href=&quot;#极坐标&quot; class=&quot;headerlink&quot; title=&quot;极坐标&quot;&gt;&lt;/a&gt;极坐标&lt;/h3&gt;&lt;font size=&quot;4rem&quot;&gt;$\iint_\sigma f(x,y)\mathrm{d}\sigma=\iint f(r,\theta)r\mathrm{d}r\mathrm{d}\theta=\int_\alpha^\beta\mathrm{d}\theta\int_{r_1(\theta)}^{r_2(\theta)}f(r,\theta)r\mathrm{d}r$&lt;/font&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="微积分" scheme="https://G-SS-Hacker.github.io/tags/%E5%BE%AE%E7%A7%AF%E5%88%86/"/>
    
  </entry>
  
  <entry>
    <title>三角恒等变换所有公式</title>
    <link href="https://g-ss-hacker.github.io/%E4%B8%89%E8%A7%92%E6%81%92%E7%AD%89%E5%8F%98%E6%8D%A2%E5%85%AC%E5%BC%8F/"/>
    <id>https://g-ss-hacker.github.io/%E4%B8%89%E8%A7%92%E6%81%92%E7%AD%89%E5%8F%98%E6%8D%A2%E5%85%AC%E5%BC%8F/</id>
    <published>2020-03-18T09:50:03.000Z</published>
    <updated>2020-03-18T09:50:36.320Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/03/18/Qno9rEZAjqbuUl7.png" alt></p><a id="more"></a><blockquote><p>Licensed under cc0 license. Feel free to share it with others.😎</p></blockquote>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/03/18/Qno9rEZAjqbuUl7.png&quot; alt&gt;&lt;/p&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="微积分" scheme="https://G-SS-Hacker.github.io/tags/%E5%BE%AE%E7%A7%AF%E5%88%86/"/>
    
  </entry>
  
  <entry>
    <title>基尔霍夫定律</title>
    <link href="https://g-ss-hacker.github.io/%E5%9F%BA%E5%B0%94%E9%9C%8D%E5%A4%AB%E5%AE%9A%E5%BE%8B/"/>
    <id>https://g-ss-hacker.github.io/%E5%9F%BA%E5%B0%94%E9%9C%8D%E5%A4%AB%E5%AE%9A%E5%BE%8B/</id>
    <published>2020-03-06T14:23:05.000Z</published>
    <updated>2020-03-06T14:24:28.687Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/03/03/UotQYv9eLx752D4.jpg" alt></p><h1 id="基尔霍夫定律-Kirchhoff-laws"><a href="#基尔霍夫定律-Kirchhoff-laws" class="headerlink" title="基尔霍夫定律(Kirchhoff laws)"></a>基尔霍夫定律(Kirchhoff laws)</h1><p><font color="grey"> <em>Guderian</em>出品 </font></p><blockquote><p>本文的讨论范围仅限于<strong>集中参数电路</strong>，适用于家庭电路，不适用于2000公里输电线或者洲际海底电缆。</p></blockquote><h2 id="这是什么？"><a href="#这是什么？" class="headerlink" title="这是什么？"></a>这是什么？</h2><p>想必随便一个有初中文化的人都知道电路中的<strong>串联分压，并联分流</strong>定律，但是并非谁都知道基尔霍夫定律。基尔霍夫定律规定了电路中，电路结构对电流、电压的约束关系。分别称为<strong>基尔霍夫电流定律</strong>和<strong>基尔霍夫定律</strong>。根据<strong>基尔霍夫电压定律</strong>可以直接导出<strong>串联分压</strong>定律，根据<strong>基尔霍夫电流定律</strong>可以直接导出<strong>并联分流</strong>定律。</p><p>古斯塔夫·罗伯特·基尔霍夫（Gustav Robert Kirchhoff，1824～1887），德国物理学家，出生于柯尼斯堡（今俄罗斯加里宁格勒）。其人如图所示：</p><p><img src="https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=545249687,2743279198&amp;fm=26&amp;gp=0.jpg" alt></p><h2 id="基尔霍夫电流定律（KCL）"><a href="#基尔霍夫电流定律（KCL）" class="headerlink" title="基尔霍夫电流定律（KCL）"></a>基尔霍夫电流定律（KCL）</h2><blockquote><p>基尔霍夫电流定律：流出（或流入）任一节点的支路电流代数和等于零。</p></blockquote><p>即：$\sum i_k=0$（$i_k$表示第$k$条支路的电流）。规定$i_k$的参考方向为流出节点时，$i_k$取正号；$i_k$的参考方向为流入节点时，$i_k$取负号。</p><a id="more"></a><h3 id="何谓节点？"><a href="#何谓节点？" class="headerlink" title="何谓节点？"></a>何谓节点？</h3><p>如图红圈所示</p><p><img src="https://i.loli.net/2020/03/03/bhSYlkpZOMcUQ8v.jpg" alt></p><h3 id="推论：广义基尔霍夫电流定律"><a href="#推论：广义基尔霍夫电流定律" class="headerlink" title="推论：广义基尔霍夫电流定律"></a>推论：广义基尔霍夫电流定律</h3><blockquote><p>流出（或流入）任一节点的闭合边界S电流代数和等于零。</p></blockquote><p>这次我们把电路中的任意一个部分抽象为一个“节点”，同样的<strong>基尔霍夫电流定律依然成立</strong>。</p><h3 id="推论：有进必有出"><a href="#推论：有进必有出" class="headerlink" title="推论：有进必有出"></a>推论：有进必有出</h3><blockquote><p>流出任一节点（闭合边界）电流的代数和等于流入该节点电流的代数和。</p></blockquote><p>即：$\sum i_{流出}=\sum i_{流入}$</p><h3 id="性质：独立KCL方程个数"><a href="#性质：独立KCL方程个数" class="headerlink" title="性质：独立KCL方程个数"></a>性质：独立KCL方程个数</h3><blockquote><p>在含有n个节点的电路中，任意n-1个节点的KCL方程是一组独立方程，这些节点称为独立节点。（类似于线性代数中的向量线性无关）</p></blockquote><h2 id="基尔霍夫电压定律（KVL）"><a href="#基尔霍夫电压定律（KVL）" class="headerlink" title="基尔霍夫电压定律（KVL）"></a>基尔霍夫电压定律（KVL）</h2><blockquote><p>基尔霍夫电压定律：沿任一回路各支路电压的代数和等于零。</p></blockquote><p>即：$\sum u_k=0$（$u_k$表示第$k$条支路的电压）。规定$u_k$的参考方向与回路方向相同时取+号，否则取-号。</p><h3 id="何谓网孔？"><a href="#何谓网孔？" class="headerlink" title="何谓网孔？"></a>何谓网孔？</h3><p>如图所示，回路$l1,l2,l3$皆为网孔，但$l4$不是网孔。可以把网孔理解为“最小回路”。</p><p><img src="https://i.loli.net/2020/03/03/6xfP83RHwCQ9pXv.jpg" alt></p><h3 id="推论：有升必有降"><a href="#推论：有升必有降" class="headerlink" title="推论：有升必有降"></a>推论：有升必有降</h3><blockquote><p>沿任一回路，各支路电压降的代数和等于电压升的代数和。</p></blockquote><p>即：$\sum u_{电压降}=\sum u_{电压升}$</p><h3 id="性质：路径无关性"><a href="#性质：路径无关性" class="headerlink" title="性质：路径无关性"></a>性质：路径无关性</h3><blockquote><p>任意两点之间的电压具有确定值，与计算路径无关。</p></blockquote><h3 id="性质：独立KVL方程个数"><a href="#性质：独立KVL方程个数" class="headerlink" title="性质：独立KVL方程个数"></a>性质：独立KVL方程个数</h3><blockquote><p>设电路有b个支路n个节点，平面电路的网孔数即独立KVL方程的个数等于b-n+1。</p></blockquote>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/03/03/UotQYv9eLx752D4.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h1 id=&quot;基尔霍夫定律-Kirchhoff-laws&quot;&gt;&lt;a href=&quot;#基尔霍夫定律-Kirchhoff-laws&quot; class=&quot;headerlink&quot; title=&quot;基尔霍夫定律(Kirchhoff laws)&quot;&gt;&lt;/a&gt;基尔霍夫定律(Kirchhoff laws)&lt;/h1&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian&lt;/em&gt;出品 &lt;/font&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;本文的讨论范围仅限于&lt;strong&gt;集中参数电路&lt;/strong&gt;，适用于家庭电路，不适用于2000公里输电线或者洲际海底电缆。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&quot;这是什么？&quot;&gt;&lt;a href=&quot;#这是什么？&quot; class=&quot;headerlink&quot; title=&quot;这是什么？&quot;&gt;&lt;/a&gt;这是什么？&lt;/h2&gt;&lt;p&gt;想必随便一个有初中文化的人都知道电路中的&lt;strong&gt;串联分压，并联分流&lt;/strong&gt;定律，但是并非谁都知道基尔霍夫定律。基尔霍夫定律规定了电路中，电路结构对电流、电压的约束关系。分别称为&lt;strong&gt;基尔霍夫电流定律&lt;/strong&gt;和&lt;strong&gt;基尔霍夫定律&lt;/strong&gt;。根据&lt;strong&gt;基尔霍夫电压定律&lt;/strong&gt;可以直接导出&lt;strong&gt;串联分压&lt;/strong&gt;定律，根据&lt;strong&gt;基尔霍夫电流定律&lt;/strong&gt;可以直接导出&lt;strong&gt;并联分流&lt;/strong&gt;定律。&lt;/p&gt;
&lt;p&gt;古斯塔夫·罗伯特·基尔霍夫（Gustav Robert Kirchhoff，1824～1887），德国物理学家，出生于柯尼斯堡（今俄罗斯加里宁格勒）。其人如图所示：&lt;/p&gt;
&lt;p&gt;&lt;img src=&quot;https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u=545249687,2743279198&amp;amp;fm=26&amp;amp;gp=0.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h2 id=&quot;基尔霍夫电流定律（KCL）&quot;&gt;&lt;a href=&quot;#基尔霍夫电流定律（KCL）&quot; class=&quot;headerlink&quot; title=&quot;基尔霍夫电流定律（KCL）&quot;&gt;&lt;/a&gt;基尔霍夫电流定律（KCL）&lt;/h2&gt;&lt;blockquote&gt;
&lt;p&gt;基尔霍夫电流定律：流出（或流入）任一节点的支路电流代数和等于零。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;即：$\sum i_k=0$（$i_k$表示第$k$条支路的电流）。规定$i_k$的参考方向为流出节点时，$i_k$取正号；$i_k$的参考方向为流入节点时，$i_k$取负号。&lt;/p&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="电路" scheme="https://G-SS-Hacker.github.io/tags/%E7%94%B5%E8%B7%AF/"/>
    
  </entry>
  
  <entry>
    <title>C语言实现单向链表</title>
    <link href="https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%AE%9E%E7%8E%B0%E5%8D%95%E5%90%91%E9%93%BE%E8%A1%A8/"/>
    <id>https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%AE%9E%E7%8E%B0%E5%8D%95%E5%90%91%E9%93%BE%E8%A1%A8/</id>
    <published>2020-02-27T09:18:18.000Z</published>
    <updated>2020-02-27T09:45:25.096Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://timgsa.baidu.com/timg?image&amp;quality=80&amp;size=b9999_10000&amp;sec=1582806308991&amp;di=845f5098180dcf73145af35097896cec&amp;imgtype=0&amp;src=http%3A%2F%2Fn.sinaimg.cn%2Fspider2020220%2F200%2Fw1080h720%2F20200220%2F8088-ipvnsze0545653.jpg" alt></p><h1 id="C语言实现单向链表"><a href="#C语言实现单向链表" class="headerlink" title="C语言实现单向链表"></a>C语言实现单向链表</h1><blockquote><p>图：武汉加油！中国必赢！</p></blockquote><p><font color="grey"> <em>Guderian</em>出品 </font></p><h2 id="完整代码"><a href="#完整代码" class="headerlink" title="完整代码"></a>完整代码</h2><blockquote><p>如图所示</p></blockquote><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">/*</span></span><br><span class="line"><span class="comment"> * Presented by G-SS-Hacker</span></span><br><span class="line"><span class="comment"> * Share it if you like</span></span><br><span class="line"><span class="comment"> */</span></span><br><span class="line"> </span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdlib.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;string.h&gt;</span></span></span><br><span class="line"></span><br><span class="line"><span class="comment">//为节点申请内存空间</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> NEW(x) NODE *x = (NODE *)malloc(sizeof(NODE))</span></span><br><span class="line"><span class="comment">//释放内存空间</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> DEL(x) free(x); x = NULL</span></span><br><span class="line"><span class="comment">//检查是否成功申请内存</span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> JUD(x) <span class="meta-keyword">if</span>(x==NULL) exit(0)</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">typedef</span> <span class="class"><span class="keyword">struct</span> <span class="title">node</span>//结构体：节点</span></span><br><span class="line"><span class="class">&#123;</span></span><br><span class="line"><span class="keyword">int</span> data;<span class="comment">//数据</span></span><br><span class="line"><span class="keyword">char</span> name[<span class="number">20</span>];<span class="comment">//名称</span></span><br><span class="line"><span class="class"><span class="keyword">struct</span> <span class="title">node</span> *<span class="title">next</span>;</span><span class="comment">//后继节点指针</span></span><br><span class="line">&#125;NODE;</span><br><span class="line"></span><br><span class="line"><span class="keyword">typedef</span> <span class="class"><span class="keyword">struct</span> <span class="title">list</span>//结构体：链表</span></span><br><span class="line"><span class="class">&#123;</span></span><br><span class="line">NODE *head;<span class="comment">//头节点指针</span></span><br><span class="line">NODE *tail; <span class="comment">//尾节点指针</span></span><br><span class="line"><span class="keyword">int</span> len;<span class="comment">//链表长度</span></span><br><span class="line">&#125;LIST;</span><br><span class="line"></span><br><span class="line"><span class="comment">//初始化链表</span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">InitList</span><span class="params">(LIST *<span class="built_in">list</span>)</span></span>; </span><br><span class="line"><span class="comment">//在链表尾部插入一个节点 </span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">PushBack</span><span class="params">(LIST *<span class="built_in">list</span>, <span class="keyword">int</span> *data, <span class="keyword">const</span> <span class="keyword">char</span> name[])</span></span>;</span><br><span class="line"><span class="comment">//在链表尾部弹出一个节点 </span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">PopBack</span><span class="params">(LIST *<span class="built_in">list</span>)</span></span>;</span><br><span class="line"><span class="comment">//在指定位置后插入一个节点 </span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">InsertNode</span><span class="params">(LIST *<span class="built_in">list</span>, <span class="keyword">int</span> pos, <span class="keyword">int</span> *data, <span class="keyword">const</span> <span class="keyword">char</span> name[])</span></span>;</span><br><span class="line"><span class="comment">//删除指定位置的节点 </span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">DeleteNode</span><span class="params">(LIST *<span class="built_in">list</span>, <span class="keyword">int</span> pos)</span></span>;</span><br><span class="line"><span class="comment">//访问指定位置的节点 </span></span><br><span class="line"><span class="function">NODE *<span class="title">GetNode</span><span class="params">(LIST *<span class="built_in">list</span>, <span class="keyword">int</span> pos)</span></span>;</span><br><span class="line"><span class="comment">//打印整个链表 </span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">PrintList</span><span class="params">(LIST *<span class="built_in">list</span>)</span></span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">LIST <span class="built_in">list</span> = &#123;<span class="literal">NULL</span>, <span class="literal">NULL</span>, <span class="number">0</span>&#125;;</span><br><span class="line">InitList(&amp;<span class="built_in">list</span>);</span><br><span class="line"><span class="comment">/* 对链表的操作</span></span><br><span class="line"><span class="comment">int a1 = 123, a2 = 456;</span></span><br><span class="line"><span class="comment">char c1[20] = "汤姆\0", c2[20] = "杰克\0";</span></span><br><span class="line"><span class="comment">PushBack(&amp;list, &amp;a1, c1);</span></span><br><span class="line"><span class="comment">PushBack(&amp;list, &amp;a2, c2);</span></span><br><span class="line"><span class="comment">NODE *p = GetNode(&amp;list, 1);</span></span><br><span class="line"><span class="comment">PopBack(&amp;list);</span></span><br><span class="line"><span class="comment">InsertNode(&amp;list, 0, &amp;a2, c2);</span></span><br><span class="line"><span class="comment">PushBack(&amp;list, &amp;a2, c2);</span></span><br><span class="line"><span class="comment">DeleteNode(&amp;list, 1);</span></span><br><span class="line"><span class="comment">PrintList(&amp;list);</span></span><br><span class="line"><span class="comment">*/</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><a id="more"></a><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br><span class="line">75</span><br><span class="line">76</span><br><span class="line">77</span><br><span class="line">78</span><br><span class="line">79</span><br><span class="line">80</span><br><span class="line">81</span><br><span class="line">82</span><br><span class="line">83</span><br><span class="line">84</span><br><span class="line">85</span><br><span class="line">86</span><br><span class="line">87</span><br><span class="line">88</span><br><span class="line">89</span><br><span class="line">90</span><br><span class="line">91</span><br><span class="line">92</span><br><span class="line">93</span><br><span class="line">94</span><br><span class="line">95</span><br><span class="line">96</span><br><span class="line">97</span><br><span class="line">98</span><br><span class="line">99</span><br><span class="line">100</span><br><span class="line">101</span><br><span class="line">102</span><br><span class="line">103</span><br><span class="line">104</span><br><span class="line">105</span><br><span class="line">106</span><br><span class="line">107</span><br><span class="line">108</span><br><span class="line">109</span><br><span class="line">110</span><br><span class="line">111</span><br><span class="line">112</span><br><span class="line">113</span><br><span class="line">114</span><br><span class="line">115</span><br><span class="line">116</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">InitList</span><span class="params">(LIST *<span class="built_in">list</span>)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">NEW(node);</span><br><span class="line">JUD(node);</span><br><span class="line">node-&gt;next = <span class="literal">NULL</span>;</span><br><span class="line"></span><br><span class="line"><span class="built_in">list</span>-&gt;head = node;</span><br><span class="line"><span class="built_in">list</span>-&gt;tail = node;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">PushBack</span><span class="params">(LIST *<span class="built_in">list</span>, <span class="keyword">int</span> *data, <span class="keyword">const</span> <span class="keyword">char</span> name[])</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">NEW(node);</span><br><span class="line">JUD(node);</span><br><span class="line">node-&gt;data = *data;</span><br><span class="line"><span class="built_in">strcpy</span>(node-&gt;name, name);</span><br><span class="line">node-&gt;next = <span class="literal">NULL</span>;</span><br><span class="line"></span><br><span class="line"><span class="built_in">list</span>-&gt;tail-&gt;next = node;</span><br><span class="line"><span class="built_in">list</span>-&gt;tail = node;</span><br><span class="line"><span class="built_in">list</span>-&gt;len++;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">PopBack</span><span class="params">(LIST *<span class="built_in">list</span>)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="comment">//检查非法输入</span></span><br><span class="line"><span class="keyword">if</span> (!<span class="built_in">list</span>-&gt;len) </span><br><span class="line"><span class="keyword">return</span> ;</span><br><span class="line"></span><br><span class="line">NODE *p = <span class="built_in">list</span>-&gt;head;</span><br><span class="line"><span class="keyword">while</span>(p-&gt;next!=<span class="built_in">list</span>-&gt;tail)</span><br><span class="line">p = p-&gt;next;</span><br><span class="line"></span><br><span class="line">DEL(<span class="built_in">list</span>-&gt;tail);</span><br><span class="line"><span class="built_in">list</span>-&gt;tail = p;</span><br><span class="line"><span class="built_in">list</span>-&gt;tail-&gt;next = <span class="literal">NULL</span>;</span><br><span class="line"><span class="built_in">list</span>-&gt;len--;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">InsertNode</span><span class="params">(LIST *<span class="built_in">list</span>, <span class="keyword">int</span> pos, <span class="keyword">int</span> *data, <span class="keyword">const</span> <span class="keyword">char</span> name[])</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="comment">//检查非法输入</span></span><br><span class="line"><span class="keyword">if</span> (<span class="built_in">list</span>-&gt;len&lt;pos || pos&lt;<span class="number">0</span>)</span><br><span class="line"><span class="keyword">return</span> ;</span><br><span class="line"></span><br><span class="line"><span class="comment">//是否在链表尾部插入节点</span></span><br><span class="line"><span class="keyword">if</span> (pos==<span class="built_in">list</span>-&gt;len)</span><br><span class="line">&#123;</span><br><span class="line">PushBack(<span class="built_in">list</span>, data, name);</span><br><span class="line"><span class="keyword">return</span> ;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line">NODE *p = <span class="built_in">list</span>-&gt;head;</span><br><span class="line"><span class="keyword">for</span>(;pos;pos--)</span><br><span class="line">p = p-&gt;next;</span><br><span class="line"></span><br><span class="line">NEW(node);</span><br><span class="line">JUD(node);</span><br><span class="line">node-&gt;data = *data;</span><br><span class="line"><span class="built_in">strcpy</span>(node-&gt;name, name);</span><br><span class="line">node-&gt;next = p-&gt;next;</span><br><span class="line">p-&gt;next = node;</span><br><span class="line"><span class="built_in">list</span>-&gt;len++;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">DeleteNode</span><span class="params">(LIST *<span class="built_in">list</span>, <span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="comment">//检查非法输入</span></span><br><span class="line"><span class="keyword">if</span> (<span class="built_in">list</span>-&gt;len&lt;pos || !pos)</span><br><span class="line"><span class="keyword">return</span> ;</span><br><span class="line"></span><br><span class="line"><span class="comment">//是否在链表尾部删除节点</span></span><br><span class="line"><span class="keyword">if</span> (pos==<span class="built_in">list</span>-&gt;len)</span><br><span class="line">&#123;</span><br><span class="line">PopBack(<span class="built_in">list</span>);</span><br><span class="line"><span class="keyword">return</span> ;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line">NODE *p = <span class="built_in">list</span>-&gt;head;</span><br><span class="line"><span class="keyword">for</span>(--pos;pos;pos--)</span><br><span class="line">p = p-&gt;next;</span><br><span class="line"></span><br><span class="line">NODE *tmp = p-&gt;next;</span><br><span class="line">p-&gt;next = tmp-&gt;next;</span><br><span class="line">DEL(tmp);</span><br><span class="line"><span class="built_in">list</span>-&gt;len--;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function">NODE *<span class="title">GetNode</span><span class="params">(LIST *<span class="built_in">list</span>, <span class="keyword">int</span> pos)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="comment">//检查非法输入</span></span><br><span class="line"><span class="keyword">if</span> (<span class="built_in">list</span>-&gt;len&lt;pos || pos&lt;<span class="number">0</span>)</span><br><span class="line"><span class="keyword">return</span> <span class="literal">NULL</span>;</span><br><span class="line"></span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"第%d个节点为"</span>, pos);</span><br><span class="line">NODE *p = <span class="built_in">list</span>-&gt;head;</span><br><span class="line"><span class="keyword">for</span>(;pos;pos--)</span><br><span class="line">p = p-&gt;next;</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%.4d %s\n"</span>, p-&gt;data, p-&gt;name);</span><br><span class="line"></span><br><span class="line"><span class="keyword">return</span> p;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">PrintList</span><span class="params">(LIST *<span class="built_in">list</span>)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="comment">//检查非法输入</span></span><br><span class="line"><span class="keyword">if</span> (!<span class="built_in">list</span>-&gt;len)</span><br><span class="line"><span class="keyword">return</span> ;</span><br><span class="line"></span><br><span class="line">NODE *p = <span class="built_in">list</span>-&gt;head-&gt;next;</span><br><span class="line"><span class="keyword">while</span>(p!=<span class="literal">NULL</span>)</span><br><span class="line">&#123;</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%.4d %s\n"</span>, p-&gt;data, p-&gt;name);</span><br><span class="line">p = p-&gt;next;</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>取消主函数中的注释，输出结果为：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">第<span class="number">1</span>个节点为<span class="number">0123</span> 汤姆</span><br><span class="line"><span class="number">0123</span> 汤姆</span><br><span class="line"><span class="number">0456</span> 杰克</span><br></pre></td></tr></table></figure><hr><font color="#407600">【更多C语言系列】</font><ul><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-基本数据类型取值范围/">C &amp; C++基本数据类型取值范围</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-中memset用法/">C &amp; C++ memset</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/野指针的产生及其危害/">野指针的产生及其危害</a></li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://timgsa.baidu.com/timg?image&amp;amp;quality=80&amp;amp;size=b9999_10000&amp;amp;sec=1582806308991&amp;amp;di=845f5098180dcf73145af35097896cec&amp;amp;imgtype=0&amp;amp;src=http%3A%2F%2Fn.sinaimg.cn%2Fspider2020220%2F200%2Fw1080h720%2F20200220%2F8088-ipvnsze0545653.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h1 id=&quot;C语言实现单向链表&quot;&gt;&lt;a href=&quot;#C语言实现单向链表&quot; class=&quot;headerlink&quot; title=&quot;C语言实现单向链表&quot;&gt;&lt;/a&gt;C语言实现单向链表&lt;/h1&gt;&lt;blockquote&gt;
&lt;p&gt;图：武汉加油！中国必赢！&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian&lt;/em&gt;出品 &lt;/font&gt;&lt;/p&gt;

&lt;h2 id=&quot;完整代码&quot;&gt;&lt;a href=&quot;#完整代码&quot; class=&quot;headerlink&quot; title=&quot;完整代码&quot;&gt;&lt;/a&gt;完整代码&lt;/h2&gt;&lt;blockquote&gt;
&lt;p&gt;如图所示&lt;/p&gt;
&lt;/blockquote&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;12&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;13&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;14&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;15&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;16&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;17&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;18&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;19&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;20&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;21&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;22&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;23&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;24&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;25&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;26&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;27&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;28&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;29&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;30&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;31&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;32&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;33&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;34&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;35&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;36&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;37&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;38&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;39&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;40&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;41&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;42&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;43&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;44&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;45&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;46&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;47&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;48&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;49&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;50&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;51&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;52&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;53&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;54&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;55&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;56&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;57&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;58&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;59&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;60&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;61&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;62&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;63&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;64&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;/*&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt; * Presented by G-SS-Hacker&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt; * Share it if you like&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt; */&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt; &lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;stdlib.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;string.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//为节点申请内存空间&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;define&lt;/span&gt; NEW(x) NODE *x = (NODE *)malloc(sizeof(NODE))&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//释放内存空间&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;define&lt;/span&gt; DEL(x) free(x); x = NULL&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//检查是否成功申请内存&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;define&lt;/span&gt; JUD(x) &lt;span class=&quot;meta-keyword&quot;&gt;if&lt;/span&gt;(x==NULL) exit(0)&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;typedef&lt;/span&gt; &lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;struct&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;node&lt;/span&gt;		//结构体：节点&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&amp;#123;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; data;			&lt;span class=&quot;comment&quot;&gt;//数据&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; name[&lt;span class=&quot;number&quot;&gt;20&lt;/span&gt;];		&lt;span class=&quot;comment&quot;&gt;//名称&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;struct&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;node&lt;/span&gt; *&lt;span class=&quot;title&quot;&gt;next&lt;/span&gt;;&lt;/span&gt;	&lt;span class=&quot;comment&quot;&gt;//后继节点指针&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;NODE;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;typedef&lt;/span&gt; &lt;span class=&quot;class&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;struct&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;list&lt;/span&gt;		//结构体：链表&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;class&quot;&gt;&amp;#123;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	NODE *head;			&lt;span class=&quot;comment&quot;&gt;//头节点指针&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	NODE *tail; 		&lt;span class=&quot;comment&quot;&gt;//尾节点指针&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; len;			&lt;span class=&quot;comment&quot;&gt;//链表长度&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;LIST;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//初始化链表&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;InitList&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(LIST *&lt;span class=&quot;built_in&quot;&gt;list&lt;/span&gt;)&lt;/span&gt;&lt;/span&gt;; &lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//在链表尾部插入一个节点 &lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;PushBack&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(LIST *&lt;span class=&quot;built_in&quot;&gt;list&lt;/span&gt;, &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *data, &lt;span class=&quot;keyword&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; name[])&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//在链表尾部弹出一个节点 &lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;PopBack&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(LIST *&lt;span class=&quot;built_in&quot;&gt;list&lt;/span&gt;)&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//在指定位置后插入一个节点 &lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;InsertNode&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(LIST *&lt;span class=&quot;built_in&quot;&gt;list&lt;/span&gt;, &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; pos, &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *data, &lt;span class=&quot;keyword&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; name[])&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//删除指定位置的节点 &lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;DeleteNode&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(LIST *&lt;span class=&quot;built_in&quot;&gt;list&lt;/span&gt;, &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; pos)&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//访问指定位置的节点 &lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;NODE *&lt;span class=&quot;title&quot;&gt;GetNode&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(LIST *&lt;span class=&quot;built_in&quot;&gt;list&lt;/span&gt;, &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; pos)&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;//打印整个链表 &lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;PrintList&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(LIST *&lt;span class=&quot;built_in&quot;&gt;list&lt;/span&gt;)&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;main&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;()&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	LIST &lt;span class=&quot;built_in&quot;&gt;list&lt;/span&gt; = &amp;#123;&lt;span class=&quot;literal&quot;&gt;NULL&lt;/span&gt;, &lt;span class=&quot;literal&quot;&gt;NULL&lt;/span&gt;, &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;&amp;#125;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	InitList(&amp;amp;&lt;span class=&quot;built_in&quot;&gt;list&lt;/span&gt;);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;comment&quot;&gt;/* 对链表的操作&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	int a1 = 123, a2 = 456;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	char c1[20] = &quot;汤姆\0&quot;, c2[20] = &quot;杰克\0&quot;;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	PushBack(&amp;amp;list, &amp;amp;a1, c1);&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	PushBack(&amp;amp;list, &amp;amp;a2, c2);&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	NODE *p = GetNode(&amp;amp;list, 1);&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	PopBack(&amp;amp;list);&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	InsertNode(&amp;amp;list, 0, &amp;amp;a2, c2);&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	PushBack(&amp;amp;list, &amp;amp;a2, c2);&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	DeleteNode(&amp;amp;list, 1);&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	PrintList(&amp;amp;list);&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;comment&quot;&gt;	*/&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
      <category term="数据结构" scheme="https://G-SS-Hacker.github.io/tags/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/"/>
    
  </entry>
  
  <entry>
    <title>C语言基础学习笔记（11）：指针与数组的关系</title>
    <link href="https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%9F%BA%E7%A1%80%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%EF%BC%8811%EF%BC%89%EF%BC%9A%E6%8C%87%E9%92%88%E4%B8%8E%E6%95%B0%E7%BB%84%E7%9A%84%E5%85%B3%E7%B3%BB/"/>
    <id>https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%9F%BA%E7%A1%80%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%EF%BC%8811%EF%BC%89%EF%BC%9A%E6%8C%87%E9%92%88%E4%B8%8E%E6%95%B0%E7%BB%84%E7%9A%84%E5%85%B3%E7%B3%BB/</id>
    <published>2020-02-22T06:21:43.000Z</published>
    <updated>2020-02-22T06:30:30.366Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://cdn.pixabay.com/photo/2018/10/12/19/02/whitby-harbour-3742796_1280.jpg" alt></p><h1 id="C语言基础学习笔记（11）：指针与数组的关系"><a href="#C语言基础学习笔记（11）：指针与数组的关系" class="headerlink" title="C语言基础学习笔记（11）：指针与数组的关系"></a>C语言基础学习笔记（11）：指针与数组的关系</h1><blockquote><p>图： 北英格兰，惠特比港（Whitby Harbour）</p></blockquote><p><font color="grey"> <em>Guderian</em>出品 </font></p><h2 id="指针与一维数组的关系"><a href="#指针与一维数组的关系" class="headerlink" title="指针与一维数组的关系"></a>指针与一维数组的关系</h2><p>一维数组在内存中是线性排列的。假设存在一个任意的<code>int</code>类型数组<code>a[N]</code>，数组名<code>a</code>代表了数组的首地址<code>&amp;a[0]</code>，则<code>&amp;a[i]</code>等价于<code>(a+i)</code>。注意这里<code>a+1</code>不是加上<code>1</code>个字节，而是取决于<code>a</code>的基类型（这里是<code>int</code>，即为<code>4</code>个字节）：<code>a+1</code>等价于<code>a+sizeof(基类型)</code>。因此我们可以得出一维数组元素的等价引用形式：<code>a[i]</code>等价于<code>*(a+i)</code>。下面举两个例子：</p><h3 id="示例一"><a href="#示例一" class="headerlink" title="示例一"></a>示例一</h3><p>用指针读入一维数组并用指针输出一维数组：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> a[<span class="number">10</span>], i, *p = <span class="literal">NULL</span>;</span><br><span class="line">p = a;</span><br><span class="line"></span><br><span class="line"><span class="keyword">for</span> (i=<span class="number">0</span>; i&lt;<span class="number">10</span>; i++)</span><br><span class="line"><span class="built_in">scanf</span>(<span class="string">"%d"</span>, &amp;p[i]);</span><br><span class="line"></span><br><span class="line">p = a;</span><br><span class="line"><span class="keyword">for</span> (i=<span class="number">0</span>; i&lt;<span class="number">10</span>; i++)</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%d"</span>, p[i]);</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"></span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><h3 id="示例二"><a href="#示例二" class="headerlink" title="示例二"></a>示例二</h3><p>示例一的另一种实现方式：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> a[<span class="number">10</span>], *p = <span class="literal">NULL</span>;</span><br><span class="line"></span><br><span class="line"><span class="keyword">for</span> (p=a; p&lt;a+<span class="number">10</span>; p++)</span><br><span class="line"><span class="built_in">scanf</span>(<span class="string">"%d"</span>, p);</span><br><span class="line"></span><br><span class="line"><span class="keyword">for</span> (p=a; p&lt;a+<span class="number">10</span>; p++)</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%d"</span>, *p);</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"></span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><a id="more"></a><h2 id="指针与二维数组的关系"><a href="#指针与二维数组的关系" class="headerlink" title="指针与二维数组的关系"></a>指针与二维数组的关系</h2><blockquote><p>兄弟们，做好心理准备，<del>下面的内容对萌新不友好</del></p></blockquote><p>内存中数据的存储形式都是线性的，二维数组在内存中按行线性存储，但可以用两种方式看待它。</p><h3 id="第一种方式：行是列的索引"><a href="#第一种方式：行是列的索引" class="headerlink" title="第一种方式：行是列的索引"></a>第一种方式：行是列的索引</h3><p>以<code>a[2][3]</code>为例，它的存储结构如图：</p><p><img src="https://i.loli.net/2020/02/22/HiVPCyXxeLYJtRp.jpg" alt></p><p>想要访问某一行某一列的元素，需要先访问某一行，再访问某一列：首先定义类型为<code>int [3]</code>的行指针<code>int (*p)[3]</code>（不要写成<code>*p[3]</code>，否则就成了有三个元素的指针数组）用于存储<code>a[2][3]</code>的行指针，只需这么做：<code>p = a</code>或者<code>p = &amp;a[0]</code>。</p><p>这里要正确理解<code>a</code>和<code>&amp;a[0]</code>的含义，一种较为简单的理解方式是：首先把<code>a</code>看做一个一维数组<code>a[2]</code>，有两个<code>int [3]</code>型元素，那么其首地址就是<code>a</code>或者<code>&amp;a[0]</code>；然后再把<code>a[2]</code>看成一个一维数组<code>a[2][3]</code>，那么其首地址就是<code>a[0]</code>或者<code>*a</code>。<code>a</code>和<code>&amp;a[0]</code>的含义就是第<code>0</code>行的行指针，<code>*a</code>和<code>a[0]</code>和<code>&amp;a[0][0]</code>的含义就是第<code>0</code>行第<code>0</code>列的指针（后面在第二种方式会讲到）。</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> a[<span class="number">2</span>][<span class="number">3</span>] = &#123;<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">4</span>,<span class="number">5</span>,<span class="number">6</span>&#125;;</span><br><span class="line"><span class="keyword">int</span> (*p)[<span class="number">3</span>];</span><br><span class="line">p = a;</span><br><span class="line"><span class="keyword">for</span>(<span class="keyword">int</span> i=<span class="number">0</span>; i&lt;<span class="number">2</span>; i++)</span><br><span class="line"><span class="keyword">for</span>(<span class="keyword">int</span> j=<span class="number">0</span>; j&lt;<span class="number">3</span>; j++)</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%d "</span>, *(*(p+i)+j));</span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>输出结果为：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">1 2 3 4 5 6</span><br></pre></td></tr></table></figure><h3 id="第二种方式：Only-one-dimension-in-RAM"><a href="#第二种方式：Only-one-dimension-in-RAM" class="headerlink" title="第二种方式：Only one dimension in RAM!"></a>第二种方式：Only one dimension in RAM!</h3><p>这种方式模拟了数组在内存上存储的真实情况，把<code>a[2][3]</code>看做一维数组，先按行分块，每一块再按列排序，要访问一个元素只需计算它内存地址的偏移量即可。定义<code>int *p;</code>并令<code>p = &amp;a[0][0]</code>（或<code>*a</code>或<code>a[0]</code>），那么要访问<code>a[i][j]</code>只需等价于访问<code>*(p+i*2+j)</code>。</p><p><img src="https://i.loli.net/2020/02/22/jI1HthbcGBFdyMs.jpg" alt></p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> a[<span class="number">2</span>][<span class="number">3</span>] = &#123;<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>,<span class="number">4</span>,<span class="number">5</span>,<span class="number">6</span>&#125;;</span><br><span class="line"><span class="keyword">int</span> *p;</span><br><span class="line">p = *a;</span><br><span class="line"><span class="keyword">for</span>(<span class="keyword">int</span> i=<span class="number">0</span>; i&lt;<span class="number">2</span>; i++)</span><br><span class="line"><span class="keyword">for</span>(<span class="keyword">int</span> j=<span class="number">0</span>; j&lt;<span class="number">3</span>; j++)</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%d "</span>, *(p+i*<span class="number">2</span>+j));</span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>输出结果为：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">1 2 3 4 5 6</span><br></pre></td></tr></table></figure><hr><font color="#407600">【更多C语言系列】</font><ul><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-基本数据类型取值范围/">C &amp; C++基本数据类型取值范围</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-中memset用法/">C &amp; C++ memset</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/野指针的产生及其危害/">野指针的产生及其危害</a></li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://cdn.pixabay.com/photo/2018/10/12/19/02/whitby-harbour-3742796_1280.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h1 id=&quot;C语言基础学习笔记（11）：指针与数组的关系&quot;&gt;&lt;a href=&quot;#C语言基础学习笔记（11）：指针与数组的关系&quot; class=&quot;headerlink&quot; title=&quot;C语言基础学习笔记（11）：指针与数组的关系&quot;&gt;&lt;/a&gt;C语言基础学习笔记（11）：指针与数组的关系&lt;/h1&gt;&lt;blockquote&gt;
&lt;p&gt;图： 北英格兰，惠特比港（Whitby Harbour）&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian&lt;/em&gt;出品 &lt;/font&gt;&lt;/p&gt;

&lt;h2 id=&quot;指针与一维数组的关系&quot;&gt;&lt;a href=&quot;#指针与一维数组的关系&quot; class=&quot;headerlink&quot; title=&quot;指针与一维数组的关系&quot;&gt;&lt;/a&gt;指针与一维数组的关系&lt;/h2&gt;&lt;p&gt;一维数组在内存中是线性排列的。假设存在一个任意的&lt;code&gt;int&lt;/code&gt;类型数组&lt;code&gt;a[N]&lt;/code&gt;，数组名&lt;code&gt;a&lt;/code&gt;代表了数组的首地址&lt;code&gt;&amp;amp;a[0]&lt;/code&gt;，则&lt;code&gt;&amp;amp;a[i]&lt;/code&gt;等价于&lt;code&gt;(a+i)&lt;/code&gt;。注意这里&lt;code&gt;a+1&lt;/code&gt;不是加上&lt;code&gt;1&lt;/code&gt;个字节，而是取决于&lt;code&gt;a&lt;/code&gt;的基类型（这里是&lt;code&gt;int&lt;/code&gt;，即为&lt;code&gt;4&lt;/code&gt;个字节）：&lt;code&gt;a+1&lt;/code&gt;等价于&lt;code&gt;a+sizeof(基类型)&lt;/code&gt;。因此我们可以得出一维数组元素的等价引用形式：&lt;code&gt;a[i]&lt;/code&gt;等价于&lt;code&gt;*(a+i)&lt;/code&gt;。下面举两个例子：&lt;/p&gt;
&lt;h3 id=&quot;示例一&quot;&gt;&lt;a href=&quot;#示例一&quot; class=&quot;headerlink&quot; title=&quot;示例一&quot;&gt;&lt;/a&gt;示例一&lt;/h3&gt;&lt;p&gt;用指针读入一维数组并用指针输出一维数组：&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;12&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;13&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;14&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;15&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;16&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;17&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;main&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;()&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; a[&lt;span class=&quot;number&quot;&gt;10&lt;/span&gt;], i, *p = &lt;span class=&quot;literal&quot;&gt;NULL&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	p = a;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;for&lt;/span&gt; (i=&lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;; i&amp;lt;&lt;span class=&quot;number&quot;&gt;10&lt;/span&gt;; i++)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;		&lt;span class=&quot;built_in&quot;&gt;scanf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;%d&quot;&lt;/span&gt;, &amp;amp;p[i]);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	p = a;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;for&lt;/span&gt; (i=&lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;; i&amp;lt;&lt;span class=&quot;number&quot;&gt;10&lt;/span&gt;; i++)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;		&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;%d&quot;&lt;/span&gt;, p[i]);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;\n&quot;&lt;/span&gt;);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;h3 id=&quot;示例二&quot;&gt;&lt;a href=&quot;#示例二&quot; class=&quot;headerlink&quot; title=&quot;示例二&quot;&gt;&lt;/a&gt;示例二&lt;/h3&gt;&lt;p&gt;示例一的另一种实现方式：&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;12&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;13&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;14&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;15&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;main&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;()&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; a[&lt;span class=&quot;number&quot;&gt;10&lt;/span&gt;], *p = &lt;span class=&quot;literal&quot;&gt;NULL&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;for&lt;/span&gt; (p=a; p&amp;lt;a+&lt;span class=&quot;number&quot;&gt;10&lt;/span&gt;; p++)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;		&lt;span class=&quot;built_in&quot;&gt;scanf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;%d&quot;&lt;/span&gt;, p);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;for&lt;/span&gt; (p=a; p&amp;lt;a+&lt;span class=&quot;number&quot;&gt;10&lt;/span&gt;; p++)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;		&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;%d&quot;&lt;/span&gt;, *p);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;\n&quot;&lt;/span&gt;);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
  </entry>
  
  <entry>
    <title>C语言基础学习笔记（10）：字符串</title>
    <link href="https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%9F%BA%E7%A1%80%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%EF%BC%8810%EF%BC%89%EF%BC%9A%E5%AD%97%E7%AC%A6%E4%B8%B2/"/>
    <id>https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%9F%BA%E7%A1%80%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%EF%BC%8810%EF%BC%89%EF%BC%9A%E5%AD%97%E7%AC%A6%E4%B8%B2/</id>
    <published>2020-02-22T01:02:34.000Z</published>
    <updated>2020-06-20T02:49:58.416Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/02/21/h8eGkoCcIjUfQBE.jpg" alt></p><h1 id="C语言基础学习笔记（10）：字符串"><a href="#C语言基础学习笔记（10）：字符串" class="headerlink" title="C语言基础学习笔记（10）：字符串"></a>C语言基础学习笔记（10）：字符串</h1><blockquote><p>图： 第一张黑洞照片（The first image of a black hole published in April 2019）</p><p>​        by 事件视野望远镜（Event Horizon Telescope）</p></blockquote><p><font color="grey"> <em>Guderian</em>出品 </font></p><ol><li><p><code>C</code>语言中没有专门的字符串数据类型。在定义字符串，字符数组的长度应比字符串长度多<code>1</code>，给<code>\0</code>留个位置：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">define</span> STR_LEN 80</span></span><br><span class="line"><span class="keyword">char</span> str[STR_LEN+<span class="number">1</span>];</span><br></pre></td></tr></table></figure></li><li><p><code>C</code>语言常用字符串处理操作函数：<code>#include &lt;string.h&gt;</code></p><p>（1）<code>strlen(s);</code>返回字符串<code>s</code>的长度</p><p>（2）<code>strcpy(s1,s2);</code>复制<code>s2</code>至<code>s1</code>，返回<code>s1</code>的指针</p><p>（3）<code>strcat(s1,s2);</code>复制<code>s2</code>接在<code>s1</code>末尾，返回<code>s1</code>的指针</p><p>（4）<code>strcmp(s1,s2);</code>比较<code>s2</code>和<code>s1</code>的大小，返回<code>0</code>表示相等，返回值大于零表示<code>s1</code>比<code>s2</code>大，返回值小于零表示<code>s1</code>比<code>s2</code>小。（比较规则：当出现第一对不相等的字符时，由这两个字符决定所在字符串的大小，返回其<code>ASCII</code>码比较的差值。）</p><p>（5）<code>strncpy(s1,s2,n);</code>复制<code>s2</code>前面最多<code>n</code>个元素至<code>s1</code>中，比<code>strcpy()</code>更安全</p><p>（6）<code>strncat(s1,s2,n);</code>复制<code>s2</code>前面最多<code>n</code>个元素至<code>s1</code>末尾，比<code>strcat()</code>更安全</p><p>（7）<code>strncmp(s1,s2,n);</code>比较<code>s2</code>和<code>s1</code>前面最多<code>n</code>个元素的大小</p></li><li><p>向函数传递字符串的两种方法：</p><p>（1）用<strong>字符数组</strong>作函数参数</p><p>（2）用<strong>字符指针</strong>作函数参数</p></li><li><p>用<strong>字符数组</strong>作函数参数示例：计算实际字符个数</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="title">MyStrlen</span><span class="params">(<span class="keyword">const</span> <span class="keyword">char</span> str[])</span> <span class="comment">//防止原字符数组被修改</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">int</span> i;</span><br><span class="line">    <span class="keyword">unsigned</span> <span class="keyword">int</span> len = <span class="number">0</span>;</span><br><span class="line">    <span class="keyword">for</span> (i=<span class="number">0</span>; str[i]!=<span class="string">'\0'</span>; i++)</span><br><span class="line">        len++;</span><br><span class="line">    <span class="keyword">return</span> len;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure></li><li><p>用<strong>字符指针</strong>作函数参数示例：计算实际字符个数</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="title">MyStrlen</span><span class="params">(<span class="keyword">const</span> har *pstr)</span> <span class="comment">//防止原字符数组被修改</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">unsigned</span> <span class="keyword">int</span> len = <span class="number">0</span>;</span><br><span class="line"><span class="keyword">for</span> (; *pstr!=<span class="string">'\0'</span>; pstr++)</span><br><span class="line">        len++;</span><br><span class="line">    <span class="keyword">return</span> len;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure></li><li><p>用<strong>字符指针</strong>作函数参数示例：计算实际字符个数（<strong>Optimized versoin</strong>）</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="title">MyStrlen</span><span class="params">(<span class="keyword">const</span> <span class="keyword">char</span> *pstr)</span> <span class="comment">//防止原字符数组被修改</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">const</span> <span class="keyword">char</span> *start = pstr;</span><br><span class="line">    <span class="keyword">while</span> (*pstr)</span><br><span class="line">        pstr++;</span><br><span class="line">    <span class="keyword">return</span> pstr-start;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure></li><li><p>用<strong>字符数组</strong>作函数参数示例：复制字符串</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">MyStrcpy</span><span class="params">(<span class="keyword">char</span> dst[], <span class="keyword">char</span> src[])</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">int</span> i = <span class="number">0</span>;</span><br><span class="line">    <span class="keyword">while</span> (src[i]!=<span class="string">'\0'</span>)</span><br><span class="line">    &#123;</span><br><span class="line">        dst[i] = src[i];</span><br><span class="line">        i++;</span><br><span class="line">    &#125;</span><br><span class="line">    dst[i] = <span class="string">'\0'</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure></li><li><p>用<strong>字符指针</strong>作函数参数示例：复制字符串</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">MyStrcpy</span><span class="params">(<span class="keyword">char</span> *dst, <span class="keyword">char</span> *src)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">while</span> (*src!=<span class="string">'\0'</span>)</span><br><span class="line">    &#123;</span><br><span class="line">        *dst = *src;</span><br><span class="line">        src++;</span><br><span class="line">        dst++</span><br><span class="line">    &#125;</span><br><span class="line">    *dst = <span class="string">'\0'</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure></li><li><p>用<strong>字符指针</strong>作函数参数示例：复制字符串（<strong>Insane versoin!!!</strong>）</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">MyStrcpy</span><span class="params">(<span class="keyword">char</span> *dst, <span class="keyword">const</span> <span class="keyword">char</span> *src)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">while</span> (*dst++ = *src++);<span class="comment">//空字符被赋值之后循环才结束</span></span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure></li><li><p><strong>不要写没人能看懂的代码！</strong>第6点、第9点和第12点的代码风格<strong>仅供欣赏！DO NOT TRY IT AT HOME!</strong></p><a id="more"></a></li><li><p>从函数返回字符指针，如<code>strcpy()</code>和<code>strcat()</code>的函数原型：</p><p><code>strcpy()</code>：<code>char *strcpy(char *dstStr, const char *srcStr);</code></p><p><code>strcat()</code>：<code>char *strcat(char *dstStr, const char *srcStr);</code></p></li><li><p>编程实现<code>strcat()</code>：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">char</span> *<span class="title">MyStrcat</span><span class="params">(<span class="keyword">char</span> *dst, <span class="keyword">char</span> *src)</span></span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">char</span> s1[<span class="number">10</span>] = &#123;<span class="string">"123"</span>&#125;;</span><br><span class="line"><span class="keyword">char</span> s2[]   = <span class="string">"45"</span>;</span><br><span class="line"><span class="keyword">char</span> *res = <span class="literal">NULL</span>;</span><br><span class="line">res = MyStrcat(s1,s2);</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%s"</span>,res);</span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">char</span> *<span class="title">MyStrcat</span><span class="params">(<span class="keyword">char</span> *dst, <span class="keyword">char</span> *src)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">    <span class="keyword">char</span> *pstr = dst;</span><br><span class="line">    <span class="keyword">while</span> (*dst!=<span class="string">'\0'</span>) dst++;</span><br><span class="line">    <span class="keyword">while</span> (*dst++ = *src++);</span><br><span class="line">    <span class="keyword">return</span> pstr;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure></li></ol><hr><font color="#407600">【更多C语言系列】</font><ul><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-基本数据类型取值范围/">C &amp; C++基本数据类型取值范围</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-中memset用法/">C &amp; C++ memset</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/野指针的产生及其危害/">野指针的产生及其危害</a></li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/02/21/h8eGkoCcIjUfQBE.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h1 id=&quot;C语言基础学习笔记（10）：字符串&quot;&gt;&lt;a href=&quot;#C语言基础学习笔记（10）：字符串&quot; class=&quot;headerlink&quot; title=&quot;C语言基础学习笔记（10）：字符串&quot;&gt;&lt;/a&gt;C语言基础学习笔记（10）：字符串&lt;/h1&gt;&lt;blockquote&gt;
&lt;p&gt;图： 第一张黑洞照片（The first image of a black hole published in April 2019）&lt;/p&gt;
&lt;p&gt;​        by 事件视野望远镜（Event Horizon Telescope）&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian&lt;/em&gt;出品 &lt;/font&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;code&gt;C&lt;/code&gt;语言中没有专门的字符串数据类型。在定义字符串，字符数组的长度应比字符串长度多&lt;code&gt;1&lt;/code&gt;，给&lt;code&gt;\0&lt;/code&gt;留个位置：&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;define&lt;/span&gt; STR_LEN 80&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; str[STR_LEN+&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;];&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;code&gt;C&lt;/code&gt;语言常用字符串处理操作函数：&lt;code&gt;#include &amp;lt;string.h&amp;gt;&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;（1）&lt;code&gt;strlen(s);&lt;/code&gt;返回字符串&lt;code&gt;s&lt;/code&gt;的长度&lt;/p&gt;
&lt;p&gt;（2）&lt;code&gt;strcpy(s1,s2);&lt;/code&gt;复制&lt;code&gt;s2&lt;/code&gt;至&lt;code&gt;s1&lt;/code&gt;，返回&lt;code&gt;s1&lt;/code&gt;的指针&lt;/p&gt;
&lt;p&gt;（3）&lt;code&gt;strcat(s1,s2);&lt;/code&gt;复制&lt;code&gt;s2&lt;/code&gt;接在&lt;code&gt;s1&lt;/code&gt;末尾，返回&lt;code&gt;s1&lt;/code&gt;的指针&lt;/p&gt;
&lt;p&gt;（4）&lt;code&gt;strcmp(s1,s2);&lt;/code&gt;比较&lt;code&gt;s2&lt;/code&gt;和&lt;code&gt;s1&lt;/code&gt;的大小，返回&lt;code&gt;0&lt;/code&gt;表示相等，返回值大于零表示&lt;code&gt;s1&lt;/code&gt;比&lt;code&gt;s2&lt;/code&gt;大，返回值小于零表示&lt;code&gt;s1&lt;/code&gt;比&lt;code&gt;s2&lt;/code&gt;小。（比较规则：当出现第一对不相等的字符时，由这两个字符决定所在字符串的大小，返回其&lt;code&gt;ASCII&lt;/code&gt;码比较的差值。）&lt;/p&gt;
&lt;p&gt;（5）&lt;code&gt;strncpy(s1,s2,n);&lt;/code&gt;复制&lt;code&gt;s2&lt;/code&gt;前面最多&lt;code&gt;n&lt;/code&gt;个元素至&lt;code&gt;s1&lt;/code&gt;中，比&lt;code&gt;strcpy()&lt;/code&gt;更安全&lt;/p&gt;
&lt;p&gt;（6）&lt;code&gt;strncat(s1,s2,n);&lt;/code&gt;复制&lt;code&gt;s2&lt;/code&gt;前面最多&lt;code&gt;n&lt;/code&gt;个元素至&lt;code&gt;s1&lt;/code&gt;末尾，比&lt;code&gt;strcat()&lt;/code&gt;更安全&lt;/p&gt;
&lt;p&gt;（7）&lt;code&gt;strncmp(s1,s2,n);&lt;/code&gt;比较&lt;code&gt;s2&lt;/code&gt;和&lt;code&gt;s1&lt;/code&gt;前面最多&lt;code&gt;n&lt;/code&gt;个元素的大小&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;向函数传递字符串的两种方法：&lt;/p&gt;
&lt;p&gt;（1）用&lt;strong&gt;字符数组&lt;/strong&gt;作函数参数&lt;/p&gt;
&lt;p&gt;（2）用&lt;strong&gt;字符指针&lt;/strong&gt;作函数参数&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;用&lt;strong&gt;字符数组&lt;/strong&gt;作函数参数示例：计算实际字符个数&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;unsigned&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;MyStrlen&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; str[])&lt;/span&gt; &lt;span class=&quot;comment&quot;&gt;//防止原字符数组被修改&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; i;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;unsigned&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; len = &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;for&lt;/span&gt; (i=&lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;; str[i]!=&lt;span class=&quot;string&quot;&gt;&#39;\0&#39;&lt;/span&gt;; i++)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        len++;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; len;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;用&lt;strong&gt;字符指针&lt;/strong&gt;作函数参数示例：计算实际字符个数&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;unsigned&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;MyStrlen&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;const&lt;/span&gt; har *pstr)&lt;/span&gt; &lt;span class=&quot;comment&quot;&gt;//防止原字符数组被修改&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;unsigned&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; len = &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;for&lt;/span&gt; (; *pstr!=&lt;span class=&quot;string&quot;&gt;&#39;\0&#39;&lt;/span&gt;; pstr++)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        len++;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; len;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;用&lt;strong&gt;字符指针&lt;/strong&gt;作函数参数示例：计算实际字符个数（&lt;strong&gt;Optimized versoin&lt;/strong&gt;）&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;unsigned&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;MyStrlen&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; *pstr)&lt;/span&gt; &lt;span class=&quot;comment&quot;&gt;//防止原字符数组被修改&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; *start = pstr;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;while&lt;/span&gt; (*pstr)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        pstr++;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; pstr-start;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;用&lt;strong&gt;字符数组&lt;/strong&gt;作函数参数示例：复制字符串&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;MyStrcpy&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; dst[], &lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; src[])&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; i = &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;while&lt;/span&gt; (src[i]!=&lt;span class=&quot;string&quot;&gt;&#39;\0&#39;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        dst[i] = src[i];&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        i++;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &amp;#125;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    dst[i] = &lt;span class=&quot;string&quot;&gt;&#39;\0&#39;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;用&lt;strong&gt;字符指针&lt;/strong&gt;作函数参数示例：复制字符串&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;MyStrcpy&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; *dst, &lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; *src)&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;while&lt;/span&gt; (*src!=&lt;span class=&quot;string&quot;&gt;&#39;\0&#39;&lt;/span&gt;)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        *dst = *src;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        src++;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;        dst++&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &amp;#125;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    *dst = &lt;span class=&quot;string&quot;&gt;&#39;\0&#39;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;用&lt;strong&gt;字符指针&lt;/strong&gt;作函数参数示例：复制字符串（&lt;strong&gt;Insane versoin!!!&lt;/strong&gt;）&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;MyStrcpy&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; *dst, &lt;span class=&quot;keyword&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; *src)&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;    &lt;span class=&quot;keyword&quot;&gt;while&lt;/span&gt; (*dst++ = *src++);	&lt;span class=&quot;comment&quot;&gt;//空字符被赋值之后循环才结束&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;不要写没人能看懂的代码！&lt;/strong&gt;第6点、第9点和第12点的代码风格&lt;strong&gt;仅供欣赏！DO NOT TRY IT AT HOME!&lt;/strong&gt;&lt;/p&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
  </entry>
  
  <entry>
    <title>C语言基础学习笔记（9）：指针</title>
    <link href="https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%9F%BA%E7%A1%80%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%EF%BC%889%EF%BC%89%EF%BC%9A%E6%8C%87%E9%92%88/"/>
    <id>https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%9F%BA%E7%A1%80%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0%EF%BC%889%EF%BC%89%EF%BC%9A%E6%8C%87%E9%92%88/</id>
    <published>2020-02-22T00:58:56.000Z</published>
    <updated>2020-02-22T00:59:38.198Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://s2.ax1x.com/2020/02/20/3etJZd.jpg" alt></p><h1 id="C语言基础学习笔记（9）：指针"><a href="#C语言基础学习笔记（9）：指针" class="headerlink" title="C语言基础学习笔记（9）：指针"></a>C语言基础学习笔记（9）：指针</h1><blockquote><p>图：土星光环</p></blockquote><p><font color="grey"> <em>Guderian</em>出品 </font></p><blockquote><p>请把本文与本文与一篇上古时期的佛经<a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/c-指针及其应用/">C++的指针变量</a>进行对比参考🕮</p></blockquote><ol><li><p><code>int *a</code>和<code>*a</code>有着巨大的差别：<code>int *a</code>是定义一个指向<code>int</code>类型数据的指针<code>a</code>；<code>*a</code>是对指针<code>a</code>解引用（Pointer Dereference），<code>*a</code>*即为指针<code>a</code>所指向的内存地址上存储的数据。如：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> a = <span class="number">0</span>, b = <span class="number">1</span>;</span><br><span class="line"><span class="keyword">int</span> *pa, *pb;</span><br><span class="line"><span class="comment">//不能写成int* pa, pb，这样只表示pa是一个指针变量，pb是一个整型变量</span></span><br><span class="line">pa = &amp;a;</span><br><span class="line">pb = &amp;b;</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"a=%d, b=%d\n"</span>, a, b);</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"*pa=%d, *pb=%d\n"</span>, *pa, *pb);</span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>输出结果为：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">a=0, b=1</span><br><span class="line">*pa=0, *pb=1</span><br></pre></td></tr></table></figure></li><li><p><code>C</code>语言中，只要<code>pa</code>指向<code>a</code>,<code>*pa</code>就是<code>a</code>的别名。</p></li><li><p>指针变量的一大应用就是用作函数参数，这样做的好处就是可以再被调函数中改变实参的值。比如：</p><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Func</span><span class="params">(<span class="keyword">int</span> *par)</span></span>;</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> arg = <span class="number">1</span>;</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"arg = %d\n"</span>, arg);</span><br><span class="line">Func(&amp;arg);</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"arg = %d\n"</span>, arg);</span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Func</span><span class="params">(<span class="keyword">int</span> *par)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"par = %d\n"</span>, *par);</span><br><span class="line">*par = <span class="number">2</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>输出结果为：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">arg = 1</span><br><span class="line">par = 1</span><br><span class="line">arg = 2</span><br></pre></td></tr></table></figure></li><li><p><strong>函数指针（Function Pointer）</strong>：就是指向函数的指针变量</p><p><code>数据类型 (*指针变量名)(形参列表)</code></p></li><li><p>函数指针示例：</p><p>若有函数原型：<code>int Func(int a, int b);</code></p><p>则可定义函数指针<code>int (*f)(int, int);</code></p><p>令<code>f = Func;</code>就是让<code>f</code>指向函数<code>Func()</code></p><ul><li>编译器将不带<code>()</code>的函数名解释为该函数的入口地址</li><li>函数指针变量存储的是函数在内存中的入口地址</li></ul></li><li><p>正确写法<code>int (*f)(int, int);</code>。常见错误：</p><p>（1）忘了写前一个<code>()</code>：<code>int *f(int, int);</code>，等价于声明了一个函数名为<code>f</code>、返回值是整型指针类型的函数；</p><p>（2）忘了写后一个<code>()</code>：<code>int (*f);</code>，等价于定义了一个整型指针变量</p></li></ol><a id="more"></a><blockquote><p>看完再看：<a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/c-指针及其应用/">C++的指针变量</a></p></blockquote><hr><font color="#407600">【更多C语言系列】</font><ul><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-基本数据类型取值范围/">C &amp; C++基本数据类型取值范围</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-中memset用法/">C &amp; C++ memset</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/野指针的产生及其危害/">野指针的产生及其危害</a></li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://s2.ax1x.com/2020/02/20/3etJZd.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h1 id=&quot;C语言基础学习笔记（9）：指针&quot;&gt;&lt;a href=&quot;#C语言基础学习笔记（9）：指针&quot; class=&quot;headerlink&quot; title=&quot;C语言基础学习笔记（9）：指针&quot;&gt;&lt;/a&gt;C语言基础学习笔记（9）：指针&lt;/h1&gt;&lt;blockquote&gt;
&lt;p&gt;图：土星光环&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian&lt;/em&gt;出品 &lt;/font&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;请把本文与本文与一篇上古时期的佛经&lt;a href=&quot;https://g-ss-hacker.github.io/G-SS-Hacker.github.io/c-指针及其应用/&quot;&gt;C++的指针变量&lt;/a&gt;进行对比参考🕮&lt;/p&gt;
&lt;/blockquote&gt;
&lt;ol&gt;
&lt;li&gt;&lt;p&gt;&lt;code&gt;int *a&lt;/code&gt;和&lt;code&gt;*a&lt;/code&gt;有着巨大的差别：&lt;code&gt;int *a&lt;/code&gt;是定义一个指向&lt;code&gt;int&lt;/code&gt;类型数据的指针&lt;code&gt;a&lt;/code&gt;；&lt;code&gt;*a&lt;/code&gt;是对指针&lt;code&gt;a&lt;/code&gt;解引用（Pointer Dereference），&lt;code&gt;*a&lt;/code&gt;*即为指针&lt;code&gt;a&lt;/code&gt;所指向的内存地址上存储的数据。如：&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;12&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;main&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;()&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; a = &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;, b = &lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *pa, *pb;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;comment&quot;&gt;//不能写成int* pa, pb，这样只表示pa是一个指针变量，pb是一个整型变量&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	pa = &amp;amp;a;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	pb = &amp;amp;b;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;a=%d, b=%d\n&quot;&lt;/span&gt;, a, b);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;*pa=%d, *pb=%d\n&quot;&lt;/span&gt;, *pa, *pb);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;p&gt;输出结果为：&lt;/p&gt;
&lt;figure class=&quot;highlight plain&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;a=0, b=1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;*pa=0, *pb=1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;code&gt;C&lt;/code&gt;语言中，只要&lt;code&gt;pa&lt;/code&gt;指向&lt;code&gt;a&lt;/code&gt;,&lt;code&gt;*pa&lt;/code&gt;就是&lt;code&gt;a&lt;/code&gt;的别名。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;指针变量的一大应用就是用作函数参数，这样做的好处就是可以再被调函数中改变实参的值。比如：&lt;/p&gt;
&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;12&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;13&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;14&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;15&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;Func&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *par)&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;main&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;()&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; arg = &lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;arg = %d\n&quot;&lt;/span&gt;, arg);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	Func(&amp;amp;arg);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;arg = %d\n&quot;&lt;/span&gt;, arg);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;Func&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *par)&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;par = %d\n&quot;&lt;/span&gt;, *par);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	*par = &lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;p&gt;输出结果为：&lt;/p&gt;
&lt;figure class=&quot;highlight plain&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;arg = 1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;par = 1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;arg = 2&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;&lt;strong&gt;函数指针（Function Pointer）&lt;/strong&gt;：就是指向函数的指针变量&lt;/p&gt;
&lt;p&gt;&lt;code&gt;数据类型 (*指针变量名)(形参列表)&lt;/code&gt;&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;函数指针示例：&lt;/p&gt;
&lt;p&gt;若有函数原型：&lt;code&gt;int Func(int a, int b);&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;则可定义函数指针&lt;code&gt;int (*f)(int, int);&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;令&lt;code&gt;f = Func;&lt;/code&gt;就是让&lt;code&gt;f&lt;/code&gt;指向函数&lt;code&gt;Func()&lt;/code&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;编译器将不带&lt;code&gt;()&lt;/code&gt;的函数名解释为该函数的入口地址&lt;/li&gt;
&lt;li&gt;函数指针变量存储的是函数在内存中的入口地址&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;正确写法&lt;code&gt;int (*f)(int, int);&lt;/code&gt;。常见错误：&lt;/p&gt;
&lt;p&gt;（1）忘了写前一个&lt;code&gt;()&lt;/code&gt;：&lt;code&gt;int *f(int, int);&lt;/code&gt;，等价于声明了一个函数名为&lt;code&gt;f&lt;/code&gt;、返回值是整型指针类型的函数；&lt;/p&gt;
&lt;p&gt;（2）忘了写后一个&lt;code&gt;()&lt;/code&gt;：&lt;code&gt;int (*f);&lt;/code&gt;，等价于定义了一个整型指针变量&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
  </entry>
  
  <entry>
    <title>C语言实现选择、插入、冒泡排序算法</title>
    <link href="https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%AE%9E%E7%8E%B0%E9%80%89%E6%8B%A9%E3%80%81%E6%8F%92%E5%85%A5%E3%80%81%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/"/>
    <id>https://g-ss-hacker.github.io/C%E8%AF%AD%E8%A8%80%E5%AE%9E%E7%8E%B0%E9%80%89%E6%8B%A9%E3%80%81%E6%8F%92%E5%85%A5%E3%80%81%E5%86%92%E6%B3%A1%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95/</id>
    <published>2020-02-20T16:13:33.000Z</published>
    <updated>2020-05-07T11:58:56.146Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/02/22/gNxkyurqLY64MA2.jpg" alt></p><h1 id="C语言实现选择、插入、冒泡排序算法"><a href="#C语言实现选择、插入、冒泡排序算法" class="headerlink" title="C语言实现选择、插入、冒泡排序算法"></a>C语言实现选择、插入、冒泡排序算法</h1><p></p><p><font color="grey"> <em>Guderian</em>出品 </font></p><p></p><h2 id="准备工作"><a href="#准备工作" class="headerlink" title="准备工作"></a>准备工作</h2><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"></span><br><span class="line"><span class="keyword">const</span> <span class="keyword">int</span> N = <span class="number">10</span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">swap</span><span class="params">(<span class="keyword">int</span> *x, <span class="keyword">int</span> *y)</span></span>;</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Sort</span><span class="params">(<span class="keyword">int</span> arr[], <span class="keyword">void</span>(*f)(<span class="keyword">int</span> *))</span></span>;</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">SelectionSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span>;</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">InsertionSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span>;</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">BubbleSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span>;</span><br></pre></td></tr></table></figure><h2 id="主函数"><a href="#主函数" class="headerlink" title="主函数"></a>主函数</h2><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> a[N] = &#123;<span class="number">2</span>,<span class="number">1</span>,<span class="number">3</span>,<span class="number">9</span>,<span class="number">8</span>,<span class="number">6</span>,<span class="number">5</span>,<span class="number">0</span>,<span class="number">4</span>,<span class="number">7</span>&#125;;</span><br><span class="line">Sort(a, InsertionSort);<span class="comment">//此处选择排序算法</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i &lt; N; i++)</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%d "</span>, a[i]);</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"></span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><h2 id="实现两数交换函数"><a href="#实现两数交换函数" class="headerlink" title="实现两数交换函数"></a>实现两数交换函数</h2><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">swap</span><span class="params">(<span class="keyword">int</span> *x, <span class="keyword">int</span> *y)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> tmp = *x;</span><br><span class="line">*x = *y;</span><br><span class="line">*y = tmp;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><h2 id="实现选择排序函数"><a href="#实现选择排序函数" class="headerlink" title="实现选择排序函数"></a>实现选择排序函数</h2><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">SelectionSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i &lt; N<span class="number">-1</span>; i++)</span><br><span class="line">&#123;</span><br><span class="line"><span class="keyword">int</span> min = i;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> j = i+<span class="number">1</span>; j &lt; N; j++)</span><br><span class="line"><span class="keyword">if</span> (arr[j] &lt; arr[min])</span><br><span class="line">min = j;</span><br><span class="line">swap(&amp;arr[i], &amp;arr[min]);</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><a id="more"></a><h2 id="实现插入排序函数"><a href="#实现插入排序函数" class="headerlink" title="实现插入排序函数"></a>实现插入排序函数</h2><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">InsertionSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i &lt; N; i++)</span><br><span class="line">&#123;</span><br><span class="line"><span class="keyword">int</span> j = i<span class="number">-1</span>;</span><br><span class="line"><span class="keyword">int</span> key = arr[i];</span><br><span class="line"><span class="keyword">while</span>(j &gt;= <span class="number">0</span> &amp;&amp; arr[j] &gt;= key)</span><br><span class="line">&#123;</span><br><span class="line">arr[j+<span class="number">1</span>] = arr[j];</span><br><span class="line">j--;</span><br><span class="line">&#125;</span><br><span class="line">arr[j+<span class="number">1</span>] = key;</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><h2 id="实现冒泡排序函数"><a href="#实现冒泡排序函数" class="headerlink" title="实现冒泡排序函数"></a>实现冒泡排序函数</h2><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">BubbleSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>, exchange = <span class="number">1</span>; exchange &amp;&amp; i &lt; N<span class="number">-1</span>; i++)</span><br><span class="line">&#123;</span><br><span class="line">exchange = <span class="number">0</span>;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">0</span>; j &lt; N<span class="number">-1</span>-i; j++)</span><br><span class="line"><span class="keyword">if</span> (arr[j] &gt; arr[j+<span class="number">1</span>])</span><br><span class="line">&#123;</span><br><span class="line">swap(&amp;arr[j], &amp;arr[j+<span class="number">1</span>]);</span><br><span class="line">exchange = <span class="number">1</span>;</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><h2 id="完整代码"><a href="#完整代码" class="headerlink" title="完整代码"></a>完整代码</h2><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br><span class="line">26</span><br><span class="line">27</span><br><span class="line">28</span><br><span class="line">29</span><br><span class="line">30</span><br><span class="line">31</span><br><span class="line">32</span><br><span class="line">33</span><br><span class="line">34</span><br><span class="line">35</span><br><span class="line">36</span><br><span class="line">37</span><br><span class="line">38</span><br><span class="line">39</span><br><span class="line">40</span><br><span class="line">41</span><br><span class="line">42</span><br><span class="line">43</span><br><span class="line">44</span><br><span class="line">45</span><br><span class="line">46</span><br><span class="line">47</span><br><span class="line">48</span><br><span class="line">49</span><br><span class="line">50</span><br><span class="line">51</span><br><span class="line">52</span><br><span class="line">53</span><br><span class="line">54</span><br><span class="line">55</span><br><span class="line">56</span><br><span class="line">57</span><br><span class="line">58</span><br><span class="line">59</span><br><span class="line">60</span><br><span class="line">61</span><br><span class="line">62</span><br><span class="line">63</span><br><span class="line">64</span><br><span class="line">65</span><br><span class="line">66</span><br><span class="line">67</span><br><span class="line">68</span><br><span class="line">69</span><br><span class="line">70</span><br><span class="line">71</span><br><span class="line">72</span><br><span class="line">73</span><br><span class="line">74</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"></span><br><span class="line"><span class="meta">#<span class="meta-keyword">define</span> N 10</span></span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">swap</span><span class="params">(<span class="keyword">int</span> *x, <span class="keyword">int</span> *y)</span></span>;</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Sort</span><span class="params">(<span class="keyword">int</span> arr[], <span class="keyword">void</span>(*f)(<span class="keyword">int</span> *))</span></span>;</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">SelectionSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span>;</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">InsertionSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span>;</span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">BubbleSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span>;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> a[N] = &#123;<span class="number">2</span>,<span class="number">1</span>,<span class="number">3</span>,<span class="number">9</span>,<span class="number">8</span>,<span class="number">6</span>,<span class="number">5</span>,<span class="number">0</span>,<span class="number">4</span>,<span class="number">7</span>&#125;;</span><br><span class="line">Sort(a, InsertionSort);<span class="comment">//此处选择排序算法</span></span><br><span class="line"></span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i &lt; N; i++)</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%d "</span>, a[i]);</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"\n"</span>);</span><br><span class="line"></span><br><span class="line"><span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">swap</span><span class="params">(<span class="keyword">int</span> *x, <span class="keyword">int</span> *y)</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">int</span> tmp = *x;</span><br><span class="line">*x = *y;</span><br><span class="line">*y = tmp;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">Sort</span><span class="params">(<span class="keyword">int</span> arr[], <span class="keyword">void</span>(*f)(<span class="keyword">int</span> *))</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line">(*f)(arr);</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">SelectionSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>; i &lt; N<span class="number">-1</span>; i++)</span><br><span class="line">&#123;</span><br><span class="line"><span class="keyword">int</span> min = i;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> j = i+<span class="number">1</span>; j &lt; N; j++)</span><br><span class="line"><span class="keyword">if</span> (arr[j] &lt; arr[min])</span><br><span class="line">min = j;</span><br><span class="line">swap(&amp;arr[i], &amp;arr[min]);</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">InsertionSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">1</span>; i &lt; N; i++)</span><br><span class="line">&#123;</span><br><span class="line"><span class="keyword">int</span> j = i<span class="number">-1</span>;</span><br><span class="line"><span class="keyword">int</span> key = arr[i];</span><br><span class="line"><span class="keyword">while</span>(j &gt;= <span class="number">0</span> &amp;&amp; arr[j] &gt;= key)</span><br><span class="line">&#123;</span><br><span class="line">arr[j+<span class="number">1</span>] = arr[j];</span><br><span class="line">j--;</span><br><span class="line">&#125;</span><br><span class="line">arr[j+<span class="number">1</span>] = key;</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="function"><span class="keyword">void</span> <span class="title">BubbleSort</span><span class="params">(<span class="keyword">int</span> arr[])</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> i = <span class="number">0</span>, exchange = <span class="number">1</span>; exchange &amp;&amp; i &lt; N<span class="number">-1</span>; i++)</span><br><span class="line">&#123;</span><br><span class="line">exchange = <span class="number">0</span>;</span><br><span class="line"><span class="keyword">for</span> (<span class="keyword">int</span> j = <span class="number">0</span>; j &lt; N<span class="number">-1</span>-i; j++)</span><br><span class="line"><span class="keyword">if</span> (arr[j] &gt; arr[j+<span class="number">1</span>])</span><br><span class="line">&#123;</span><br><span class="line">swap(&amp;arr[j], &amp;arr[j+<span class="number">1</span>]);</span><br><span class="line">exchange = <span class="number">1</span>;</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><hr><font color="#407600">【更多C语言系列】</font><ul><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-基本数据类型取值范围/">C &amp; C++基本数据类型取值范围</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-中memset用法/">C &amp; C++ memset</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/野指针的产生及其危害/">野指针的产生及其危害</a></li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/02/22/gNxkyurqLY64MA2.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h1 id=&quot;C语言实现选择、插入、冒泡排序算法&quot;&gt;&lt;a href=&quot;#C语言实现选择、插入、冒泡排序算法&quot; class=&quot;headerlink&quot; title=&quot;C语言实现选择、插入、冒泡排序算法&quot;&gt;&lt;/a&gt;C语言实现选择、插入、冒泡排序算法&lt;/h1&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian&lt;/em&gt;出品 &lt;/font&gt;&lt;/p&gt;&lt;p&gt;&lt;/p&gt;
&lt;h2 id=&quot;准备工作&quot;&gt;&lt;a href=&quot;#准备工作&quot; class=&quot;headerlink&quot; title=&quot;准备工作&quot;&gt;&lt;/a&gt;准备工作&lt;/h2&gt;&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;const&lt;/span&gt; &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; N = &lt;span class=&quot;number&quot;&gt;10&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;swap&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *x, &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *y)&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;Sort&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; arr[], &lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt;(*f)(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *))&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;SelectionSort&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; arr[])&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;InsertionSort&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; arr[])&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;BubbleSort&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; arr[])&lt;/span&gt;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;h2 id=&quot;主函数&quot;&gt;&lt;a href=&quot;#主函数&quot; class=&quot;headerlink&quot; title=&quot;主函数&quot;&gt;&lt;/a&gt;主函数&lt;/h2&gt;&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;main&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;()&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; a[N] = &amp;#123;&lt;span class=&quot;number&quot;&gt;2&lt;/span&gt;,&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;,&lt;span class=&quot;number&quot;&gt;3&lt;/span&gt;,&lt;span class=&quot;number&quot;&gt;9&lt;/span&gt;,&lt;span class=&quot;number&quot;&gt;8&lt;/span&gt;,&lt;span class=&quot;number&quot;&gt;6&lt;/span&gt;,&lt;span class=&quot;number&quot;&gt;5&lt;/span&gt;,&lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;,&lt;span class=&quot;number&quot;&gt;4&lt;/span&gt;,&lt;span class=&quot;number&quot;&gt;7&lt;/span&gt;&amp;#125;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	Sort(a, InsertionSort);	&lt;span class=&quot;comment&quot;&gt;//此处选择排序算法&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;for&lt;/span&gt; (&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; i = &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;; i &amp;lt; N; i++)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;		&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;%d &quot;&lt;/span&gt;, a[i]);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;\n&quot;&lt;/span&gt;);	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt; &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;h2 id=&quot;实现两数交换函数&quot;&gt;&lt;a href=&quot;#实现两数交换函数&quot; class=&quot;headerlink&quot; title=&quot;实现两数交换函数&quot;&gt;&lt;/a&gt;实现两数交换函数&lt;/h2&gt;&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;swap&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *x, &lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; *y)&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; tmp = *x;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	*x = *y;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	*y = tmp;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;h2 id=&quot;实现选择排序函数&quot;&gt;&lt;a href=&quot;#实现选择排序函数&quot; class=&quot;headerlink&quot; title=&quot;实现选择排序函数&quot;&gt;&lt;/a&gt;实现选择排序函数&lt;/h2&gt;&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;void&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;SelectionSort&lt;/span&gt;&lt;span class=&quot;params&quot;&gt;(&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; arr[])&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;for&lt;/span&gt; (&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; i = &lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;; i &amp;lt; N&lt;span class=&quot;number&quot;&gt;-1&lt;/span&gt;; i++)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;		&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; min = i;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;		&lt;span class=&quot;keyword&quot;&gt;for&lt;/span&gt; (&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; j = i+&lt;span class=&quot;number&quot;&gt;1&lt;/span&gt;; j &amp;lt; N; j++)&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;			&lt;span class=&quot;keyword&quot;&gt;if&lt;/span&gt; (arr[j] &amp;lt; arr[min])&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;				min = j;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;		swap(&amp;amp;arr[i], &amp;amp;arr[min]);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
      <category term="排序" scheme="https://G-SS-Hacker.github.io/tags/%E6%8E%92%E5%BA%8F/"/>
    
      <category term="算法" scheme="https://G-SS-Hacker.github.io/tags/%E7%AE%97%E6%B3%95/"/>
    
  </entry>
  
  <entry>
    <title>C和C++中memcpy用法</title>
    <link href="https://g-ss-hacker.github.io/C%E5%92%8CC-%E4%B8%ADmemcpy%E7%94%A8%E6%B3%95/"/>
    <id>https://g-ss-hacker.github.io/C%E5%92%8CC-%E4%B8%ADmemcpy%E7%94%A8%E6%B3%95/</id>
    <published>2020-02-20T02:29:22.000Z</published>
    <updated>2020-02-22T01:26:27.441Z</updated>
    
    <content type="html"><![CDATA[<p><img src="https://i.loli.net/2020/02/22/5J6bmYjvsQe37nf.jpg" alt></p><h1 id="C和C-中memcpy-函数"><a href="#C和C-中memcpy-函数" class="headerlink" title="C和C++中memcpy()函数"></a>C和C++中memcpy()函数</h1><p></p><p><font color="grey"> <em>Guderian</em>出品 </font></p><p></p><h2 id="头文件"><a href="#头文件" class="headerlink" title="头文件"></a>头文件</h2><ul><li>C：      <code>&lt;string.h&gt;</code></li><li>C++：  <code>&lt;cstring&gt;</code></li></ul><h2 id="声明"><a href="#声明" class="headerlink" title="声明"></a>声明</h2><p><code>void *memcpy(void *str1, const void *str2, size_t n)</code></p><p>此处<code>size_t</code>变量类型等价于<code>long unsigned int</code>即无符号长整型，在32位机器上为32位，在64位机器为中64位。</p><p>注：32位机器指CPU通用寄存器的数据宽度为32位，也就是说CPU一次可以运行32bit数据</p><h2 id="描述"><a href="#描述" class="headerlink" title="描述"></a>描述</h2><p>从内存 <strong>str2</strong> 复制 <strong>n</strong> 个字符到内存 <strong>str1</strong></p><h2 id="参数"><a href="#参数" class="headerlink" title="参数"></a>参数</h2><ul><li><code>str1</code> ——指向存储复制内容的目标数组。</li><li><code>str2</code> ——指向复制目标数组。</li><li><code>n</code>——要被复制的字节数。</li></ul><h2 id="返回值"><a href="#返回值" class="headerlink" title="返回值"></a>返回值</h2><p>返回一个指向存储区<code>str1</code>的指针。</p><h2 id="实例"><a href="#实例" class="headerlink" title="实例"></a>实例</h2><figure class="highlight c"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;stdio.h&gt;</span></span></span><br><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;string.h&gt;</span></span></span><br><span class="line"> </span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span> <span class="params">()</span></span></span><br><span class="line"><span class="function"></span>&#123;</span><br><span class="line"><span class="keyword">char</span> s[<span class="number">50</span>] = <span class="string">"the quick brown fox jumps over the lazy dog"</span>;</span><br><span class="line"><span class="keyword">char</span> t[<span class="number">50</span>];</span><br><span class="line"> </span><br><span class="line"><span class="built_in">memcpy</span>(t, s, <span class="keyword">sizeof</span>(s));</span><br><span class="line"><span class="built_in">printf</span>(<span class="string">"%s\n"</span>, t);</span><br><span class="line">   </span><br><span class="line"><span class="keyword">return</span>(<span class="number">0</span>);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure><p>输出结果：</p><figure class="highlight plain"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">the quick brown fox jumps over the lazy dog</span><br></pre></td></tr></table></figure><a id="more"></a><hr><font color="#407600">【更多C语言系列】</font><ul><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-基本数据类型取值范围/">C &amp; C++基本数据类型取值范围</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/C和C-中memset用法/">C &amp; C++ memset</a></li><li><a href="https://g-ss-hacker.github.io/G-SS-Hacker.github.io/野指针的产生及其危害/">野指针的产生及其危害</a></li></ul>]]></content>
    
    <summary type="html">
    
      &lt;p&gt;&lt;img src=&quot;https://i.loli.net/2020/02/22/5J6bmYjvsQe37nf.jpg&quot; alt&gt;&lt;/p&gt;
&lt;h1 id=&quot;C和C-中memcpy-函数&quot;&gt;&lt;a href=&quot;#C和C-中memcpy-函数&quot; class=&quot;headerlink&quot; title=&quot;C和C++中memcpy()函数&quot;&gt;&lt;/a&gt;C和C++中memcpy()函数&lt;/h1&gt;&lt;p&gt;&lt;/p&gt;&lt;p&gt;&lt;font color=&quot;grey&quot;&gt; &lt;em&gt;Guderian&lt;/em&gt;出品 &lt;/font&gt;&lt;/p&gt;&lt;p&gt;&lt;/p&gt;
&lt;h2 id=&quot;头文件&quot;&gt;&lt;a href=&quot;#头文件&quot; class=&quot;headerlink&quot; title=&quot;头文件&quot;&gt;&lt;/a&gt;头文件&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;C：      &lt;code&gt;&amp;lt;string.h&amp;gt;&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;C++：  &lt;code&gt;&amp;lt;cstring&amp;gt;&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;声明&quot;&gt;&lt;a href=&quot;#声明&quot; class=&quot;headerlink&quot; title=&quot;声明&quot;&gt;&lt;/a&gt;声明&lt;/h2&gt;&lt;p&gt;&lt;code&gt;void *memcpy(void *str1, const void *str2, size_t n)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;此处&lt;code&gt;size_t&lt;/code&gt;变量类型等价于&lt;code&gt;long unsigned int&lt;/code&gt;即无符号长整型，在32位机器上为32位，在64位机器为中64位。&lt;/p&gt;
&lt;p&gt;注：32位机器指CPU通用寄存器的数据宽度为32位，也就是说CPU一次可以运行32bit数据&lt;/p&gt;
&lt;h2 id=&quot;描述&quot;&gt;&lt;a href=&quot;#描述&quot; class=&quot;headerlink&quot; title=&quot;描述&quot;&gt;&lt;/a&gt;描述&lt;/h2&gt;&lt;p&gt;从内存 &lt;strong&gt;str2&lt;/strong&gt; 复制 &lt;strong&gt;n&lt;/strong&gt; 个字符到内存 &lt;strong&gt;str1&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&quot;参数&quot;&gt;&lt;a href=&quot;#参数&quot; class=&quot;headerlink&quot; title=&quot;参数&quot;&gt;&lt;/a&gt;参数&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;code&gt;str1&lt;/code&gt; ——指向存储复制内容的目标数组。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;str2&lt;/code&gt; ——指向复制目标数组。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;n&lt;/code&gt;——要被复制的字节数。&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&quot;返回值&quot;&gt;&lt;a href=&quot;#返回值&quot; class=&quot;headerlink&quot; title=&quot;返回值&quot;&gt;&lt;/a&gt;返回值&lt;/h2&gt;&lt;p&gt;返回一个指向存储区&lt;code&gt;str1&lt;/code&gt;的指针。&lt;/p&gt;
&lt;h2 id=&quot;实例&quot;&gt;&lt;a href=&quot;#实例&quot; class=&quot;headerlink&quot; title=&quot;实例&quot;&gt;&lt;/a&gt;实例&lt;/h2&gt;&lt;figure class=&quot;highlight c&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;2&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;3&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;4&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;5&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;6&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;7&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;8&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;9&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;10&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;11&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;12&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;13&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;stdio.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;meta&quot;&gt;#&lt;span class=&quot;meta-keyword&quot;&gt;include&lt;/span&gt; &lt;span class=&quot;meta-string&quot;&gt;&amp;lt;string.h&amp;gt;&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt; &lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;span class=&quot;keyword&quot;&gt;int&lt;/span&gt; &lt;span class=&quot;title&quot;&gt;main&lt;/span&gt; &lt;span class=&quot;params&quot;&gt;()&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&lt;span class=&quot;function&quot;&gt;&lt;/span&gt;&amp;#123;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; s[&lt;span class=&quot;number&quot;&gt;50&lt;/span&gt;] = &lt;span class=&quot;string&quot;&gt;&quot;the quick brown fox jumps over the lazy dog&quot;&lt;/span&gt;;&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;char&lt;/span&gt; t[&lt;span class=&quot;number&quot;&gt;50&lt;/span&gt;];&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt; &lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;memcpy&lt;/span&gt;(t, s, &lt;span class=&quot;keyword&quot;&gt;sizeof&lt;/span&gt;(s));&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;built_in&quot;&gt;printf&lt;/span&gt;(&lt;span class=&quot;string&quot;&gt;&quot;%s\n&quot;&lt;/span&gt;, t);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;   &lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;	&lt;span class=&quot;keyword&quot;&gt;return&lt;/span&gt;(&lt;span class=&quot;number&quot;&gt;0&lt;/span&gt;);&lt;/span&gt;&lt;br&gt;&lt;span class=&quot;line&quot;&gt;&amp;#125;&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
&lt;p&gt;输出结果：&lt;/p&gt;
&lt;figure class=&quot;highlight plain&quot;&gt;&lt;table&gt;&lt;tr&gt;&lt;td class=&quot;gutter&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;1&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;td class=&quot;code&quot;&gt;&lt;pre&gt;&lt;span class=&quot;line&quot;&gt;the quick brown fox jumps over the lazy dog&lt;/span&gt;&lt;br&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;&lt;/figure&gt;
    
    </summary>
    
    
      <category term="总结" scheme="https://G-SS-Hacker.github.io/categories/%E6%80%BB%E7%BB%93/"/>
    
    
      <category term="C-plus-plus" scheme="https://G-SS-Hacker.github.io/tags/C-plus-plus/"/>
    
      <category term="C" scheme="https://G-SS-Hacker.github.io/tags/C/"/>
    
  </entry>
  
</feed>