科技https://blog.1wind.cn/https://blog.1wind.cn/posts/2025%E5%B9%B4%E7%BB%88%E6%80%BB%E7%BB%93/https://blog.1wind.cn/posts/2025%E5%B9%B4%E7%BB%88%E6%80%BB%E7%BB%93/2025年终总结Wed, 31 Dec 2025 00:00:00 GMT<h1 id="马拉松">马拉松</h1> <p>2025年1月1日，我参加了上海的“蒸蒸日上迎新跑”，20.6公里，没想到自己怎么坚持的，总之就是老年程序猿坚持跑下来了哈哈</p> <img src="https://b.1wind.cn/2025/12/c92fe42cae0c164ddda2e2d56e31c0c5.jpg" alt="IMG_20250101_085300" style="zoom: 50%;"> <img src="https://b.1wind.cn/2025/12/667a72589f092e932e3afdc5b0629d76.jpg" alt="IMG_20250101_114940" style="zoom: 50%;"> <p>也是新的一年开始了</p> <h1 id="实习">实习</h1> <p>2025年1月7日，我离开了南京，这个美丽的地方，我的出租房，与它混战了6个月的实习</p> <p><img src="https://b.1wind.cn/2025/12/54eb78fdc2f74c38b6fc574ace25047a.jpg" alt="IMG_20250107_144458"></p> <p>准备回家备考本科了</p> <h1 id="竞赛">竞赛</h1> <p>2025年1月9日，安徽合肥，竞赛！</p> <img src="https://b.1wind.cn/2025/12/c62677f16f583f89cf92d1b61fdb9c7f.jpg" alt="IMG_20250109_180836" style="zoom: 50%;"> <p>这一次竞赛见到了阔别已久的好友，聊了很多，也释怀了很多事</p> <p>总之觉得人生就是反复无常吧</p> <h1 id="生活">生活</h1> <p>1月23日，回老家杀猪！</p> <p>我本来还想尝试一下抬猪来着，结果大人不让，看来还是身体太老年了，得锻炼一下了哈哈哈</p> <p>回家后的日子里也是平平无奇的，不过生活多了一些新的期待吧，一只黑色的汪汪降临在我的身边了</p> <p>每天这只笨汪汪都会狗叫，还会到处尿尿，哎，难受</p> <p><img src="https://b.1wind.cn/2025/12/7552aad73a58704c0fde1d800e55ed99.jpg" alt="IMG_20250122_153112"></p> <p>不过给心里带来了一些慰藉，狗狗确实是陪伴人类的友好生物</p> <p>哇咔咔，1月29日，庙会嘿嘿，去看了很多有意思的节目！</p> <p><img src="https://b.1wind.cn/2025/12/bc790e53f5902d57a3eb3fcd71e2f1a4.jpg" alt="IMG_20250129_174338"></p> <p>紧接着几个月，没啥意思，就是学习，读书</p> <p>学啊学，学啊学</p> <p>自学对于自制力差的来说，真的很难受，有时候甚至是边玩手机边看网课</p> <p>还好顶住了，克制ing…</p> <p>考完后的几天，没啥事干，本来打算去找个实习赚点钱，后面还是考虑了一下</p> <p>5月1日，我去了驾校，开始学习科一</p> <p><img src="https://b.1wind.cn/2025/12/aad3c0278abe23b87ea8b228341b7676.jpg" alt="Screenshot_2025-05-14-10-22-47-638_com.jxedt"></p> <p>期间坏狗天天在家搞破坏，喵的</p> <p>科一学了十几天，一次过！</p> <p>接着考试出成绩啦，终于能去新的学校了</p> <p>有遗憾有开心吧，可惜没能勇敢去尝试一下更好的学校</p> <p>我希望在新的一年，我能考上<strong>研究生</strong>。</p> <p>接着也要到6月了</p> <p>毕业季，要回学校把一系列事情都处理掉了，学校反馈了毕业生超多福利</p> <p>挺开心的，这个时间段，科二也拿下了，二战！</p> <p>感觉自己属于开车稳定系列的，大心脏！</p> <p>科三科三！</p> <p>接下来一个月，一直在考科三了</p> <p>依然是二战拿捏了，嘻嘻</p> <p>不知道为啥，一战永远感受不到自己的失败，二战反而会更认真</p> <p>考完的日子里，一直在学习考研的课程和遛狗</p> <p>还看到了超帅的小米su7 ultra！</p> <p>等待开学ing…</p> <p>开学开学了2333</p> <p>当了班长，想体验一下领导者，学习一些新东西吧，努力！</p> <p>9-12月，学习吃饭学习吃饭，聚餐吃饭聚餐</p> <p>emmm，到了学校的生活反而无常了</p> <p>10月考了软考，这次比上次有进步了，遗憾的是最后一道算法题“八皇后”被卡死</p> <p>最后理论成绩通过了，但是实操成绩差了6分，就差在了“八皇后”上</p> <p>更努力吧，加油</p> <p>做项目，沉淀，生活稳稳的</p> <p>希望可以再多学学说话，<strong>曾经的我对说话嗤之以鼻，现在的我逐帧学习</strong></p> <p>我想，一辈子做技术，迟早被淘汰，只有掌握往上走的方法，才能在计算机，甚至其他的行业坐下来</p> <p>新的一年，加油！</p> <p><img src="https://b.1wind.cn/2025/12/eb52735972060262a7a0c84465d17731.jpg" alt="IMG_20251231_174128"></p>https://blog.1wind.cn/posts/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/https://blog.1wind.cn/posts/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/操作系统Mon, 21 Jul 2025 00:00:00 GMT<h1 id="概念">概念</h1> <p>操作系统(Operating System，OS)是指控制和管理整个计算机系统的硬件和软件资源，并合理的组织调度计算机的工作和资源的分配；以提供给用户和其他软件方便的接口和环境；它是计算机系统中最基本的系统软件</p> <ol> <li>操作系统是系统资源的管理者</li> <li>向上层提供方便易用的服务</li> <li>是最接近硬件的一层软件</li> </ol> <p>执行一个程序前需要将该程序放到内存中，才能被CPU处理</p> <img src="https://b.1wind.cn/2025/08/af76489d201ffaf9a24533f5904b578b.png" alt="image-20250806215335149" style="zoom:50%;"> <img src="https://b.1wind.cn/2025/08/e8776ac541fad664900cfa100f35d3d2.png" alt="image-20250806215527318" style="zoom:50%;"> <img src="https://b.1wind.cn/2025/08/6505940bf873d689e7f6352c48f2e044.png" alt="image-20250806215854046" style="zoom: 50%;"> <p>没有任何软件支持的计算机称为裸机。在裸机上安装的操作系统，可以提供资源管理功能和方便用户的服务功能，将裸机改造成功能更强、使用更方便的机器</p> <p>通常把覆盖了软件的机器称为扩充机器，又称为虚拟机</p> <h1 id="特征">特征</h1> <h2 id="并发共享">并发&#x26;共享</h2> <p>并发：指两个或多个事件在同一时间间隔内发生。这些事件宏观上是同时发生的。但微观上是交替发生的</p> <p>常考易混概念---并行：指两个或多个事件在同一时刻同时发生</p> <p>并发其实可以这么理解，某一个时间段，你在做一件事情，炒菜，但炒菜这里包含多个工作，它是交替执行的，比如说8点切菜，9点烧菜，从宏观上看，它只在做一件事，炒菜，但从微观上看，这些动作是交替的</p> <p>而并行就是说，8点炒菜并烧菜，这两个工作一起干，而不是分开干</p> <p>操作系统的并发性指计算机系统中“同时”运行多个程序，这些程序宏观上看是同时运行着的，而微观上看是交替运行的</p> <p>操作系统就是伴随着“多道程序技术”而出现的。因此，操作系统和程序并发是一起诞生的</p> <p>注意**(重要考点)**：</p> <p>单核CPU同一时刻只能执行一个程序，各个程序只能并发执行</p> <p>多核CPU同一时刻可以同时执行多个程序，多个程序可以并行执行</p> <p>共享即资源共享，是指系统中的资源可供内存中多个并发执行的进程共同使用</p> <ul> <li>互斥共享方式：系统中的某些资源，虽然可以提供给多个进程使用，但一个时间段只允许一个进程访问该资源</li> <li>同时共享方式：系统中的某些资源，允许一个时间段内由多个进程“同时”对它们进行访问</li> </ul> <p>并发性指计算机系统中同时存在多个运行着的程序</p> <p>共享性是指系统中的资源可供内存中多个并发执行的进程共同使用</p> <p><strong>并发性和共享性互为共存条件</strong></p> <h2 id="虚拟">虚拟</h2> <p>虚拟是指把一个物理上的实体变为若干个逻辑上的对应物。物理实体(前者)是实际存在的，而逻辑上对应物(后者)是用户感受到的</p> <p>可以这么理解，硬盘在电脑中是真实存在的，而硬盘分盘是一种逻辑上的分盘操作，并没有真实的把硬盘分割成几个小硬盘</p> <h2 id="异步">异步</h2> <p>异步是指，在多道程序环境下，允许多个程序并发执行，但由于资源有限，进程的执行不是一贯到底的，而是走走停停，以不可预知的速度向前推进，这就是进程的异步性</p> <p>系统资源可能因某种情况而阻塞导致程序并不是同步的运行过去，而是异步的不按规定去运行</p> <p>如果失去了并发性，即系统只能串行地运行各个程序，那么每个程序的执行会一贯到底。只有系统拥有并发性，才有可能导致异步性</p> <h1 id="发展分类">发展&#x26;分类</h1> <h2 id="手工操作阶段">手工操作阶段</h2> <p>程序猿将程序[二进制]写到纸带上，然后将纸带装到纸带机上，接着计算机需要将纸带机的数据读取，并给出纸带结果，最终程序猿需要取走纸带</p> <p>主要缺点：用户独占全机、人机速度矛盾导致资源利用率极低</p> <h2 id="批处理阶段">批处理阶段</h2> <h3 id="单道批处理系统">单道批处理系统</h3> <p>引入脱机输入/输出技术(用外围机+磁带完成)，并由监督程序负责控制作业的输入、输出【操作系统的雏形】</p> <p>主要优点：缓解了一定程度的人机速度矛盾，资源利用率有所提升</p> <p>主要缺点：内存中仅能有一道程序运行，只有该程序运行结束之后才能调入下一道程序。CPU有大量的时间是在空闲等待I/0完成。资源利用率依然很低</p> <h3 id="多道批处理系统">多道批处理系统</h3> <p>操作系统正式诞生，用于支持多道程序并发运行，每次往内存中读入多道程序</p> <p>主要优点：多道程序并发执行，共享计算机资源。资源利用率大幅提升，CPU和其他资源更能保持“忙碌”状态，系统吞吐量增大。</p> <p>主要缺点：用户响应时间长，没有人机交互功能（用户提交自己的作业之后就只能等待计算机处理完成，中间不能控制自己的作业执行。）</p> <p>eg：无法调试程序/无法在程序运行过程中输入一些参数</p> <h2 id="分时操作系统">分时操作系统</h2> <p>分时操作系统：计算机以时间片为单位轮流为各个用户/作业服务，各个用户可通过终端与计算机进行交互</p> <p>主要优点：用户请求可以被即时响应，解决了人机交互问题。允许多个用户同时使用一台计算机，并且用户对计算机的操作相互独立，感受不到别人的存在。</p> <p>主要缺点：不能优先处理一些紧急任务。操作系统对各个用户/作业都是完全公平的，循环地为每个用户/作业服务一个时间片，不区分任务的紧急性</p> <h2 id="实时操作系统">实时操作系统</h2> <p>主要优点：能够优先响应一些紧急任务，某些紧急任务不需要时间片排队</p> <p>在实时操作系统的控制下，计算机系统接收到外部新号后及时进行处理，并且要在严格的时限内处理完事件。实时操作系统的主要特点是及时性和可靠性</p> <p>实时操作系统分为硬实时系统和软实时系统</p> <ul> <li>硬实时系统：必须在绝对严格的规定时间内完成处理</li> <li>软实时系统：能接受偶尔违反时间规定</li> </ul> <h2 id="其他操作系统">其他操作系统</h2> <p>网络操作系统：是伴随着计算机网络的发展而诞生的，能把网络中各个计算机有机地结合起来，实现数据传送等功能，实现网络中各种资源的共享(如文件共享)和各台计算机之间的通信。（如：Windows NT就是一种典型的网络操作系统，网站服务器就可以使用）</p> <p>分布式操作系统：主要特点是分布性和并行性。系统中的各台计算机地位相同，任何工作都可以分布在这些计算机上，由它们并行、协同完成这个任务</p> <p>个人计算机操作系统：如Windows XP、MacOS，方便个人使用</p> <h1 id="运行机制">运行机制</h1> <p>我们普通程序员写的程序就是“应用程序”</p> <p>微软、苹果有一帮人负责实现操作系统，他们写的是“内核程序”</p> <p>由很多内核程序组成了“操作系统内核”，简称“内核(Kernel)”</p> <p>内核是操作系统最重要最核心的部分，也是最接近硬件的部分</p> <p>甚至可以说，一个操作系统只要有内核就够了(eg：Docker->仅需Linux内核)</p> <p>操作系统的功能未必都在内核中，如图形化用户界面GUI</p> <ul> <li>应用程序只能使用“非特权指令”，如：加法、减法指令等</li> <li>操作系统内核作为“管理者”，有时会让CPU执行一些“特权指令”，如：内存清零指令。</li> <li>这些指令影响重大，只允许管理者---即操作系统内核来使用</li> </ul> <p>在<strong>CPU设计和生产的时候就划分了特权指令和非特权指令</strong>，因此CPU执行一条指令前就能判断出其类型</p> <p>CPU有两种状态，“内核态”和“用户态”</p> <ul> <li>处于内核态时，说明此时正在运行的是内核程序，此时可以执行特权指令</li> <li>处于用户态时，说明此时正在运行的是应用程序，此时只能执行非特权指令</li> <li>拓展：CPU中有一个寄存器叫程序状态字寄存器(PSW)，其中有个二进制位，1表示“内核态”，0表示“用户态”</li> <li>别名：内核态=核心态=管态；用户态=目态</li> </ul> <p>内核态->用户态：执行一条特权指令---修改PSW的标志位为“用户态”，这个动作意味着操作系统将主动让出CPU使用权</p> <p>用户态->内核态：由“中断”引发，硬件自动完成转变过程，触发中断信号意味着操作系统将强行夺回CPU的使用权</p> <p>除了非法使用特权指令之外，还有很多事件会触发中断信号，<strong>一个共性是，但凡需要操作系统介入的地方，都会触发中断信号</strong></p> <p>操作系统运行机制</p> <ol> <li>刚开机时，CPU为<strong>内核态</strong>，操作系统内核程序先上CPU运行</li> <li>开机完成后，用户可以启动某个应用程序</li> <li>操作系统内核程序在合适的时候主动让出CPU，让该应用程序上CPU运行</li> <li>应用程序运行在用户态</li> <li>此时，黑客在应用程序中植入了一条特权指令，企图破坏系统</li> <li>CPU发现接下来要执行的这条指令是特权指令，但是自己又处于用户态</li> <li>这个非法事件会引发一个<strong>中断信号</strong></li> <li>中断使操作系统再次夺回CPU的控制权</li> <li>操作系统会对引发中断的事件进行处理，处理完了再把CPU使用权交给别的应用程序</li> </ol> <p>操作系统内核在让出CPU之前，<strong>会用一条特权指令把PSW的标志位设置为用户态</strong></p> <p><strong>CPU检测到中断信号后，会立即变为“核心态”</strong>，并停止运行当前的应用，转而运行处理中断信号的内核程序</p> <h1 id="中断异常">中断&#x26;异常</h1> <h2 id="中断的作用">中断的作用</h2> <p>中断会使CPU由用户态变为内核态，使操作系统重新夺回对CPU的控制权</p> <p>CPU上会运行两种程序，一种是操作系统内核程序(是整个系统的管理者)，一种是应用程序</p> <p>在合适的情况下，操作系统内核会把CPU的使用权主动让给应用程序</p> <p>“中断”是让操作系统内核夺回CPU使用权的唯一途径</p> <p>如果没有中断机制，那么一旦应用程序上CPU运行，CPU就会一直运行在这个应用程序</p> <h2 id="中断的类型">中断的类型</h2> <p>内中断：与当前执行的指令有关，中断信号来源于CPU内部</p> <p>eg：</p> <ol> <li>试图在用户态下执行特权指令</li> <li>执行除法指令时发现除数为0(若当前执行的指令是非法的，则会引发一个中断信号)</li> <li>有时候应用程序想请求操作系统内核的服务，此时会执行一条特殊的指令---陷入指令，该指令会引发一个内部中断的信号(执行陷入指令，意味着应用程序主动地将CPU控制器还给操作系统内核。系统调用就是通过陷入指令完成的)</li> </ol> <p>外中断：与当前执行的指令无关，中断信号来源于CPU外部</p> <p>eg：</p> <ol> <li>时钟中断---由时钟部件发来的中断信号(时钟部件每隔一个时间片(如50ms)会给CPU发送一个时钟中断信号)</li> <li>I/0中断---由输入/输出设备发来的中断信号(当输入输出任务完成时，向CPU发送中断信号)</li> </ol> <h2 id="中断的分类">中断的分类</h2> <p>内中断也称异常、例外</p> <p>内中断由陷阱(陷入)、故障、终止组成</p> <ul> <li>陷阱(陷入)：由陷入指令引发，是应用程序故意引发的</li> <li>故障：由错误条件引起的，可能被内核程序修复。内核程序修复故障后会把CPU使用权还给应用程序，让它继续执行下去</li> <li>终止：由致命错误引起，内核程序无法修复该错误，因此一般不再将CPU使用权还给引发终止的应用程序，而是直接终止该应用程序。如：整数除0、非法使用特权指令</li> </ul> <p>外中断也称中断</p> <p>外中断包括但不限于时钟中断、I/0中断请求</p> <h2 id="中断的基本原理">中断的基本原理</h2> <p>不同的中断信号，需要不同的中断处理程序来处理。当CPU检测到中断信号后，会根据中断信号的类型去查询“中断向量表”，以此来找到相应的中断处理程序在内存中的存放位置</p> <p>如图所示</p> <img src="https://b.1wind.cn/2025/08/3f92879160c33a50446cc388af9bb733.png" alt="image-20250810100536411" style="zoom:50%;"> <h1 id="系统调用">系统调用</h1> <p>操作系统作为用户和计算机硬件之间的接口，需要向上提供一些简单易用的服务。主要包括命令接口和程序接口。其中，程序接口由一组<strong>系统调用</strong>组成</p> <p>系统调用是操作系统提供给应用程序(程序员/编程人员)使用的接口，可以理解为一种可供应用程序调用的特殊函数，<strong>应用程序可以通过系统调用来</strong>请求获得操作系统内核的服务</p> <table><thead><tr><th>普通应用程序</th><th>可直接进行系统调用，也可以使用库函数，有的库函数涉及系统调用，有的不涉及</th></tr></thead><tbody><tr><td>编程语言</td><td>向上提供库函数。有时会将系统调用封装成库函数，以隐藏系统调用的一些细节，使程序员编程更加方便</td></tr><tr><td>操作系统</td><td>向上提供系统调用，使得上层程序能请求内核的服务</td></tr><tr><td>裸机</td><td></td></tr></tbody></table> <img src="https://b.1wind.cn/2025/08/d0873231aa910692fe22dc46fcdab0a6.png" alt="image-20250810101639955" style="zoom:50%;"> <p>应用程序通过系统调用请求操作系统的服务。而系统中的各种共享资源都由操作系统内核统一掌管，因此凡是与共享资源有关的操作(如存储分配、I/0操作、文件管理等)，都必须通过系统调用的方式向操作系统内核提出服务请求，由操作系统内核代为完成。这样可以保证系统的稳定性和安全性，防止用户进行非法操作</p> <p>系统调用按功能分类:</p> <ol> <li>设备管理:完成设备的 请求/释放/启动 等功能</li> <li>文件管理：完成文件的 读/写/创建/删除 等功能</li> <li>进程控制：完成进程的 创建/撤销/阻塞/唤醒 等功能</li> <li>进程通信：完成进程之间的 消息传递/信号传递 等功能</li> <li>内存管理：完成内存的 分配/回收 等功能</li> </ol> <h1 id="体系结构">体系结构</h1> <h2 id="概念-1">概念</h2> <p>计算机系统层次结构如图所示</p> <p><img src="https://b.1wind.cn/2025/08/694dc1117cf4620eac5602d5b015dd4a.png" alt="image-20250810135929538"></p> <p><strong>内核</strong>是操作系统最基本、最核心的部分</p> <p>实现操作系统内核功能的那些程序就是<strong>内核程序</strong></p> <ul> <li>内核 <ul> <li>时钟管理：实现计时功能</li> <li>中断处理：负责实现中断机制</li> <li>原语： <ul> <li>是一种特殊的程序</li> <li>处于操作系统最底层，是最接近硬件的部分</li> <li>这种程序的运行具有原子性---其运行只能一气呵成，不可中断</li> <li>运行时间较短，调用频繁</li> </ul> </li> <li>对系统资源进行管理的功能 <ul> <li>进程管理</li> <li>存储器管理</li> <li>设备管理</li> </ul> </li> </ul> </li> </ul> <p>内核也分为大内核以及微内核</p> <ul> <li>大内核 <ul> <li>将操作系统的主要功能模块都作为系统内核，运行在核心态</li> <li>优点：高性能</li> <li>缺点：内核代码庞大，结构混乱，难以维护</li> </ul> </li> <li>微内核 <ul> <li>只把最基本的功能保留在内核</li> <li>优点：内核功能少，结构清晰，方便维护</li> <li>缺点：需要频繁地在核心态和用户态之间切换，性能低</li> </ul> </li> </ul> <p>典型的大内核/宏内核/单内核 操作系统：Linux、UNIX</p> <p>典型的微内核 操作系统：Windows NT</p> <img src="https://b.1wind.cn/2025/08/6d349778908a35d0a5550b54a20bd68c.png" alt="image-20250810142118058" style="zoom:50%;"> <p>如图所示</p> <p>大内核中将系统的主要功能存储在内核态中,应用程序存储在用户态中</p> <p>微内核只保留了最基本的功能在内核态中,其余的都在用户态中</p> <h2 id="总结图">总结图</h2> <p><img src="https://b.1wind.cn/2025/08/082d6c316c7d11acdd95578a18fdd179.png" alt="image-20250810142422270"></p> <h1 id="引导">引导</h1> <p>操作系统引导(boot)---开机的时候，怎么让操作系统运行起来？</p> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/08/d464664196dfdab70eca2aaa1481ff1c.png" alt="image-20250810145237909"></p> <p>操作系统引导：</p> <ol> <li>CPU从一个特定主存地址开始，取指令，执行ROM中的引导程序(先进行硬件自检,再开机)</li> <li>将磁盘的第一块---主引导记录读入内存,执行磁盘引导程序,扫描分区表</li> <li>从活动分区(又称主分区，即安装了操作系统的分区)读入分区引导记录，执行其中的程序</li> <li>从根目录下找到完整的操作系统初始化程序(即启动管理器)并执行，完成“开机”的一系列动作</li> </ol> <h1 id="虚拟机">虚拟机</h1> <p>虚拟机，使用虚拟化技术，将一台物理机器虚拟化为多台虚拟机器(Virtual Machine,VM)，每个虚拟机器都可以独立运行一个操作系统</p> <p>同义术语：虚拟机管理程序/虚拟机监控程序/Virtual Machine Monitor/Hypervisor</p> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/08/0c263558053b3e8577f88c54359d1075.png" alt="image-20250810154031211"></p> <p>对比如下</p> <p>第一类简单来说就是多系统了,第二类是运行在某种虚拟程序上,比如vmware</p> <p><img src="https://b.1wind.cn/2025/08/e6ccebd494c0941f394c96f911a16ebc.png" alt="image-20250810155402104"></p> <h1 id="进程">进程</h1> <h2 id="概念-2">概念</h2> <p>程序：是静态的，就是存放在磁盘里的可执行文件，一系列的指令集合</p> <p>进程：(Process)：是动态的，是程序的一次执行过程</p> <h2 id="组成">组成</h2> <p>当进程被创建时，操作系统会为该进程分配一个<strong>唯一的、不重复</strong>的“身份证号”---PID（Process ID,进程ID）</p> <p>操作系统要记录PID、进程所属用户ID(基本的进程描述信息，可以让操作系统区分各个进程)</p> <p>（如：分配了多少内存、正在使用哪些I/O设备、正在使用哪些文件[可用于实现操作系统对进程的控制、调度]）</p> <p>还要记录进程的运行情况（如：CPU使用时间、磁盘使用情况、网络流量使用情况等[可用于实现操作系统对进程的控制、调度]）</p> <p>这些信息都被保存在一个数据结构PCB（Process Control Block）中，即<strong>进程控制块</strong></p> <p>操作系统需要对各个并发运行的进程进行管理，但凡管理时需要的信息，都会被放在PCB中</p> <p>PCB是进程存在的唯一标志，当进程被创建时，操作系统为其创建PCB，当进程结束时，会收回其PCB</p> <p>一个**进程实体(进程映像)<strong>由</strong>PCB(进程控制块)、程序段(包含程序指令)、数据段(包含运行过程中产生的各种数据)**组成</p> <p><strong>进程是动态的</strong>，进程实体(进程映像)是静态的</p> <p>进程实体反应了进程在某一时刻的状态(如:x++后，x=2)</p> <h2 id="特征-1">特征</h2> <ul> <li>动态性：进程是程序的一次执行过程，是动态地产生、变化和消亡的</li> <li>并发性：内存中有多个进程实体，各进程可并发执行</li> <li>独立性：进程是能独立运行、独立获得资源、独立接受调度的基本单位</li> <li>异步性：各进程是按各自独立的、不可预知的速度向前推进，操作系统要提供“进程同步机制”来解决异步问题</li> <li>结构性：每个进程都会配置一个PCB。结构上看，进程由程序段、数据段、PCB组成</li> </ul> <h2 id="状态转换">状态&#x26;转换</h2> <ul> <li> <p>进程正在被创建时，它的状态是“<strong>创建态</strong>”，在这个阶段操作系统会为进程分配资源、初始化PCB</p> </li> <li> <p>当进程创建完成后，便进入“就绪态”，处于就绪态的进程已经具备运行条件，但由于没有空闲的CPU，就暂时不能运行</p> </li> <li> <p>如果一个进程此时在CPU上运行，那么这个进程处于“<strong>运行态</strong>”</p> </li> <li> <p>CPU会执行该进程对应的程序(执行指令序列)</p> </li> <li> <p>在进程运行的过程中，可能会<strong>请求等待某个事件的发生</strong>(如等待某种系统资源的分配，或者等待其他进程的响应)</p> </li> <li> <p>在这个事件发生之前，进程无法继续往下执行，此时操作系统会让这个进程下CPU，并让它进入<strong>阻塞态</strong></p> </li> <li> <p>当CPU空闲时，又会选择另一个就绪态进程上CPU运行</p> </li> <li> <p>一个进程可以执行exit系统调用，请求操作系统终止该进程。</p> </li> <li> <p>此时该进程会进入“<strong>终止态</strong>”，操作系统会让该进程下CPU，并回收内存空间等资源，最后还要回收该进程的PCB</p> </li> </ul> <p><img src="https://b.1wind.cn/2025/08/156dbf5cf75a501b570a55875aab3b4a.png" alt="image-20250811220223814"></p> <p>状态转换图如上</p> <ul> <li>运行态:占有CPU,并在CPU上运行(单CPU情况下，同一时刻只会有一个进程处于运行态，多核CPU情况下，可能有多个进程处于运行态)</li> <li>就绪态：已经具备运行条件，但由于没有空闲CPU，而暂时不能运行</li> <li>阻塞态(等待态)：因等待某一事件而暂时不能运行</li> <li>创建态(新建态)：进程正在被创建，操作系统为进程分配资源，初始化PCB</li> <li>终止态(结束态)：进程正在从系统中撤销，操作系统会回收进程拥有的资源、撤销PCB</li> </ul> <h2 id="控制">控制</h2> <h3 id="概念-3">概念</h3> <p>进程控制的主要功能是对系统中的所有进程实施有效的管理，它具有创建新进程、撤销已有进程、实现进程状态转换等功能</p> <p>简化理解：反正进程控制就是要实现进程状态转换</p> <p>原语的执行具有原子性，即执行过程只能一气呵成，期间不允许被中断</p> <p>可以用<code>关中断指令</code>和<code>开中断指令</code>这两个特权指令实现原子性</p> <p>CPU执行了<code>关中断指令</code>之后，就不再例行检查中断信号，直到执行<code>开中断指令</code>之后才会恢复检查</p> <h3 id="相关的原语">相关的原语</h3> <img src="https://b.1wind.cn/2025/08/0a1f79368249cad23e4a81abb687dd09.png" alt="image-20250812102737653" style="zoom:50%;"> <img src="https://b.1wind.cn/2025/08/1c56cb1d6423143c675da6e4bc076e30.png" alt="image-20250812102846503" style="zoom:50%;"> <img src="https://b.1wind.cn/2025/08/f5e433b3d1d43ef49b3fb226e5731c2e.png" alt="image-20250812103518269" style="zoom:50%;"> <img src="https://b.1wind.cn/2025/08/4b74a515677c96f523211fece1fa9a93.png" alt="image-20250812103650620" style="zoom:50%;"> <h2 id="通信ipc">通信(IPC)</h2> <h3 id="概念-4">概念</h3> <p>进程间通信(Inter-Process Communication,IPC)是指两个进程之间产生数据交互</p> <p>进程是分配系统资源的单位(包括内存地址空间)，因此各进程拥有的内存地址空间相互独立</p> <h3 id="共享存储">共享存储</h3> <p>基于数据结构的共享：比如共享空间里只能放一个长度为10的数组。这种共享方式速度慢、限制多，是一种低级的通信方式</p> <p>基于存储区的共享：操作系统在内存中划出一块共享存储区，数据的形式、存放位置都由通信进程控制，而不是操作系统。这种共享方式速度很快，是一种高级通信方式</p> <h3 id="消息传递">消息传递</h3> <p>进程间的数据交换以格式化的消息(Message)为单位。进程通过操作系统提供的“发送消息/接收消息”两个原语进行数据交换</p> <p>消息发送需要消息头和消息体</p> <p>其中消息头包括：</p> <ul> <li>发送进程ID</li> <li>接收进程ID</li> <li>消息长度等格式化的信息</li> </ul> <p>而消息传递有两种方式</p> <ul> <li>直接通信方式</li> <li>间接通信方式</li> </ul> <p>通过“信箱”间接的通信，因此又被称为信箱通信方式</p> <p><img src="https://b.1wind.cn/2025/08/2a6bfe1545a06b2c992c3c00683cf037.png" alt="image-20250812153455651"></p> <p>直接通信方式如上图所示</p> <img src="https://b.1wind.cn/2025/08/21808594912c66c380643bbd3a002d7a.png" alt="image-20250812154030993" style="zoom:50%;"> <p>间接通信通信方式如上图所示</p> <h3 id="管道通信">管道通信</h3> <p><img src="https://b.1wind.cn/2025/08/8026964f523089805489e567c96887a4.png" alt="image-20250812155653070"></p> <p>管道是一个特殊的共享文件，又名pipe文件。其实就是在内存中开辟一个大小固定的内存缓冲区</p> <ul> <li> <p>管道只能采用半双工通信，某一时间段内只能实现单向的传输。如果要实现双向同时通信，则需要设置两个管道</p> </li> <li> <p>各进程要互斥地访问管道(由操作系统实现)</p> </li> <li> <p>当管道写满时，写进程将阻塞，直到读进程将管道中的数据取走，即可唤醒写进程</p> </li> <li> <p>当管道读空时，读进程将阻塞，直到写进程往管道内写入数据，即可唤醒读进程</p> </li> <li> <p>管道中的数据一旦被读出，就彻底消失。因此，当多个进程读同一个管道时，可能会错乱。对此，通常有两种解决方案</p> <ul> <li>一个管道允许多个写进程，一个读进程(考试选这个)</li> <li>允许有多个写进程，多个读进程，但系统会让各个读进程轮流从管道中读数据</li> </ul> </li> <li> <p>写进程往管道写数据，即便管道没被写满，只要管道没空，读进程就可以从管道读数据</p> </li> <li> <p>读进程从管道读数据，即便管道没被读空，只要管道没满，写进程就可以往管道写数据</p> </li> </ul> <h2 id="挂起状态七状态模型">挂起状态&#x26;七状态模型</h2> <p>暂时调到外存等待的进程状态为<strong>挂起状态(挂起态，suspend)</strong></p> <p>挂起态又可以进一步细分为<strong>就绪挂起、阻塞挂起</strong>两种状态</p> <p><img src="https://b.1wind.cn/2025/08/07a94e5cfa2284a84ed15a975d45b841.png" alt="image-20250813160146674"></p> <p>七状态模型如上图所示</p> <p>注意<strong>挂起</strong>和<strong>阻塞</strong>的区别，两种状态都是暂时不能获取CPU的服务，但挂起态是将进程映像调到外存去了，而阻塞态下进程映像还在内存中</p> <p>有的操作系统会把就绪挂起、阻塞挂起分为两个挂起队列，甚至会根据阻塞原因不同再把阻塞挂起进程进一步细分为多个队列</p> <h1 id="信号">信号</h1> <ul> <li>信号量(Semaphore)---实现进程间的同步、互斥</li> <li>信号(Signal)---实现进程间通信(IPC,Inter Process Communication)</li> </ul> <p>信号是用于<strong>通知进程某个特定事件已经发生</strong>。<strong>进程收到一个信号后，对该信号进行处理</strong></p> <p>注1：不同的操作系统对信号类型的定义不一样</p> <p>注2：通常用宏定义常量表示信号名，如：#define SIGINT 2</p> <p><strong>When 什么时候处理信号？</strong></p> <ul> <li>当用户从内核态转为用户态时(如：系统调用返回、或中断处理返回时)，例行检查是否有待处理信号，如果有，就处理信号</li> </ul> <p><strong>How 怎么处理信号？</strong></p> <ol> <li>执行操作系统为此类信号设置的缺省**(默认)信号处理程序**(<strong>某些信号默认忽略，不作处理</strong>)</li> <li>执行进程为此类信号设置<strong>用户自定义信号处理程序(自定义信号处理程序将覆盖①)</strong></li> </ol> <ul> <li>信号处理程序运行结束后，通常会返回进程的下一条指令继续执行(除非信号处理程序将进程阻塞或终止)</li> <li>一旦处理了某个信号，就将pending位重置位0</li> <li>重复收到的同类信号，将被简单地丢弃（因为仅有1bit记录一类待处理信号）</li> <li>当同时收到多个不同类信号时，通常先处理序号更小的信号</li> </ul> <p>信号可以作为异常的配套机制，让进程对操作系统的异常处理进行补充</p> <p>在进程运行过程中，某些特殊事件可能引发“异常”，操作系统内核负责捕获并处理异常</p> <ul> <li>有些异常可以由内核完成全部处理，此时就不必再使用信号机制</li> <li>有些异常无法由内核完成全部处理，可能还需要用户进程配合，此时就可以用“信号机制”与”异常机制“相互配合（如：在Linux中，会发生<strong>除以0异常</strong>时，内核的异常处理程序会向用户进程发送SIGFPE信号。SIGFPE信号的默认处理程序会终止并转储内存；当然进程可以自定义SIGFPE信号处理程序）</li> </ul> <h1 id="线程">线程</h1> <h2 id="概念-5">概念</h2> <p>可以把线程理解为“轻量级进程”</p> <p>线程是一个基本的CPU执行单元，也是程序执行流的最小单位</p> <p>引入线程之后，不仅是进程之间可以并发，进程内的各线程之间也可以并发，从而进一步提升了系统的并发度，使得一个进程内也可以并发处理各种任务(如QQ视频、文字聊天、传文件)</p> <p>引入线程后，进程只作为除CPU之外的系统资源的分配单元(如打印机、内存地址空间等都是分配给进程的)</p> <h2 id="特点">特点</h2> <p><strong>引入线程机制后带来的变化</strong></p> <ul> <li>资源分配、调度 <ul> <li>传统进程机制中，进程是资源分配、调度的基本单位</li> <li>引入线程后，进程是资源分配的基本单位，线程是调度的基本单位</li> </ul> </li> <li>并发性 <ul> <li>传统进程机制中，只能进程间并发</li> <li>引入线程后，各线程间也能并发，提升了并发度</li> </ul> </li> <li>系统开销 <ul> <li>传统的进程间并发，需要切换进程的运行环境，系统开销很大</li> <li>线程间并发，如果是同一进程内的线程切换，则不需要切换进程环境，系统开销小</li> <li>引入线程后，并发所带来的系统开销减小</li> </ul> </li> </ul> <p><strong>属性</strong></p> <ul> <li>线程是处理机调度的单位</li> <li>多CPU计算机中，各个线程可占用不同的CPU</li> <li>每个线程都有一个线程ID、线程控制块(TCB)</li> <li>线程也有就绪、阻塞、运行三种基本状态</li> <li>线程几乎不拥有系统资源</li> <li>同一进程的不同线程间共享进程的资源</li> <li>由于共享内存地址空间，同一进程中的线程间通信甚至无需系统干预</li> <li>同一进程中的线程切换，不会引起进程切换</li> <li>不同进程中的线程切换，会引起进程切换</li> <li>切换同进程内的线程，系统开销很小</li> <li>切换进程，系统开销较大</li> </ul> <h2 id="实现方式">实现方式</h2> <h3 id="用户级线程">用户级线程</h3> <ol> <li>用户级线程由应用程序通过线程库实现，所有的线程管理各种都由应用程序负责(包括线程切换)</li> <li>用户级线程中，线程切换可以在用户态下即可完成，无需操作系统干预</li> <li>在用户看来，是有多个线程。但是在操作系统内核看来，并意识不到线程的存在</li> </ol> <p>“用户级线程”就是“从用户视角可以看到的线程”</p> <ul> <li>优缺点 <ul> <li>优点：用户级线程的切换在用户空间即可完成，不需要切换到核心态，线程管理的系统开销小，效率高</li> <li>缺点：当一个用户级线程被阻塞后，整个进程都会被阻塞，并发度不高。多个线程不可在多核处理机上并行运行</li> </ul> </li> </ul> <h3 id="内核级线程">内核级线程</h3> <ol> <li>内核级线程的管理工作由操作系统内核完成</li> <li>线程调度、切换等工作都由内核负责，因此内核级线程的切换必然需要在核心态下才能完成</li> <li>操作系统会为每个内核级线程建立相应的TCB(Thread Control Block，线程控制块)，通过TCB对线程进行管理。“内核级线程”就是“从操作系统内核视角能看到的线程”</li> </ol> <ul> <li>优缺点 <ul> <li>优点：当一个线程被阻塞后，别的线程还可以继续执行，并发能力强。多线程还在多核处理机上并行执行</li> <li>缺点：一个用户进程会占用多个内核级线程，线程切换由操作系统内核完成，需要切换到核心态，因此线程管理的成本高，开销大</li> </ul> </li> </ul> <h2 id="多线程模型">多线程模型</h2> <p><strong>一对一</strong>模型：一个用户级线程映射到一个内核级线程。每个用户进程有与用户级线程同数量的内核级线程</p> <p>优点：当一个线程被阻塞后，别的线程还可以继续执行，并发能力强。多线程可在多核处理机上并行执行</p> <p>缺点：一个用户进程会占用多个内核级线程，线程切换由操作系统内核完成，需要切换到核心态，因此线程管理的成本高，开销大</p> <p><strong>多对一</strong>模型：多个用户级线程映射到一个内核级线程。且一个进程只被分配一个内核级线程</p> <p>优点：用户级线程的切换在用户空间即可完成，不需要切换到核心态，线程管理的系统开销小，效率高</p> <p>缺点：当一个用户级线程被阻塞后，整个进程都会被阻塞，并发度不高。多个线程不可在多核处理机上并行运行</p> <p><strong>重点</strong>：操作系统只<code>看得见</code>内核级线程，因此只有内核级线程才是处理机分配的单位，所以无法并行</p> <p><strong>多对多</strong>模型：n用户级线程映射到m个内核级线程(n>=m)。每个用户进程对应m个内核级线程</p> <p>克服了多对一(并发度不高的缺点，一个阻塞全体阻塞)，又克服了一对一模型中一个用户进程占用太多内核级线程，开销太大的缺点</p> <p>可以这么理解：</p> <p>用户级线程是“代码逻辑”的载体</p> <p>内核级先是“运行机会”的载体</p> <p><strong>内核级线程才是处理机分配的单位</strong>，且内核级线程中可以运行任意一个有映射关系的用户级线程代码，只有两个内核级线程中正在运行的代码逻辑都阻塞时，这个进程才会阻塞</p> <h2 id="状态与转换">状态与转换</h2> <p>如图所示，其实线程的状态与转换和进程是类似的，几乎没区别</p> <img src="https://b.1wind.cn/2025/08/13ec64f48fc42929dd56a38e001a9c12.png" alt="image-20250813145901208" style="zoom:50%;"> <h1 id="进程调度">进程调度</h1> <h2 id="概念-6">概念</h2> <p>当有一堆任务要处理，但由于资源有限，这些事情没法同时处理。这就需要确定<strong>某种规则</strong>来<strong>决定</strong>处理这些任务的<strong>顺序</strong>，这就是调度研究的问题</p> <h2 id="高级调度">高级调度</h2> <p>高级调度(作业调度)。按一定的原则从外存的作业后备队列中年挑选一个作业调入内存，并创建进程。每个作业只调入一次，调出一次。作业调入时会建立PCB，调出时才撤销PCB</p> <p>作业：一个具体的任务</p> <p>用户向系统提交一个作业≈用户让操作系统启动一个程序(来处理一个具体的任务)</p> <h2 id="低级调度">低级调度</h2> <p>低级调度(进程调度/处理机调度)---按照某种策略从就绪队列中选取一个进程，将处理机分配给它</p> <p>进程调度是操作系统中最基本的一种调度，在一般的操作系统中年都必须配置进程调度</p> <p>进程调度的频率很高，一般几十毫秒一次</p> <h2 id="中级调度">中级调度</h2> <p>内存不够时，可将某些进程的数据调出外存。等内存空闲或者进程需要运行时再重新调入内存</p> <p>暂时调到外存等待的进程状态为<strong>挂起状态</strong>。被挂起的进程PCB会被组织成<strong>挂起队列</strong></p> <p>中级调度(内存调度)---按照某种策略决定将哪个处于挂起状态的进程重新调入内存</p> <p>一个进程可能会被多次调入和调出，因此中级调度发生的<strong>频率</strong>比高级调度<strong>更高</strong></p> <h2 id="调度对比">调度对比</h2> <table><thead><tr><th></th><th>要做什么</th><th>调度发生</th><th>发生频率</th><th>对进程状态的影响</th></tr></thead><tbody><tr><td>高级调度<br>(作业调度)</td><td>按照某种规则，从后备队列中选择合适的作业将其调入内存，并为其创建进程</td><td>外存->内存<br>(面向作业)</td><td>最低</td><td>无->创建态->就绪态</td></tr><tr><td>中级调度<br>(内存调度)</td><td>按照某种规则，从挂起队列中选择合适的进程将其数据调回内存</td><td>外存->内存<br>(面向进程)</td><td>中等</td><td>挂起态->就绪态<br>(阻塞挂起->阻塞态)</td></tr><tr><td>低级调度<br>(进程调度)</td><td>按照某种规则，从就绪队列中选择一个进程为其分配处理机</td><td>孽畜->CPU</td><td>最高</td><td>就绪态->运行态</td></tr></tbody></table> <h2 id="时机">时机</h2> <p>进程调度(低级调度)，就是按照某种算法从就绪队列中选择一个进程为其分配处理机</p> <ul> <li>需要进行进度调度与切换的情况 <ul> <li>当前运行的进程主动放弃处理机 <ul> <li>进程正常终止</li> <li>运行过程中发生异常而终止</li> <li>进程主动请求阻塞(如等待I/0)</li> </ul> </li> <li>当前运行的进程被动放弃处理机 <ul> <li>分给进程的时间片用完</li> <li>有更紧急的事需要处理(如I/O中断)</li> <li>有更高优先级的进程进入就绪队列</li> </ul> </li> </ul> </li> <li>不能进行进程调度与切换的情况 <ol> <li>在处理中断的过程中。中断处理过程复杂，与硬件密切相关，很难做到在中断处理过程中进行进程切换</li> <li>进程在操作系统内核程序临界区中</li> <li>在原子操作过程中(原语)。原子操作不可中断，要一气呵成</li> </ol> </li> </ul> <p>进程在<strong>操作系统内核程序临界区</strong>中不能进行调度和切换</p> <p>临界资源：一个时间段内只允许一个进程使用的资源。各进程需要<strong>互斥地</strong>访问临界资源</p> <p>临界区：访问临界资源的那段代码</p> <p><strong>内核程序临界区</strong>一般是用来访问<strong>某种内核数据结构</strong>的，比如进程的就绪队列(由各就绪进程的PCB组成)</p> <p><strong>普通临界区是可以进行调度和切换的，内核临界区不可以</strong></p> <h2 id="方式">方式</h2> <p><strong>非剥夺调度方式</strong>，又称<strong>非抢占方式</strong>。即，只允许进程主动放弃处理机。在运行过程中即便有更紧迫的任务到达，当前进程依然会继续使用处理机，直到该进程或主动要求进入阻塞态，实现简单，系统开销小，但是无法及时处理紧急任务，适合于早期的批处理系统</p> <p><strong>剥夺调度方式</strong>，又称<strong>抢占方式</strong>。当一个进程正在处理机上执行时，如果有一个更重要或更紧迫的进程需要处理机，则立即暂停正在执行的进程，将处理机分配给更重要更紧迫的那个进程，可以优先处理更紧急的进程，也可实现让各进程按时间片轮流执行的功能(通过时钟中断)。适合于分时操作系统、实时操作系统</p> <h2 id="切换与过程">切换与过程</h2> <p>“狭义的进程调度”与“进程切换”的区别</p> <p><strong>狭义的进程调度</strong>指的是从就绪队列中<strong>选出一个要运行的进程</strong>。(这个进程可以是刚刚被暂停执行的过程，也可能是<strong>另一个进程</strong>，后一种情况就需要<strong>进程切换</strong>)</p> <p><strong>进程切换</strong>是指一个进程让出处理机，由另一个进程占用处理机的过程</p> <p><strong>广义的进程调度</strong>包含了选择一个进程和进程切换两个步骤</p> <p>进程切换的过程主要完成了：</p> <ol> <li>对原来运行进程各种数据的保存</li> <li>对新的进程各种数据的恢复(如：程序计数器、程序状态字、各种数据寄存器等处理机现场信息，这些信息一般保存在进程控制块)</li> </ol> <p>注意：<strong>进程切换是有代价的</strong>，因此如果<strong>过于频繁的</strong>进行进度<strong>调度</strong>、<strong>切换</strong>，必然会使整个<strong>系统的效率降低</strong>，使系统大部分时间都花在了<u>进程切换</u>上，而真正用于执行进程的时间减少</p> <h2 id="调度器调度程序">调度器/调度程序</h2> <img src="https://b.1wind.cn/2025/08/c12210fc4bc0593fc768618ea761cfc6.png" alt="image-20250814102307432" style="zoom:67%;"> <p>②、③由调度程序引起，调度程序决定：</p> <ul> <li>让谁运行---调度算法</li> <li>运行多长时间---时间片大小</li> </ul> <p>调度时机---什么事件会触发调度程序</p> <ul> <li>创建新进程</li> <li>进程退出</li> <li>运行进程阻塞</li> <li>I/O中断发生(可能唤醒某些阻塞进程)</li> <li>非抢占式调度策略，只有运行进程阻塞或退出才触发调度程序工作</li> <li>抢占式调度策略，每个时钟中断或k个时钟中断会触发调度程序工作</li> </ul> <h2 id="闲逛进程">闲逛进程</h2> <p>调度程序永远的备胎，没有其他就绪进程时，运行闲逛进程(idle)</p> <p>闲逛进程的特性：</p> <ul> <li>优先级最低</li> <li>可以是0地址指令，占一个完整的指令周期(指令周期末尾例行检查中断)</li> <li>能耗低</li> </ul> <h2 id="评价指标">评价指标</h2> <h3 id="cpu利用率">CPU利用率</h3> <p>由于早期的CPU造价极其昂贵，因此人们会希望让CPU尽可能多的工作</p> <p>CPU利用率：指CPU“忙碌”的时间占总时间的比例 $$ 利用率=\frac{忙碌的时间}{总时间} \ Eg:\ 某计算机只支持单道程序\ 某个作业刚开始需要在CPU上运行5秒，再用打印机打印输出5秒，之后再执行5秒才能结束。\ 在此过程中，CPU利用率、打印机利用率分别是多少？\ CPU利用率=\frac{5+5}{5+5+5}=66.66% \ 打印机利用率=\frac{5}{15}=33.33% $$</p> <h3 id="系统吞吐量">系统吞吐量</h3> <p>对于计算机来说，希望能用尽可能少的时间处理完尽可能多的作业</p> <p>系统吞吐量：单位时间内完成作业的数量 $$ 系统吞吐量=\frac{总共完成了多少道作业}{总共花了多少时间} \ Eg:某计算机系统处理完10道作业，共花费100秒，则系统吞吐量为？\ \frac{10}{100} = 0.1道/秒 $$</p> <h3 id="周转时间">周转时间</h3> <p>对于计算机的用户来说，他很关心自己的作业从提交到完成花了多少时间</p> <p><strong>周转时间</strong>，是指从<strong>作业被提交给系统开始</strong>，到<strong>作业完成为止</strong>的这段时间间隔</p> <p>它包括四个部分：作业在外存后备队列上等待作业调度(高级调度)的时间、进程在就绪队列上等待进程调度(低级调度)的时间、进程在CPU上执行的时间、进程等待I/O操作完成的时间。后三项在一个作业的整个处理过程中，可能发生多次</p> <p>(作业)<strong>周转时间</strong>=作业完成时间-作业提交时间</p> <p>对于用户来说，更关心自己单个作业的周转时间 $$ 平均周转时间=\frac{各作业周转时间之和}{作业数} $$ 对于周转时间相同的两个作业，实际运行时间长的作业在相同时间内被服务的时间更多，带权周转时间更小，用户满意度更高 $$ 带权周转时间=\frac{作业周转时间}{作业实际运行时间}=\frac{作业完成时间-作业提交时间}{作业实际运行的时间}\ 平均带权周转时间=\frac{各作业带权周转时间之和}{作业数} $$</p> <h3 id="等待时间">等待时间</h3> <p>计算机的用户希望自己的作业尽可能少的等待处理机</p> <p><strong>等待时间</strong>，指进程/作业<strong>处于等待处理机状态时间之和</strong>,等待时间越长，用户满意度越低</p> <p>对于<strong>进程</strong>来说，等待时间就是指进程建立后<strong>等待被服务的时间之和</strong>，在等待I/O完成的期间其实进程也是在被服务的，所以不计入等待时间</p> <p>对于<strong>作业</strong>来说，不仅要考虑<strong>建立进程后的等待时间，还要加上作业在外存后备队列中等待的时间</strong></p> <p>一个作业总共需要被CPU服务多久，被I/O设备服务多久一般是确定不变的，因此调度算法其实只会影响作业/进程的等待时间。当然，与前面的指标类似，也有“<strong>平均等待时间</strong>”来评价整体性能</p> <h3 id="响应时间">响应时间</h3> <p>对应计算机用户来说，会希望自己的提交的请求(比如通过键盘输入了一个调试命令)尽早地开始被系统服务、回应</p> <p><strong>响应时间</strong>，指从用户<strong>提交请求</strong>到<strong>首次产生响应</strong>所用时间</p> <h2 id="调度算法">调度算法</h2> <h3 id="先来先服务">先来先服务</h3> <p>先来先服务(FCFS，First Come First Serve)</p> <ul> <li>主要从公平的角度考虑(类似于排队)</li> <li>按照作业/进程到达的先后顺序进行服务</li> <li>用于作业调度时，考虑的是哪个作业先到达后备队列；用于进程调度时，考虑的是哪个进程先到达就绪队列</li> <li>非抢占式算法</li> <li>优点：公平、算法实现简单</li> <li>缺点：排在长作业(进程)后面的短作业需要等待很长时间，带权周期时间很大，对短作业来说用户体验不好。即FCFS算法对长作业有利，对短作业不利(Eg:排队)</li> <li>不会<strong>饥饿</strong>(饥饿是指某进程/作业长期得不到服务)</li> </ul> <p>例题如下</p> <img src="https://b.1wind.cn/2025/08/265e5b51dd62262f6c43296b57870356.png" alt="image-20250814145328008" style="zoom:50%;"> <h3 id="短作业优先">短作业优先</h3> <p>短作业优先(SJF,Shortest Job First)</p> <ul> <li>追求最少的平均等待时间，最少的平均周转时间、最少的平均带权周转时间</li> <li>最短的作业/进程优先得到服务(所谓“最短”，是指要求服务时间最短)</li> <li>可用于作业调度，也可用于进程调度。用于进程调度时称为“<strong>短进程优先(SPF,Shortest Process First)</strong>”算法</li> <li>SJF和SPF是非抢占式的算法。但是也有<strong>抢占式的版本</strong>---<strong>最短剩余时间优先算法</strong>(SRTN,Shortest Remaining Time Next)</li> <li>优点：“最短的”平均等待时间、平均周转时间</li> <li>缺点：不公平。对短作业有利，对长作业不利。可能产生<strong>饥饿</strong>现象。另外。作业/进程的运行时间是由用户提供的，并不一定真实，不一定能做到真正的短作业优先</li> <li>会饥饿。如果源源不断地有短作业/进程到来，可能使长作业/进程长时间得不到服务，产生<strong>饥饿</strong>现象。如果一直得不到服务，则称为<strong>饿死</strong></li> </ul> <p>非抢占式短作业优先算法例题如下</p> <img src="https://b.1wind.cn/2025/08/44aba370162141bf45888bf4290f687b.png" alt="image-20250814150546467" style="zoom:50%;"> <p>抢占式短作业优先算法解析</p> <img src="https://b.1wind.cn/2025/08/497e18581521aac331c199d73f740802.png" alt="image-20250814151147429" style="zoom:50%;"> <p>抢占式短作业优先算法例题</p> <img src="https://b.1wind.cn/2025/08/07011801c6224f1bb248879495e79a01.png" alt="image-20250814151323484" style="zoom:50%;"> <p>注意几个小细节：</p> <ol> <li> <p>如果题目中<strong>未特别说明</strong>，所提到的短作业/进程优先算法，<strong>默认</strong>是<strong>非抢占式的</strong></p> </li> <li> <p>很多书上都会说“SJF调度算法的平均等待时间、平均周转时间最少”</p> <p>严格来说，这个表述是错误的，不严谨的。</p> <p>之前的例子表明，最短剩余时间优先算法得到的平均等待时间、平均周转时间还要更少</p> <p>应该加上一个条件“在<strong>所有进程同时可运行时</strong>，采用SJF调度算法的平均等待时间、平均周转时间最少”；</p> <p>或者说“<strong>在所有进程都几乎同时到达</strong>时，采用SJF调度算法的平均等待时间、平均周转时间最少”；</p> <p>如果不加上述前提条件，则应该说“<strong>抢占式</strong>的短作业/进程优先调度算法(<strong>最短剩余时间优先</strong>，<strong>SRNT</strong>算法)的平均等待时间、平均周转时间最少”</p> </li> <li> <p>虽然严格来说，SJF的平均等待时间、平均周转时间并不是最少，但相比于其他算法(如FCFS)，SJF依然可以获得较少的平均等待时间、平均周转时间</p> </li> <li> <p>如果选择题中遇到“SJF算法的平均等待时间、平均周转时间最少”的选项，那最好判断其他选项是不是有很明显的错误，如果没有更合适的选项，那也应该选择该选项</p> </li> </ol> <h3 id="高响应比优先">高响应比优先</h3> <p>高响应比优先(HRRN,Highest Response Ratio Next)</p> <ul> <li> <p>要综合考虑作业/进程的等待时间和要求服务的时间</p> </li> <li> <p>在每次调度时先计算各个作业/进程的<strong>响应比</strong>，选择<strong>响应比最高</strong>的作业/进程为其服务</p> </li> <li> <p>$$ 响应比=\frac{等待时间+要求服务时间}{要求服务时间} $$</p> </li> <li> <p>可用于作业调度，也可用于进程调度</p> </li> <li> <p>属于非抢占式的算法。因此只有当前运行的作业/进程主动放弃处理机时，才需要调度，才需要计算响应比</p> </li> <li> <p>综合考虑了等待时间和运行时间(要求服务时间)，等待时间相同时，要求服务时间短的优先(SJF的优点)；要求服务时间相同时，等待时间长的优先(FCFS的优点)，对于长作业来说，随着等待时间越来越久，其响应比也会越来越大，从而避免了长作业饥饿的问题</p> </li> <li> <p>不会饥饿</p> </li> </ul> <p>例题如下</p> <img src="https://b.1wind.cn/2025/08/3c849efae6242a730005d6ec232987b4.png" alt="image-20250814155526360" style="zoom:50%;"> <h3 id="时间片轮转">时间片轮转</h3> <p>时间片轮转(RR,Round-Robin)</p> <ul> <li>公平地、轮流地为各个进程服务，让每个进程在一定时间间隔内都可以得到响应</li> <li>按照各进程到达就绪队列的顺序，轮流让每个进程执行一个<strong>时间片</strong>(如100ms)。若进程未在一个时间片内执行完，则剥夺处理机，将进程重新放到就绪队列队尾重新排队</li> <li>用于进程调度(只有作业放入内存建立了相应的进程后，才能被分配处理时间片)</li> <li>若进程未能在时间片内运行完，将被强行剥夺处理机使用权，因此时间片轮转调度算法属于抢占式的算法。由时钟装置发出时钟中断来通知CPU时间片已到</li> <li>优点：公平；响应快，适用于分时操作系统；</li> <li>缺点：由于高频率的进程切换，因此有一定开销；不区分任务的紧急程度</li> <li>不会饥饿</li> </ul> <p>如果<strong>时间片太大</strong>，使得每个进程都可以在一个时间片内完成，则时间片轮转调度算法<strong>退化为先来先服务调度算法</strong>，并且<strong>会增大进程响应时间</strong>。因此<strong>时间片不能太大</strong></p> <p>另一方面，进程调度、切换是有时间代价的(保存、恢复运行环境)，因此如果<strong>时间片太小</strong>，会导致<strong>进程切换过于频繁</strong>，系统会花大量的时间来处理进程切换，从而导致实际用于进程执行的时间比例减少。可见<strong>时间片也不能太小</strong></p> <p>例题如下</p> <img src="https://b.1wind.cn/2025/08/ac8c5e77428422b7502c3c8bd2e0d0b9.png" alt="image-20250815102227212" style="zoom:50%;"> <h3 id="优先级">优先级</h3> <p>优先级调度算法</p> <ul> <li>随着计算机的发展，特别是实时操作系统的出现，越来越多的应用场景需要根据任务的紧急程度来决定处理顺序</li> <li>调度时选择优先级最高的作业/进程</li> <li>既可用于作业调度，也可用于进程调度。甚至，还会用于在之后会学习的I/O调度中</li> <li>抢占式、非抢占式都有。做题时的区别在于：非抢占式只需在进程主动放弃处理机时调度即可，而抢占式还需在就绪队列变化时，检查是否会发生抢占</li> <li>优点：用优先级区分紧急程度、重要程度，适用于实时操作系统。可灵活地调整对各种作业/进程的偏好程度</li> <li>缺点：若源源不断地有高优先级进程到来，则可能导致饥饿</li> <li>会饥饿</li> </ul> <p>非抢占式例题</p> <img src="https://b.1wind.cn/2025/08/1ebcf64410ac2d2c5eba524d2a8a7bde.png" alt="image-20250815104017583" style="zoom:50%;"> <p>抢占式例题</p> <img src="https://b.1wind.cn/2025/08/4cb0720c04a0c1a98295e8444c92ee52.png" alt="image-20250815104605357" style="zoom:50%;"> <p>补充：</p> <p>就绪队列未必只有一个，可以按照不同优先级来组织。另外，也可以把优先级高的进程排在更靠近队头的位置</p> <p>根据优先级是否可以动态改变，可将优先级分为静态优先级和动态优先级两种。</p> <ul> <li>静态优先级：创建进程时确定，之后一直不变</li> <li>动态优先级：创建进程时有一个初始值，之后会根据情况动态地调整优先级</li> </ul> <p><strong>如何合理地设置各类进程的优先级？</strong></p> <p>通常：系统进程优先级<strong>高于</strong>用户进程，前台进程优先级<strong>高于</strong>后台进程，操作系统更<strong>偏好I/O型进程(或称I/O繁忙型进程)</strong></p> <p>注：与I/O型进程相对的是<strong>计算型进程(或称CPU繁忙型进程)</strong></p> <p>I/O设备和CPU可以<u>并行</u>工作。如果优先让I/O繁忙型进程优先运行的话，则越有可能让I/O设备尽早地投入工作，则资源利用率、系统吞吐量都会得到提升</p> <p><strong>如果采用的是动态优先级</strong>，<strong>什么时候应该调整？</strong></p> <p>可以从追求公平、提升资源利用率等角度考虑</p> <p>如果某进程在就绪队列中等待了很长时间，则可以适当提升其优先级</p> <p>如果某进程占用处理机运行了很长时间，则可适当降低其优先级</p> <p>如果发现一个进程频繁地进行I/O操作，则可适当提升其优先级</p> <h3 id="多级反馈队列">多级反馈队列</h3> <p>多级反馈队列调度算法</p> <ul> <li>对其他调度算法的折中权衡</li> <li>规则 <ol> <li>设置多级就绪队列，各级队列优先级从高到低，时间片从小到大</li> <li>新进程到达时先进入第1级队列，按FCFS原则排队等待被分配时间片，若用完时间片还未结束，则进程进入下一级队列队尾。如果此时已经是在最下级的队列，则重新放回该队列队尾</li> <li>只有第k级队列为空时，才会为k+1级队头的进程分配时间片</li> </ol> </li> <li>用于进程调度</li> <li><strong>抢占式</strong>的算法。在k级队列的进程运行过程中，若更上级的队列(1~k-1级)中进入了一个新进程，由于新进程处于优先级更高的队列中，因此新进程会抢占处理机，原来运行的进程放回k级队列队尾</li> <li>对各类进程相对公平(FCFS的优点)；每个新到达的进程都可以很快就得到响应(RR)的优点；短进程只用较少的时间就可以完成(SPF的优点)；不必实现估计进程的运行时间(避免用户造假)；可灵活地调整对各类进程的偏好程度，比如CPU密集进程、I/O密集型进程(拓展：可以将因I/O而阻塞的进程重新放回原队列，这样I/O型进程就可以保持较高优先级)</li> <li>会饥饿</li> </ul> <p>例题</p> <img src="https://b.1wind.cn/2025/08/ac66a613430020c0d87d813a144f8bfa.png" alt="image-20250815111515250" style="zoom:50%;"> <h3 id="多级队列">多级队列</h3> <p>多级队列调度算法</p> <img src="https://b.1wind.cn/2025/08/6bcca856186739acdc6478816ada2117.png" alt="image-20250815140753659" style="zoom:50%;"> <p>系统中按进程类型设置多个队列，进程创建成功后插入某个队列</p> <p>队列之间可采取固定优先级，或时间片划分</p> <ul> <li>固定优先级：高优先级空时，低优先级进程才能被调度</li> <li>时间片划分：如三个队列分配时间50%、40%、10%</li> </ul> <p>各队列可采用不同的调度策略，如：</p> <ul> <li>系统进程队列采用优先级调度</li> <li>交互式队列采用RR</li> <li>批处理队列采用FCFS</li> </ul> <h3 id="总结">总结</h3> <table><thead><tr><th>算法</th><th>可抢占？</th><th>优点</th><th>缺点</th><th>考虑到等待时间&#x26;运行时间？</th><th>会导致饥饿？</th></tr></thead><tbody><tr><td>FCFS</td><td>非抢占式</td><td>公平；实现简单</td><td>对短作业不利</td><td>考虑等待时间<br>不考虑运行时间</td><td>不会</td></tr><tr><td>SJF/SPF</td><td>默认为非抢占式，也有SJF的抢占式，即版本最短剩余时间优先算法(SRTN)</td><td>“最短的”平均等待/周转时间</td><td>对长作业不利；难以做到真正的短作业优先</td><td>考虑等待时间<br>不考虑运行时间</td><td>会</td></tr><tr><td>HRRN</td><td>非抢占式</td><td>完善上述算法</td><td></td><td>考虑等待时间<br>考虑运行时间</td><td>不会</td></tr><tr><td>时间片轮转</td><td>抢占式</td><td>公平，适用于分时系统</td><td>频繁切换与开销，不区分优先级</td><td></td><td>不会</td></tr><tr><td>优先级</td><td>都有</td><td>区分优先级，适用于实时操作系统</td><td>可能会饥饿</td><td></td><td>会</td></tr><tr><td>多级反馈队列</td><td>抢占式</td><td>优秀</td><td>一般无缺点，可能会饥饿</td><td></td><td></td></tr></tbody></table> <h2 id="多处理机调度">多处理机调度</h2> <h3 id="概念-7">概念</h3> <p>单处理机调度：只需决定让哪个就绪进程优先上处理机即可</p> <p>多处理机调度：</p> <ol> <li>用调度算法决定让哪个就绪进程优先上处理机</li> <li><strong>还需决定被调度的进程到底上哪个处理机</strong></li> </ol> <p>多处理机调度中，应追求的目标：</p> <ul> <li>负载均衡---尽可能让每个CPU都同等忙碌</li> <li>处理机亲和性---尽量让一个进程调度到同一个CPU上运行，以发挥CPU中缓存的作用(Cache)</li> </ul> <h3 id="公共就绪队列">公共就绪队列</h3> <ul> <li>所有CPU共享同一个就绪进程队列(位于内核区)</li> <li>每个CPU运行调度程序时，从公共就绪队列中选择一个进程运行</li> <li>每个CPU访问公共就绪队列时需要上锁(确保互斥)</li> </ul> <p>优点：可以天然地实现负载均衡</p> <p>缺点：各个进程频繁地切换CPU运行，“亲和性”不好</p> <p><strong>如何提示处理机亲和性</strong>？</p> <ul> <li>软亲和：由进程调度程序尽量保证“亲和性”</li> <li>硬亲和：由用户进程通过系统调用，主动要求操作系统分配固定的CPU，确保“亲和性”</li> </ul> <h3 id="私有就绪队列">私有就绪队列</h3> <ul> <li>每个CPU都有一个私有就绪队列</li> <li>CPU空闲时运行调度程序，从私有就绪队列中选择一个进程运行</li> </ul> <p><strong>如何实现负载均衡</strong>？</p> <p><strong>推迁移(Push)策略:</strong></p> <p><u>一个特定的系统程序周期性检查每个处理器的负载</u>,如果负载不平衡,就从忙碌CPU的就绪队列中”推”一些就绪进程到空闲CPU的就绪队列中</p> <p><strong>拉迁移(Pull)策略:</strong></p> <p>每个CPU运行调度程序时,周期性检查自身负载与其他CPU负载.如果一个CPU负载很低,就从其他高负载CPU的就绪队列中”拉”一些就绪进程到自己的就绪队列</p> <p><strong>优点</strong>:天然地实现了处理机亲和性</p> <h1 id="同步互斥">同步&#x26;互斥</h1> <h2 id="进程同步">进程同步</h2> <p><strong>同步</strong>也称<strong>直接制约关系</strong>，它是指为完成某种任务而建立的两个或多个进程，这些进程因为需要在某些位置上<strong>协调</strong>它们的<strong>工作次序</strong>而产生的制约关系。进程间的直接制约关系就是源于它们之间的相互合作</p> <h2 id="进程互斥">进程互斥</h2> <h3 id="概念-8">概念</h3> <p>我们把一个时间段只允许一个进程使用的资源称为临界资源。许多物理设备(比如摄像头、打印机)都属于临界资源。此外还有许多变量、数据、内存缓存区等都属于临界资源</p> <p>对临界资源的访问，必须互斥地进行。互斥，也称间接制约关系。进程互斥指当一个进程访问某临界资源时，另一个想要访问该临界资源的进程必须等待。当前访问临界资源的进程访问结束，释放该资源之后，另一个进程才能去访问临界资源</p> <p>对临界资源的互斥访问，可以在逻辑上分为如下四个部分</p> <ul> <li>进入区：负责检查是否可进入临界区，若可进入，则应设置<u>正在访问临界资源的标志</u>(可理解为“上锁”)，以阻止其他进程同时进入临界区</li> <li>临界区：访问临界资源的那段代码</li> <li>退出区：负责解除<u>正在访问临界资源的标志</u>(可理解为“解锁”)</li> <li>剩余区：做其他处理</li> </ul> <p>注意：</p> <ul> <li><strong>临界区</strong>是进程中<strong>访问临界资源</strong>的代码段</li> <li><strong>进入区</strong>和<strong>退出区</strong>是<strong>负责实现互斥</strong>的代码段</li> <li>临界区也可称为“临界段”</li> </ul> <p>为了实现对临界资源的互斥访问，同时保证系统整体性能，需要遵循以下原则：</p> <ol> <li><strong>空闲让进</strong>。临界区空闲时，可以允许一个请求进入临界区的进程立即进入临界区</li> <li><strong>忙则等待</strong>。当已有进程进入临界区时，其他试图进入临界区的进程必须等待</li> <li><strong>有限等待</strong>。对请求访问的进程，应保证能在有限时间内进入临界区(保证不会饥饿)</li> <li><strong>让权等待</strong>。当进程不能进入临界区时，应立即释放处理机，防止进程忙等待</li> </ol> <h3 id="软件实现方法">软件实现方法</h3> <h4 id="单标志法">单标志法</h4> <p>算法思想：两个进程在<strong>访问完临界区后</strong>会把使用临界区的权限转交给另一个进程。也就是说<strong>每个进程进入临界区的权限只能被另一个赋予</strong></p> <p><img src="https://b.1wind.cn/2025/08/6560ec9c57d21600adeab25fd6f1b0b9.png" alt="image-20250816102046745"></p> <p>上图是具体过程</p> <p>因此，该算法可以实现“<strong>同一时刻最多只允许一个进程访问临界区</strong>”</p> <p>但算法有个致命的缺陷，只能按P0->P1->P0->P1->…这样轮流访问。这种必须“轮流访问”带来的问题是，如果此时运行进入临界区的进程是P0，而P0一直不访问临界区，那么虽然此时临界区空闲，但是并不允许P1访问。</p> <p>因此，<strong>单标志法</strong>存在的<strong>主要问题</strong>是：<strong>违背“空闲让进”原则</strong></p> <h4 id="双标志先检查法">双标志先检查法</h4> <p>算法思想：设置一个布尔型数组flag[]，数组中各个元素用来<strong>标记各进程想进入临界区的意愿</strong>,比如“flag[0]=true”，意味着0号进程P0现在想要进入临界区。每个进程在进入临界区之前先检查当前有没有别的进程想进入临界区，如果没有，则把自身对应的标志flag[i]设为true，之后开始访问临界区</p> <p><img src="https://b.1wind.cn/2025/08/fcca6c10172d448dc22c7c19188fb03a.png" alt="image-20250816102905161"></p> <p>如上图所示</p> <p>若按照①⑤②⑥③⑦…的顺序执行，P0和P1将会同时访问临界区，因为进程可能并发执行，导致还没做判断时就被切换到另一个进程了</p> <p>因此，双标志先检查法的<strong>主要问题</strong>是：<strong>违反“忙则等待”原则</strong></p> <p>原因在于，<strong>进入区</strong>的“检查”和“上锁”两个处理不是一气呵成的。“检查后”，“上锁”前可能发生进程切换</p> <h4 id="双标志后检查法">双标志后检查法</h4> <p>算法思想：双标志先检查法的改版。前一个算法的问题是先“检查”后“上锁”，但是这两个操作又无法一气呵成，结果导致了两个进程同时进入临界区的问题。因此，人们又想到先“上锁”后“检查”的方法，来避免上述问题</p> <p><img src="https://b.1wind.cn/2025/08/46eee532f8b34264325dfcd920e06ccd.png" alt="image-20250816103648339"></p> <p>如上图所示</p> <p>若按照①⑤②⑥…的顺序执行，P0和P1将都无法进入临界区</p> <p>因此双标志后检查法虽然**解决了“忙则等待”<strong>的问题，但是又违背了</strong>“空闲让进”和“有限等待”<strong>原则，会因各进程都长期无法访问临界资源而</strong>产生“饥饿”**现象</p> <h4 id="peterson算法">Peterson算法</h4> <p>算法思想：结合双标志法、单标志法的思想。如果双方都争着想进入临界区，那可以让进程尝试谦让。</p> <p><strong>做一个有礼貌的进程。</strong></p> <p><img src="https://b.1wind.cn/2025/08/2cdc6355997fedea0dc1585305e9da65.png" alt="image-20250816104506485"></p> <p>如上图所示</p> <p>看着很复杂，其实很简单</p> <p>在进入区做了这些操作</p> <ol> <li>主动争取资源</li> <li>主动谦让</li> <li>检查对方是否也想使用，且最后一次不是自己做了谦让动作</li> </ol> <p>Peterson算法用软件方法解决了进程互斥问题，<strong>遵循了空闲让进</strong>、<strong>忙则等待</strong>、<strong>有限等待</strong>三个原则，但是依然<strong>未遵循让权等待</strong>的原则</p> <h3 id="硬件实现方法">硬件实现方法</h3> <h4 id="中断屏蔽方法">中断屏蔽方法</h4> <p>利用“开/关中断指令”实现(与原语的实现思想相同，即在某进程开始访问临界区到结束访问为止都不允许被中断，也就不能发生进程切换，因此也不可能发生两个同时访问临界区的情况)</p> <p>关中断后即不允许当前进程被中断，也必然不会发生进程切换</p> <p>直到当前进程访问完临界区，再执行开中断指令，才有可能有别的进程上处理机并访问临界区</p> <p>通常是在进入临界区前关中断，离开后开中断</p> <p>优点：简单、高效</p> <p>缺点：不适用于多处理机；只适用于操作系统内核进程，不适用于用户进程(因为开/关中断指令只能运行在内核态，这组指令如果让用户随意使用会很危险)</p> <h4 id="testandset">TestAndSet</h4> <p>简称TS指令，也有地方称为TestAndSetLock指令，或TSL指令</p> <p>TSL指令<strong>是用硬件实现的</strong>,执行的过程不允许被中断，只能一气呵成。</p> <p>以下是用C语言描述的逻辑</p> <p><img src="https://b.1wind.cn/2025/08/df552cfea0f1ac8e3b96de424aa953b6.png" alt="image-20250816145451220"></p> <p>优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞；适用于多处理机环境</p> <p>缺点：不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”</p> <h4 id="swap指令">Swap指令</h4> <p>有的地方也叫Exchange指令，或简称XCHG指令</p> <p>Swap指令<strong>是用硬件实现的</strong>，执行的过程不允许被中断，只能一气呵成。</p> <p>以下是用C语言描述的逻辑</p> <p><img src="https://b.1wind.cn/2025/08/f86d57e500837b8e770d6fb7fbd49013.png" alt="image-20250816145022673"></p> <p>优点：实现简单，无需像软件实现方法那样严格检查是否会有逻辑漏洞；适用于多处理机环境</p> <p>缺点：不满足“让权等待”原则，暂时无法进入临界区的进程会占用CPU并循环执行TSL指令，从而导致“忙等”</p> <h2 id="互斥锁">互斥锁</h2> <p>解决临界区最简单的工具就是<strong>互斥锁(mutex lock)</strong>。一个进程在进入临界区时应获得锁；在退出临界区时释放锁。函数acquire()获得锁，而函数release()释放锁。</p> <p>每个互斥锁都有一个布尔变量available，表示锁是否可用。如果锁是可用的，调用acquire()会成功，且锁不再可用。当一个进程试图获取不可用的锁时，会被阻塞，直到锁被释放。</p> <div class="expressive-code"><link rel="stylesheet" href="/_astro/ec.zq8gl.css"><script type="module" src="/_astro/ec.8zarh.js"></script><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">acquire</span><span style="--0:#256F74;--1:#89DDFF">()</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#5A676D;--1:#EEFFFF">available</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 忙等待</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">available </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 获得锁</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">release</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">available </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 释放锁</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="acquire() while(!available) ; // 忙等待 available = false; // 获得锁release(){ available = true; // 释放锁}"><div></div></button></div></figure></div> <p>acquire()或release()的执行必须是原子操作，因此互斥锁通常采用硬件机制来实现</p> <p><strong>互斥锁</strong>的主要缺点是<strong>忙等待</strong>，当有一个进程在临界区时，任何其他进程在进入临界区时必须连续循环调用acquire()。当多个进程共享同一CPU时，就浪费了CPU周期。因此，互斥锁通常用于多处理器系统，一个线程可以在一个处理器上等待，不影响其他线程的执行</p> <p>需要连续循环忙等待的互斥锁，都可称为自旋锁(spin lock)，如TSL指令、swap指令、单标志法</p> <p>特性：</p> <ul> <li>需忙等待，进程时间片用完才下处理机，违反“让权等待”</li> <li>优点：等待期间不用切换进程上下文，多处理器系统中，若上锁的时间短，则等待代价很低</li> <li>常用于多处理器系统，一个核忙等，其他核照常工作，并快速释放临界区</li> <li>不太适用于单处理机系统，忙等的过程中不可能解锁</li> </ul> <h1 id="信号量机制">信号量机制</h1> <h2 id="概念-9">概念</h2> <p>用户进程可以通过使用操作系统提供的<strong>一对原语</strong>来对<strong>信号量</strong>进行操作，从而很方便的实现了进程互斥、进程同步</p> <p><strong>信号量</strong>其实就是一个变量(<strong>可以是一个整数，也可以是更复杂的记录型变量</strong>)，可以用一个信号量来<strong>表示系统中某种资源的数量</strong>，比如：系统中只有一台打印机，就可以设置一个初值为1的信号量。</p> <p><strong>原语</strong>是一种特殊的程序段，其<strong>执行只能一气呵成，不可被中断</strong>。原语是<strong>由关中断/开中断指令</strong>实现的。软件解决方案的主要问题是“进入区的各种操作无法一气呵成”，因此如果能把进入区、退出区的操作都用“原语”实现，使这些操作能“一气呵成”就能避免问题</p> <p><strong>一对原语：wait(S)原语和signal(S)原语</strong>，可以把原语理解为我们自己写的函数，函数名分别为wait和signal，括号内的信号量S其实就是函数调用时传入的一个参数</p> <p>wait、signal原语常<strong>简称为P、V操作</strong>(来自荷兰语proberen和verhogen)。因此，做题的时候常把wait(S)、signal(S)两个操作分别写为<strong>P(S)、V(S)</strong></p> <h2 id="整型信号量">整型信号量</h2> <p>用一个整数型变量作为信号量，用来表示系统中某种资源的数量。</p> <p>与普通整数变量的区别：</p> <ul> <li>对信号量的操作只有三种，即初始化、P操作、V操作</li> </ul> <p>示例如下</p> <p><img src="https://b.1wind.cn/2025/08/37db878add0f80e0d4c49a49249d75ae.png" alt="image-20250816163320794"></p> <h2 id="记录型信号量">记录型信号量</h2> <p>整型信号量的缺陷是存在“忙等”问题，因此人们又提出了“记录型信号量”，即用记录型数据结构表示的信号量</p> <p>示例如下</p> <p><img src="https://b.1wind.cn/2025/08/c4f9f9204e9017d541b4c69fe02f8b31.png" alt="image-20250816163909397"></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 记录型信号量的定义</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> value</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 剩余资源数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">Struct process </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 等待队列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 某进程需要使用资源时，通过wait 原语申请</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">wait</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">semaphore </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">value</span><span style="--0:#256F74;--1:#89DDFF">--;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">value</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">block</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 进程使用完资源后，通过signal 原语释放</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">signal</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">semaphore </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">value</span><span style="--0:#256F74;--1:#89DDFF">++;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">value</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">wakeup</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 记录型信号量的定义typedef struct{ int value; // 剩余资源数 Struct process *L; // 等待队列}// 某进程需要使用资源时，通过wait 原语申请void wait(semaphore S){ S.value--; if(S.value < 0){ block(S.L) }}// 进程使用完资源后，通过signal 原语释放void signal(semaphore S){ S.value++; if(S.value <= 0){ wakeup(S.L); }}"><div></div></button></div></figure></div> <p>在考研题目中wait(S)、signal(S)也可以记为P(S)、V(S)，这对原语可用于实现系统资源的“申请”和“释放”</p> <p><strong>S.value的初值</strong>表示系统中<strong>某种资源的数目</strong></p> <p>对信号量S的<strong>一次P操作</strong>意味着进程<strong>请求一个单位的该类资源</strong>,因此需要执行S.value—，表示资源数减1，当S.value&#x3C;0时表示该类资源已分配完毕，因此进程应<strong>调用block原语进行自我阻塞</strong>(当前运行的进程从<strong>运行态->阻塞态</strong>)，主动放弃处理机，并插入该类资源的等待队列S.L中。可见，该机制<strong>遵循了“让权等待”原则</strong>，不会出现“忙等”现象</p> <p>对信号量S的<strong>一次V</strong>操作意味着进程<strong>释放一个单位的该类资源</strong>，因此需要执行S.value++，表示资源数加1，若加1后仍是S.value&#x3C;=0，表示依然有进程在等待该类资源，因此<strong>应调用wakeup原语唤醒等待队列中的第一个进程</strong>(被唤醒进程从<strong>阻塞态->就绪态</strong>)</p> <h2 id="实现进程互斥">实现进程互斥</h2> <ol> <li>分析并发进程的关键活动，划定临界区(如：对临界资源打印机的访问就应该放在临界区)</li> <li>设置<strong>互斥信号量</strong>mutex，<strong>初值为1</strong></li> <li>在进入区P(mutex)---<strong>申请资源</strong></li> <li>在退出区V(mutex)---<strong>释放资源</strong></li> </ol> <p>代码示例如下</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> value</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 剩余资源数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> process </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 等待队列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">semaphore</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 信号量机制实现互斥</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore mutex </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化信号量</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">P1</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 使用临界资源前需要加锁</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">临界资源代码段</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 使用临界资源后需要解锁</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">P2</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 使用临界资源前需要加锁</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">临界资源代码段</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 使用临界资源后需要解锁</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct{ int value; // 剩余资源数 struct process *L; // 等待队列}semaphore;// 信号量机制实现互斥semaphore mutex = 1; // 初始化信号量P1(){ P(mutex); // 使用临界资源前需要加锁 临界资源代码段 V(mutex); // 使用临界资源后需要解锁}P2(){ P(mutex); // 使用临界资源前需要加锁 临界资源代码段 V(mutex); // 使用临界资源后需要解锁}"><div></div></button></div></figure></div> <p>注意：<strong>对不同的临界资源需要设置不同的互斥信号量</strong></p> <p>P、V操作必须成对出现。缺少P(mutex)就不能保证临界资源的互斥访问。缺少V(mutex)会导致资源永不被释放，等待进程永不被唤醒</p> <h2 id="实现进程同步">实现进程同步</h2> <p>进程同步：要让各并发进程按要求有序地推进</p> <p>基于信号量实现进程同步，示例如下</p> <ol> <li>分析什么地方需要实现“同步关系”，即必须保证“一前一后”执行的两个操作(或两句代码)</li> <li>设置<strong>同步信号量</strong>S，<strong>初始为0</strong></li> <li>在前操作之后执行V(S)</li> <li>在后操作之前执行P(S)</li> </ol> <p>口诀：前V后P</p> <p><img src="https://b.1wind.cn/2025/08/6a02a00a984341470c4a9bb008fbc0a8.png" alt="image-20250817143629145"></p> <h2 id="实现前驱关系">实现前驱关系</h2> <p>其实每一对前驱关系都是一个进程同步问题(需要保证一前一后的操作)</p> <p>因此，</p> <ol> <li><strong>要为每一对前驱关系各设置一个同步信号量</strong></li> <li><strong>在“前操作”之后对相应的同步信号量执行V操作</strong></li> <li><strong>在“后操作”之前对相应的同步信号量执行P操作</strong></li> </ol> <h1 id="生产者-消费者">生产者-消费者</h1> <p>系统中有一组生产者进程和一组消费者进程，生产者进程每次生产一个产品放入缓冲区，消费者进程每次从缓冲区取出一个产品并使用。(注：这里的“产品”理解为某种数据)</p> <p>生产者、消费者共享一个初始为空、大小为n的缓冲区</p> <p>只有缓冲区没满时(生产者生产)，生产者才能把产品放入缓冲区，否则必须等待</p> <p>只有缓冲区不空时(消费者消费)，消费者才能从中取出产品，否则必须等待</p> <p>缓冲区是临界资源，各进程必须互斥访问(互斥关系)</p> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/08/04e5ce114cfbfc2bb48671fbaf8af392.png" alt="image-20250817161413295"></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore mutex </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 缓冲区互斥信号量</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore empty </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> n</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 缓冲区空闲位置数量</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore full </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 缓冲区物品数量</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">Process </span><span style="--0:#4C6690;--1:#82AAFF">producer</span><span style="--0:#256F74;--1:#89DDFF">()</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">生产一个物品</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">empty</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 请求缓冲区一个空位</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">往缓冲区中放入一个物品</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">full</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 缓冲区物品数量加一</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">Process </span><span style="--0:#4C6690;--1:#82AAFF">consumer</span><span style="--0:#256F74;--1:#89DDFF">()</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">full</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 请求缓冲区一个物品</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">从缓冲区中取出一个物品</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">empty</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 缓冲区空位数量加一</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">消费一个物品</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="semaphore mutex = 1; // 缓冲区互斥信号量semaphore empty = n; // 缓冲区空闲位置数量semaphore full = 0; // 缓冲区物品数量Process producer() { while(1) { 生产一个物品; P(empty); // 请求缓冲区一个空位 P(mutex); 往缓冲区中放入一个物品; V(mutex); V(full); // 缓冲区物品数量加一 }}Process consumer() { while(1) { P(full); // 请求缓冲区一个物品 P(mutex); 从缓冲区中取出一个物品; V(mutex); V(empty); // 缓冲区空位数量加一 消费一个物品; }}"><div></div></button></div></figure></div> <h1 id="多生产者-多消费者">多生产者-多消费者</h1> <p>桌子上有一只盘子，每次只能向其中放入一只水果。爸爸专向盘子中放苹果，妈妈专向盘子中放橘子，儿子专等着吃盘子中的橘子，女儿专等着吃盘子中的苹果。只有盘子空时，爸爸或妈妈才可向盘子中放一个水果。仅当盘子中有自己需要的水果时，儿子或女儿可以从盘子中取出水果。用PV操作实现上述过程。<img src="C:/Users/Administrator/AppData/Roaming/Typora/typora-user-images/image-20250818094106023.png" alt="image-20250818094106023"></p> <p>具体情况如上图所示</p> <p>互斥关系：</p> <p>对缓冲区(盘子)的访问要互斥的进行</p> <p>同步关系(一前一后)：</p> <ol> <li>父亲将苹果放入盘子后，女儿才能取苹果</li> <li>母亲将橘子放入盘子后，儿子才能取橘子</li> <li>只有<strong>盘子为空</strong>时，<strong>父亲或母亲</strong>才能放入水果</li> </ol> <p>盘子为空这个事件可以由儿子或女儿触发，事件发生后才允许父亲或母亲放水果</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semahore mutex </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 实现互斥访问盘子(缓冲区)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore apple </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 盘子中有几个苹果</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore orange </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 盘子中有几个橘子</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore plate </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 盘子中还可以放多少个水果</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">dad</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">准备一个苹果</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">plate</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">把苹果放入盘子</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">apple</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">mom</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">准备一个橘子</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">plate</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">把橘子放入盘子</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">orange</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">26</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">27</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">28</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">daughter</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">29</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">30</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">apple</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">31</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">32</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">从盘中取出苹果</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">33</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">34</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">plate</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">35</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">吃掉苹果</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">36</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">37</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">38</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">39</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">son</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">40</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">41</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">orange</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">42</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">43</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">从盘中取出橘子</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">44</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">45</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">plate</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">46</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">吃掉橘子</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">47</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">48</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="semahore mutex = 1; // 实现互斥访问盘子(缓冲区)semaphore apple = 0; // 盘子中有几个苹果semaphore orange = 0; // 盘子中有几个橘子semaphore plate = 1; // 盘子中还可以放多少个水果dad (){ while(1){ 准备一个苹果 P(plate); P(mutex); 把苹果放入盘子; V(mutex); V(apple); }}mom (){ while(1){ 准备一个橘子 P(plate); P(mutex); 把橘子放入盘子; V(mutex); V(orange); }}daughter (){ while(1){ P(apple); P(mutex); 从盘中取出苹果; V(mutex); V(plate); 吃掉苹果; }}son (){ while(1){ P(orange); P(mutex); 从盘中取出橘子; V(mutex); V(plate); 吃掉橘子; }}"><div></div></button></div></figure></div> <p>当然，这里也可以不设置互斥信号量，因为此处的信号量，至多只有一个是为1的，用完了就会唤醒其他的</p> <p>比如说：父亲进程先上来，它准备了一个苹果，然后放入盘子，此刻改变了盘子的值，接着释放了苹果的信号量，让吃苹果的来进行消费，此时苹果会被吃掉，因为之前父亲最后执行了P操作，接着释放掉盘子，让父亲或母亲继续放水果，而在这期间，并没有额外的增长其他的信号量，只有被消费的苹果和被重新生产的盘子</p> <p>在生产者-消费者问题中，如果缓冲区为1，那么有可能不需要设置互斥信号量就可以实现互斥访问缓冲区的功能。得看情况分析</p> <h1 id="读者-写者">读者-写者</h1> <p>有读者和写者两组并发进程，共享一个文件，当两个或两个以上的度进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程(读进程或写进程)同时访问共享数据时则可能导致数据不一致的错误。因此要求：</p> <ol> <li>允许多个读者可以同时对文件执行读操作</li> <li>只允许一个写者往文件中写信息</li> <li>任一写者在完成写操作之前不允许其他读者或写者工作</li> <li>写者执行写操作前，应让已有的读者和写者全部退出</li> </ol> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore rw </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 用于实现对共享文件的互斥访问</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> count </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 记录当前有几个读进程在访问文件</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore mutex </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 用于保证对count变量的互斥访问</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">semaphore w </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 用于实现写优先</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">writer</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">rw</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">写文件</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">rw</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">reader</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">count </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">rw</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">count</span><span style="--0:#256F74;--1:#89DDFF">++;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">读文件</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">26</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">P</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">27</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">count</span><span style="--0:#256F74;--1:#89DDFF">--;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">28</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">count</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">29</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">rw</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">30</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">V</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">mutex</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">31</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">32</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="semaphore rw = 1; // 用于实现对共享文件的互斥访问int count = 0; // 记录当前有几个读进程在访问文件semaphore mutex = 1; // 用于保证对count变量的互斥访问semaphore w = 1; // 用于实现写优先writer(){ while(1){ P(w); P(rw); 写文件 V(rw); V(w); }}reader(){ while(1){ P(w); P(mutex); if(count == 0) P(rw); count++; V(mutex); V(w); 读文件 P(mutex); count--; if(count==0) V(rw); V(mutex); }}"><div></div></button></div></figure></div> <p>在这种算法中，连续进入的多个读者可以同时读文件；写者和其他进程不能同时访问文件；写者不会饥饿，但也不少真正的写优先，而是相对公平的先来先服务原则，这种算法称为<strong>读写公平法</strong></p> <h1 id="哲学者进餐">哲学者进餐</h1> <p>一张圆桌上坐着5名哲学家，每两个哲学家之间的桌上摆着一根筷子，桌子的中间是一碗米饭。哲学家们倾注毕生的精力用于思考和进餐，哲学家在思考时，并不影响他人。只有当哲学家饥饿时，才试图拿起左、右两根筷子(一根一根地拿起)。如果筷子已在他人手上，则需等待。饥饿的哲学家只有同时拿起两根筷子才可以开始进餐，当进餐完毕后，放下筷子继续思考。</p> <p>而5位哲学家对中间的筷子必然是互斥关系，当5位哲学家都各自持有一根筷子时，就会出现死锁问题</p> <p>如何防止死锁的发生呢？</p> <ol> <li>可以对哲学家进餐施加一些限制条件，比如最多允许四个哲学家同时进餐。这样可以保证至少有应该哲学家是可以拿到左右两只筷子的</li> <li>要求奇数号哲学家先拿左边的筷子，然后再拿右边的筷子，而偶数号哲学家刚好相反。用这种方法可以保证如果相邻的两个奇偶号哲学家都想吃饭，那么只会有其中一个可以拿起第一只筷子，另一个会直接阻塞。这就避免了占有一支后再等待另一只的情况</li> <li>各哲学家拿筷子这件事必须互斥地执行。这就保证了即使一个哲学家在拿筷子拿到一半时被阻塞，也不会有别的哲学家会继续尝试拿筷子。这样的话，正在吃饭的哲学家放下筷子后，被阻塞的哲学家就可以获得等待的筷子了</li> </ol> <h1 id="管程">管程</h1> <h2 id="概念-10">概念</h2> <p>管程是一种特殊的软件模块，由这些部分组成：</p> <ol> <li>局部于管程的<strong>共享数据结构</strong>说明</li> <li>对该数据结构进行操作的<strong>一组过程</strong></li> <li>对局部于管程的共享数据设置初始值的语句</li> <li>管程有应该名字</li> </ol> <p><strong>过程其实就是函数</strong></p> <p><strong>管程的基本特征</strong></p> <ol> <li>局部于管程的数据只能被局部于管程的过程所访问</li> <li>一个进程只有通过管程内的过程才能进入管程访问共享数据</li> <li>每次仅允许一个进程在管程内执行某个内部过程</li> </ol> <h1 id="死锁">死锁</h1> <h2 id="概念-11">概念</h2> <p>每个人都占有一个资源，同时又在等待另一个人手里的资源。发生“死锁”</p> <p>在并发环境下，各进程因竞争资源而造成的一种<u>互相等待对方手里的资源，导致各进程都阻塞，都无法向前推进</u>的现象，就是死锁。发生死锁后若无外力干涉，这些进程都将无法向前推进</p> <p>饥饿：由于长期得不到想要的资源，某进程无法向前推进的现象。比如：在短进程优先(SPF)算法中，若有源源不断的短进程到来，则长进程将一直得不到处理机，从而发生长进程“饥饿”</p> <p>死循环：某进程设计过程中一直跳不出某个循环的现象。有时是因为程序逻辑bug导致的，有时是程序员故意设计的</p> <table><thead><tr><th></th><th>共同点</th><th>区别</th></tr></thead><tbody><tr><td>死锁</td><td>都是进程无法顺利向前推进的现象(故意设计的死循环除外)</td><td>死锁一定是“循环等待对方手里的资源”导致的，因此如果有死锁现象，那么<strong>至少有两个或两个以上的进程同时发生死锁</strong>。另外，发生死锁的进程一定处于阻塞态</td></tr><tr><td>饥饿</td><td></td><td>可能只有一个进程发生饥饿。发生饥饿的进程既可能是阻塞态(如长期得不到需要的I/O设备)，也可能是就绪态(长期得不到处理机)</td></tr><tr><td>死循环</td><td></td><td>可能只有一个进程发生死循环。死循环的进程可以上处理机运行(可以是运行态)，只不过无法像期待的那样顺利推进。死锁和饥饿问题是由操作系统分配资源的策略不合理导致的，而死循环是由代码逻辑的错误导致的。<strong>死锁和饥饿是管理者(操作系统)的问题，死循环是被管理者的问题</strong></td></tr></tbody></table> <p><strong>死锁产生的必要条件</strong></p> <ul> <li><strong>互斥条件</strong>：只有对必须互斥使用的资源的争抢才会导致死锁(如哲学家的筷子、打印机设备)。像内存、扬声器这样可以同时让多个进程使用的资源是不会导致死锁的(因为进程不用阻塞等待这种资源)</li> <li><strong>不剥夺条件</strong>：进程所获得的资源在未使用完之前，<strong>不能由其他进程强行夺走</strong>，只能主动释放</li> <li><strong>请求和保持条件</strong>：进程<strong>已经保持了至少一个资源</strong>,但又提出了新的资源<strong>请求</strong>，而该资源又被其他进程占有，此时请求进程被阻塞，但又对自己已有的资源<strong>保持</strong>不放</li> <li><strong>循环等待条件</strong>：存在一种进程<strong>资源的循环等待链</strong>，链中的每一个进程已获得的资源同时被下一个进程所请求</li> </ul> <p><strong>注意！发生死锁时一定有循环等待，但是发生循环等待时未必死锁</strong>(循环等待是死锁的必要不充分条件)</p> <p><strong>如果同类资源数大于1</strong>，则即使有循环等待，也未必发生死锁。但如果系统中每类资源都<strong>只有一个</strong>，那循环等待就是死锁的充分必要条件了</p> <h2 id="处理策略">处理策略</h2> <h3 id="预防死锁">预防死锁</h3> <h4 id="破坏互斥条件"><strong>破坏互斥条件</strong></h4> <p><strong>互斥条件</strong>：只有对必须互斥使用的资源的争抢才会导致死锁</p> <p>如果把只能互斥使用的资源改造为允许共享使用，则系统不会进入死锁状态。比如:<strong>SPOOLing技术</strong>。</p> <p>操作系统可以采用SPOOLing技术把独占设备在逻辑上改造成共享设备。比如，用SPOOLing技术将打印机改造为共享设备</p> <p>该策略的<strong>缺点</strong>：并不是所有的资源都可以改造成可共享使用的资源。并且为了系统安全，很多地方还必须保护这种互斥性。因此，<strong>很多时候都无法破坏互斥条件</strong></p> <h4 id="破坏不剥夺条件"><strong>破坏不剥夺条件</strong></h4> <p><strong>不剥夺条件</strong>：进程所获得的资源在未使用完之前，不能由其他进程强行夺走，只能主动释放</p> <p>破坏不剥夺条件：</p> <p>方案一：当某个进程请求新的资源得不到满足时，它必须立即释放保持的所有资源，待以后需要时再重新申请。也就是说，即使某些资源未使用完，也需要主动释放，从而破坏了不可剥夺条件</p> <p>方案二：当某个进程需要的资源被其他进程所占有的时候，可以由操作系统协助，将想要的资源强行剥夺。这种方式一般需要考虑各进程的优先级(比如：剥夺调度方式，就是将处理机资源强行剥夺给优先级更高的进程使用)</p> <p>该策略的<strong>缺点</strong>：</p> <ol> <li>实现起来比较复杂</li> <li>释放已获得的资源可能造成前一阶段工作的失效。因此这种方法一般只适用于易保存和恢复状态的资源，如CPU</li> <li>反复地申请和释放资源会增加系统开销，降低系统吞吐量</li> <li>若采用方案一，意味着只要暂时得不到某个资源，之前获得的那些资源就都需要放弃，以后再重新申请。如果一直发生这样的情况，就会导致进程饥饿</li> </ol> <h4 id="破坏请求和保持条件">破坏请求和保持条件</h4> <p><strong>请求和保持条件</strong>：进程<strong>已经保持了至少一个资源</strong>,但又提出了新的资源<strong>请求</strong>，而该资源又被其他进程占有，此时请求进程被阻塞，但又对自己已有的资源<strong>保持</strong>不放</p> <p>可以<strong>采用静态分配方法</strong>，即进程在运行前一次申请完它所需要的全部资源，在它的资源未满足前，不让它投入运行。一旦投入运行后，这些资源就一直归它所有，该进程就不会请求别的任何资源了</p> <p>该策略实现起来简单，但也有明显的<strong>缺点</strong>：</p> <p>有些资源可能只需要用很短的时间，因此如果进程的整个运行期间都保持着所有资源，就会造成严重的资源浪费，<strong>资源利用率低</strong>。另外，该策略也有<strong>可能导致某些进程饥饿</strong></p> <h4 id="破坏循环等待条件">破坏循环等待条件</h4> <p><strong>循环等待条件</strong>：存在一种进程<strong>资源的循环等待链</strong>,链中的每一个进程已获得的资源同时被下一个进程所请求。</p> <p>可采用<strong>顺序资源分配法</strong>.首先给系统中的资源编号，规定每个进程<strong>必须按编号递增的顺序请求资源</strong>,同类资源(即编号相同的资源)一次申请完</p> <p>原理分析：一个进程只有已占有小编号的资源时，才有资格申请更大编号的资源。按此规则，已持有大编号资源的进程不可能逆向地回来申请小编号的资源，从而就不会产生循环等待的现象</p> <p>该策略的<strong>缺点</strong>：</p> <ol> <li>不方便增加新的设备，因为可能需要重新分配所有的编号</li> <li>进程实际使用的资源的顺序可能和编号递增顺序不一致，会导致资源浪费</li> </ol> <h3 id="避免死锁">避免死锁</h3> <h4 id="安全序列">安全序列</h4> <p>所谓<strong>安全序列</strong>，就是指如果系统按照这种序列分配资源，则每个进程都能顺利完成。只要能找出一个安全序列，系统就是<strong>安全状态</strong>。当然，安全序列可能有多个。</p> <p>如果分配了资源之后，系统中找不出任何一个安全序列，系统就进入了<strong>不安全状态</strong>。这就意味着之后<strong>可能</strong>所有进程都无法顺利的执行下去。当然，如果有进程提前归还了一些资源，那<strong>系统也有可能重新回到安全状态</strong>，不过我们在分配资源之前总是要考虑到最坏的情况</p> <p>如果系统处于<strong>安全状态</strong>，就<strong>一定不会</strong>发生<strong>死锁</strong>。如果系统进入<strong>不安全状态</strong>，就<strong>可能</strong>发生<strong>死锁</strong>(处于不安全状态未必就是发生了死锁，但发生死锁时一定是在不安全状态)</p> <p>因此可以<strong>在资源分配之前先判断这次分配是否会导致系统进入不安全状态</strong>，以此决定是否答应资源分配请求。这也是“<strong>银行家算法</strong>”的核心思想</p> <p>核心思想：在进程提出资源申请时，先预判这次分配是否会导致系统进入不安全状态。如果会进入不安全状态，就暂时不答应这次请求，让该进程先阻塞等待</p> <h3 id="检测和解除">检测和解除</h3> <ol> <li>死锁检测算法：用于检测系统状态，以确定系统中是否发生了死锁</li> <li>死锁解除算法：当认定系统中已经发生了死锁，利用该算法可将系统从死锁状态中解脱出来</li> </ol> <p>看视频吧，这章讲的比较抽象：<a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=42">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=42</a></p> <p>解除死锁的主要方法有：</p> <ol> <li><strong>资源剥夺法</strong>。挂起(暂时放到外存上)某些死锁进程，并抢占它的资源，将这些资源分配给其他的死锁进程。但是应防止被挂起的进程长时间得不到资源而饥饿</li> <li><strong>撤销进程法</strong>(或<strong>终止进程法</strong>)。强制撤销部分、甚至全部死锁进程，并剥夺这些进程的资源。这种方式的优点是实现简单，但所付出的代价可能会很大。因为有些进程可能已经运行了很长时间，已经接近结束了，一旦被终止可谓功亏一篑，以后还得从头再来</li> <li><strong>进程回退法</strong>。让一个或多个死锁进程回退到足以避免死锁的地步。这就要求系统要记录进程的历史信息，设置还原点</li> </ol> <p>如何决定“对谁动手”</p> <ol> <li>进程优先级</li> <li>已执行多长时间</li> <li>还要多久能完成</li> <li>进程已经使用了多少资源</li> <li>进程是交互式的还是批处理式的</li> </ol> <h1 id="内存">内存</h1> <h2 id="基础知识">基础知识</h2> <p>内存可存放数据。程序执行前<strong>需要放到内存中才能被CPU处理</strong>---缓和CPU与硬盘之间的速度矛盾</p> <p>思考：在多道程序环境下，系统中会有多个程序并发执行，也就是说会有多个程序的数据需要同时放到内存中。那么，如何区分各个程序的数据是放在什么地方的呢？</p> <p>方案：给内存的单元编地址</p> <p>内存中也有一个一个的“小房间”，每个小房间就是一个“<strong>存储单位</strong>”</p> <p>如果计算机“<strong>按字节编址</strong>”，则<strong>每个存储单元大小</strong>为<strong>1字节</strong>，即1B，即8个二进制位</p> <p>如果<strong>字长位16位</strong>的计算机“<strong>按字编址</strong>”，则<strong>每个存储单位大小</strong>为<strong>1个字</strong>；每个字的大小为16个二进制位</p> <h2 id="绝对装入">绝对装入</h2> <p><strong>绝对装入</strong>：在编译时，如果知道程序将放到内存中的哪个位置，编译程序将产生绝对地址的目标代码。装入程序按照装入模块中的地址，将程序和数据装入内存</p> <p>编译、链接后得到的装入模块的指令直接就使用了绝对地址</p> <p>绝对装入<strong>只适用于单道程序环境</strong></p> <h2 id="可重定位装入">可重定位装入</h2> <p><strong>静态重定位</strong>：又称<strong>可重定位装入</strong>。编译、链接后的装入模块的地址都是从0开始的，指令中使用的地址、数据存放的地址都是相当于起始地址而言的逻辑地址。可根据内存的当前情况，将装入模块装入到内存的适当位置。装入时对地址进行“<strong>重定位</strong>”，将逻辑地址变为物理地址(地址变换是在装入时一次完成的)</p> <p>静态重定位的特点是在一个作业装入内存时，<strong>必须分配其要求的全部内存空间</strong>，如果没有足够的内存，就不能装入该作业</p> <h2 id="动态重定位">动态重定位</h2> <p><strong>动态重定位</strong>：又称<strong>动态运行时装入</strong>。编译、链接后的装入模块的地址都是从0开始的。装入程序把装入模块装入内存后，并不会立即把逻辑地址转换为物理地址，而是<strong>把地址转换推迟到程序真正要执行时才进行</strong>。因此装入内存后所有的地址依然是逻辑地址。这种方式需要一个<strong>重定位寄存器</strong>的支持</p> <p>并且这种方法可以将程序分配到不连续的存储区中；在程序运行前只需装入它的部分代码即可投入运行，然后在程序运行期间，根据需要动态申请分配内存；便于程序段的共享，可以向用户提供一个比存储空间大得多的地址空间</p> <p>采用动态重定位时<strong>允许程序在内存中发生移动</strong></p> <h2 id="链接的三种方式">链接的三种方式</h2> <ol> <li>静态链接：在程序运行之前，先将各目标模块及它们所需的库函数连接成一个完整的可执行文件(装入模块)，之后不再拆开</li> <li>装入时动态链接：将各目标模块装入内存时，边装入边链接的链接方式</li> <li>运行时动态链接：在程序执行中需要该目标模块时，才对它进行链接。其优点是便于修改和更新，便于实现对目标模块的共享</li> </ol> <h2 id="内存管理">内存管理</h2> <p>操作系统作为系统资源的管理者，也需要对内存进行管理，具体要管什么呢？</p> <ol> <li>操作系统负责<strong>内存空间的分配与回收</strong></li> <li>操作系统需要提供某种技术从逻辑上<strong>对内存空间进行扩充</strong></li> <li>操作系统需要提供地址转换功能，负责程序的<strong>逻辑地址</strong>与<strong>物理地址</strong>的转换</li> <li>操作系统需要提供<strong>内存保护</strong>功能。保证各进程在各自存储空间内运行，互不干扰</li> </ol> <p>内存保护可采用两种方法：</p> <ol> <li>在CPU中设置一对上、下限寄存器，存放进程的上、下限地址。进程的指令要访问某个地址时，CPU检查是否越界</li> <li>采用<strong>重定位寄存器</strong>(又称<strong>基址寄存器</strong>)和<strong>界地址寄存器</strong>(又称<strong>限长寄存器</strong>)进行越界检查。重定位寄存器存放的是进程的<strong>起始物理地址</strong>。界地址寄存器中存放的是进程的<strong>最大逻辑地址</strong></li> </ol> <h2 id="进程的内存映像">进程的内存映像</h2> <p>具体情况如图所示</p> <p><img src="https://b.1wind.cn/2025/08/902faf3b8e381276f7eac90de5675c91.png" alt="image-20250819141755796"></p> <h2 id="覆盖">覆盖</h2> <p>早期的计算机内存很小，比如IBM推出的第一台PC机最大只支持1MB大小的内存。因此经常会出现内存大小不够的情况</p> <p>后来人们引入了<strong>覆盖技术</strong>，用来解决“<strong>程序大小超过物理内存总和”的问题</strong></p> <p>覆盖技术的思想：将<strong>程序分为多个段</strong>(多个模块)。</p> <p>常用的段常驻内存，不常用的段在需要时调入内存</p> <p>内存中分为<strong>一个“固定区”<strong>和</strong>若干个“覆盖区”</strong></p> <p>需要常驻内存的段放在“<strong>固定区</strong>”中，<strong>调入后就不再调出</strong>(除非运行结束)</p> <p>不常用的段放在“<strong>覆盖区</strong>”，<strong>需要用到时调入内存</strong>，<strong>用不到时调出内存</strong></p> <p><strong>覆盖技术如图所示</strong></p> <p><img src="https://b.1wind.cn/2025/08/216d4314a60d4f493d39335c0dd8f741.png" alt="image-20250819142805408"></p> <p><strong>必须由程序员声明覆盖结构</strong>，操作系统完成自动覆盖。</p> <p>缺点：<strong>对用户不透明</strong>，增加了用户编程负担。</p> <p>覆盖技术只用于早期的操作系统中，现在已成为历史</p> <h2 id="交换">交换</h2> <p>交换(对换)技术的设计思想：内存空间紧张时，系统将内存中某些进程暂时<strong>换出</strong>外存，把外存中某些已具备运行条件的进程<strong>换入</strong>内存(进程在内存与磁盘间动态调度)</p> <p>那么，也就出现了三个问题</p> <ol> <li>应该在外存(磁盘)的上面位置保存被换出的进程 <ul> <li>具有对换功能的操作系统中，通常把磁盘空间分为<strong>文件区</strong>和<strong>对换区</strong>两部分。<strong>文件区</strong>主要用于存放文件，<strong>主要追求存储空间的利用率</strong>，因此对文件区空间的管理<strong>采用离散分配方式</strong>;<strong>对换区</strong>空间只占磁盘空间的小部分，<strong>被换出的进程数据就存放在对换区</strong>。由于对换的速度直接影响到系统的整体速度，因此对换区空间的管理<strong>主要追求换入换出速度</strong>，因此通常对换区<strong>采用连续分配方式</strong>。总之，对换区I/O速度比文件区更快</li> </ul> </li> <li>什么时候应该交换 <ul> <li>交换通常在许多进程运行且内存吃紧时进行，而系统负荷降低就暂停。例如：在发现许多进程运行时经常发生缺页，说明内存紧张，此时可以换出一些进程；如果缺页率明显下降，就可以暂停换出</li> </ul> </li> <li>应该换出哪些进程 <ul> <li>可以优先换出阻塞进程；可换出优先级低的进程；为了防止优先级低的进程在被调入内存后很快又被换出，有的系统还会考虑进程在内存的驻留时间</li> </ul> </li> </ol> <p><strong>注意：PCB会常驻内存，不会被换出内存</strong></p> <h2 id="连续分配管理方式">连续分配管理方式</h2> <p><strong>连续分配</strong>：指为用户进程分配的必须是一个<strong>连续的内存空间</strong></p> <h3 id="单一连续分配">单一连续分配</h3> <p>在单一连续分配方式中，内存被分为<strong>系统区</strong>和<strong>用户区</strong></p> <p>系统区通常位于内存的低地址部分，用于存放操作系统相关数据；用户区用于存放用户进程相关数据</p> <p>内存中<strong>只能有一道用户程序</strong>，用户程序独占整个用户区空间</p> <p><strong>优点</strong>：实现简单；<strong>无外部碎片</strong>；可以采用覆盖技术扩充内存；不一定需要采取内存保护(eg：早期的PC操作系统MS-DOS)</p> <p><strong>缺点</strong>：只能用于单用户、单任务的操作系统中；有内部碎片(分配给某进程的内存区域中，如果有些部分没有用上，就是“内存碎片”)；存储器利用率极低</p> <h3 id="固定分区分配">固定分区分配</h3> <p>20世纪60年代出现了支持多道程序的系统，为了能在内存中装入多道程序，且这些程序之间又不会相互干扰，于是将整个<strong>用户空间</strong>划分为<strong>若干个固定大小的分区</strong>，<strong>在每个分区中只装入一道作业</strong>，这样就形成了最早的、最简单的一种可运行多道程序的内存管理方式</p> <p>分区大小相等：缺乏灵活性，但是很<strong>适合用于用一台计算机控制多个相同对象的场合</strong>(比如：钢铁厂有n个相同的炼钢炉，就可把内存分为n个大小相等的区域存放n个炼钢炉控制程序)</p> <p>分区大小不等：增加了灵活性，可以满足不同大小的进程需求。根据常在系统中运行的作业大小情况进行划分(比如：划分多个小分区、适量中等分区、少量大分区)</p> <p>如图所示</p> <img src="https://b.1wind.cn/2025/08/cd785681f79595e787afc57b3fcaf3af.png" alt="image-20250819164633438" style="zoom:50%;"> <p>操作系统需要建立一个数据结构---<strong>分区说明表</strong>，来实现各个分区的分配与回收。每个表项对应一个分区，通常按分区大小排序。每个表项包括对应分区的<strong>大小</strong>、<strong>起始地址</strong>、<strong>状态</strong>(是否已分配)</p> <p>当某用户程序要装入内存时，由操作系统内核程序根据用户程序大小检索该表，从中找到一个能满足大小的、未分配的分区，将之分配给该程序，然后修改状态为“已分配”</p> <p>优点：实现简单，<strong>无外部碎片</strong></p> <p>缺点：</p> <ol> <li>当用户程序太大时，可能所有的分区都不能满足需求，此时不得不采用覆盖技术来解决，但这又会降低性能</li> <li><strong>会产生内部碎片</strong>，内存利用率低</li> </ol> <h3 id="动态分区分配">动态分区分配</h3> <p><strong>动态分区分配</strong>又称为可变分区分配。这种分配方式<strong>不会预先划分内存分区</strong>，而是在进程装入内存时，<strong>根据进程的大小动态地建立分区</strong>，并使分区的大小正好适合进程的需要。因此系统分区的大小和数目是可变的</p> <p>但这样又引出了新的问题</p> <ol> <li>系统要用什么样的数据结构记录内存的使用情况 <ul> <li>空闲分区表：每个空闲分区对应一个表项。表项中包含分区号、分区大小、分区起始地址等信息</li> <li>空闲分区链：每个分区的起始部分和末尾部分分别设置前向指针和后向指针。起始部分处还可记录分区大小等信息</li> </ul> </li> <li>当很多个空闲分区都能满足需求时，应选择哪个分区进行分配 <ul> <li>把一个新作业装入内存时，续按照一定的<strong>动态分区分配算法</strong>，从空闲分区表(或空闲分区链)中选出一个分区分配给该作业。由于分配算法对系统性能有很大的影响，因此人们对它进行了广泛的研究</li> </ul> </li> <li>如何进行分区的分配与回收操作？ <ul> <li>相邻空闲分区合并</li> </ul> </li> </ol> <p>动态分区分配<strong>没有内部碎片</strong>，但是<strong>有外部碎片</strong></p> <p><strong>内部碎片</strong>，分配给某进程的内存区域中，如果有些部分没有用上</p> <p><strong>外部碎片</strong>，是指内存中的某些空闲分区由于太小而难以利用</p> <p>如果内存中空闲空间的总和可以满足某进程的要求</p> <p>但由于进程需要的是一整块连续的内存空间，因此这些“碎片”不能满足进程的需求</p> <p>可以通过紧凑(拼凑，Compaction)技术来解决外部碎片</p> <h2 id="动态分区分配算法">动态分区分配算法</h2> <h3 id="首次适应算法">首次适应算法</h3> <p><strong>算法思想</strong>：每次都从低地址开始查找，找到第一个能满足大小的空闲分区</p> <p><strong>如何实现</strong>：<strong>空闲分区以地址递增的次序排列</strong>。每次分配内存时顺序查找<strong>空闲分区链</strong>(或<strong>空闲分区表</strong>)，找到大小能满足要求的第一个空闲分区</p> <h3 id="最佳适应算法">最佳适应算法</h3> <p><strong>算法思想</strong>：由于动态分区分配是一种连续分配方式，为各进程分配的空间必须是连续的一整片区域。因此为了保证当“大进程”到来时能有连续的大片空间，可以尽可能多地留下大片的空闲区，即，优先使用更小的空闲区。</p> <p><strong>如何实现</strong>：空闲分区<strong>按容量递增次序链接</strong>。每次分配内存时顺序查找空闲分区链(或<strong>空闲分区表</strong>)，找到大小能满足要求的第一个空闲分区</p> <p><strong>缺点：每次都选最小的分区进行分配，会留下越来越多的、很小的、难以利用的内存块。因此这种方法会产生很多的外部碎片</strong></p> <h3 id="最坏适应算法">最坏适应算法</h3> <p>又称<strong>最大适应算法</strong>(Largest Fit)</p> <p><strong>算法思想</strong>：为了解决最佳适应算法的问题---即留下太多难以利用的小碎片，可以在每次分配时优先使用最大的连续空闲区，这样分配后剩余的空闲区就不会大小，更方便使用</p> <p><strong>如何实现</strong>：空闲分区<strong>按容量递减次序链接</strong>。每次分配内存时顺序查找空闲分区链(或<strong>空闲分区表</strong>)，找到大小能满足要求的第一个空闲分区</p> <p><strong>缺点：每次都选最大的分区进行分配，虽然可以让分配后留下的空闲区更大，更可用，但是这种方式会导致较大的连续空闲区被迅速用完。如果之后有“大进程”到达，就没有内存分区可用了</strong></p> <h3 id="邻近适应算法">邻近适应算法</h3> <p><strong>算法思想</strong>：首次适应算法每次都从链头开始查找的。这可能会导致低地址不符出现很多小的空闲分区，而每次分配查找时，都要经过这些分区，因此也增加了查找的开销。如果每次都从上次查找结束的位置开始检索，就能解决上述问题</p> <p><strong>如何实现</strong>：空闲分区以地址递增的顺序排列(可排成一个循环链表)。每次分配内存时<strong>从上次查找结束的位置开始</strong>查找<strong>空闲分区链</strong>(或<strong>空闲分区表</strong>)，找到大小能满足要求的第一个空闲分区</p> <h3 id="总结-1">总结</h3> <table><thead><tr><th>算法</th><th>算法思想</th><th>分区排列顺序</th><th>优点</th><th>缺点</th></tr></thead><tbody><tr><td>首次适应</td><td>从头到尾找适合的分区</td><td>空闲分区以地址递增次序排列</td><td>综合看性能最好。算法开销小，回收分区后一般</td><td></td></tr><tr><td>最佳适应</td><td>优先使用更小的分区，以保留更多大分区</td><td>空闲分区以容量递增次序排列</td><td>会有更多大分区被保留下来，更能满足大进程需求</td><td>会产生很多太小的、难以回收的碎片；算法开销大，回收分区后可能需要对空闲分区队列重新排序</td></tr><tr><td>最坏适应</td><td>优先使用更大的分区，以防止产生太小的不可用的碎片</td><td>空闲分区以容量递减次序排列</td><td>可以减少难以利用的小碎片</td><td>大分区容易被用完，不利于大进程；算法开销大(原因同上)</td></tr><tr><td>邻近适应</td><td>由首次适应演变而来，每次从上次查找结束为止开始查找</td><td>空闲分区以地址递增次序排列(可排序成循环链表)</td><td>不用每次都从低地址的小分区开始检索。算法开销小(原因同首次适应)</td><td>会使高地址分区也被用完</td></tr></tbody></table> <h1 id="基本分页存储管理">基本分页存储管理</h1> <h2 id="分页存储">分页存储</h2> <p>将内存空间分为一个个<strong>大小相等的分区</strong>(比如：每个分区4KB)，每个分区就是一个“<strong>页框</strong>”(<strong>页框</strong>=<strong>页帧</strong>=<strong>内存块</strong>=<strong>物理块</strong>=<strong>物理页面</strong>)。每个页框有一个编号，即“<strong>页框号</strong>”(<strong>页框号</strong>=<strong>页帧号</strong>=<strong>内存块号</strong>=<strong>物理块号</strong>=<strong>物理页号</strong>)，页框号<strong>从0开始</strong></p> <p>将<code>进程的逻辑地址空间</code>也分为<strong>与页框大小相等</strong>的一个个部分，每个部分称为一个“<strong>页</strong>”或“<strong>页面</strong>”。每个页面也有一个编号，即“<strong>页号</strong>”，页号也是<strong>从0开始</strong></p> <p>操作系统<strong>以页框为单位为各个进程分配</strong>内存空间。进程的每个页面分部放入一个页框中。也就是说，进程的<strong>页面</strong>与内存的<strong>页框</strong>有一一<strong>对应</strong>的关系</p> <p>各个页面不必连续存放，可以放到不相邻的各个页框中</p> <p>为了能知道进程的每个页面在内存中存放的位置，操作系统要为每个进程建立一张<strong>页表</strong></p> <p>注：页表通常存在PCB(进程控制块)中</p> <ol> <li>一个进程对应一张页表</li> <li>进程的每个页面对应一个页表项</li> <li>每个<strong>页表项</strong>由“页号”和“块号”组成</li> <li>页表记录进程<strong>页面</strong>和实际存放的内存块之间的映射关系</li> </ol> <p>内存块比较容易理解一些，而内存块其实就是刚刚上面提到的页框，后续都以内存块进行讲解</p> <p>针对上述概念，那么就存在一些问题</p> <p><strong>每个页表项占多少字节</strong>？ $$ Eg:假设某系统物理内存大小为4GB，页面大小为4KB，则每个页表项至少应该为多少字节？ \ 内存块大小=页面大小=4KB=4*1KB=2^{12} \ 1KB=1024B=2^{10}B \ 4=2^2 \ 4GB的内存总共会被分为2^{32}/2^{12}=2^{20}个内存块\ 4GB=2^{2} * 1GB= 2^{2} * 1024MB=2^{2} * 1024 * 1024KB=2^{2}<em>2^{10}<em>1024</em>1024</em>1B \ 整合上面的公式\ 2^{2}*2^{10}*2^{10}<em>2^{10}<em>1B=2^{32}B \ 因为内存被分成的块数=总内存除以每页大小 \ 所以内存块数的范围应该是0到2^{20}-1 \ 内存块数至少要用20bit来表示 至少要用3B来表示块号(3</em>8=24bit) $$ 页表中的页号是<strong>隐含</strong>的，即<strong>页号不占用存储空间</strong>，因此如上题所示，每个页表项占3B，存储整个页表至少需要3</em>(n+1)B</p> <p>这里的n+1是因为页号是从0开始的，所以需要+1</p> <p>注意：页表记录的至少内存块号，而不是内存块的起始地址！</p> <p><strong>J号内存块的起始地址=J*内存块大小</strong></p> <p><strong>如何实现地址的转换</strong>？</p> <ul> <li>进程在内存中<strong>连续存放时</strong>，操作系统是如何实现逻辑地址到物理地址的转换的？ <ul> <li>重定位寄存器中指明了进程在内存中的<strong>起始位置</strong>,通常是通过目标逻辑地址与起始地址相加，就可以得到物理地址(绝对地址)了</li> <li>逻辑地址：相对于起始位置的<strong>偏移量</strong></li> </ul> </li> <li>将进程地址空间<strong>分页</strong>之后，操作系统是如何实现逻辑地址到物理地址的转换的？ <ul> <li>虽然进程的各个页面是离散存放的，但是页面内部是连续存放的</li> <li>如果要访问逻辑地址A，则 <ol> <li>确定逻辑地址A对应的“<strong>页号</strong>”P</li> <li>找到P号页面在内存中的起始地址(需要查页表)</li> <li>确定逻辑地址A的“<strong>页内偏移量</strong>”W</li> </ol> </li> <li>逻辑地址A对应的物理地址=P号页面在内存中的起始地址+页内偏移量W</li> </ul> </li> </ul> <p><strong>如何确定一个逻辑地址对应的页号、页内偏移量</strong></p> <p>Eg：在某计算机系统中，页面大小是50B。某进程逻辑地址空间大小为200B，则逻辑地址110对应的页号、页内偏移量是多少？</p> <p>已知进程空间大小为200，页面大小为50，那么可以分为4个页面</p> <p>页号=逻辑地址/页面长度(取除法的整数部分)=110/50=2</p> <p>页内偏移量=逻辑地址%页面长度(取除法的余数部分)=110%50=10</p> <p><strong>逻辑地址</strong>可拆分为(<strong>页号，页内偏移量</strong>)</p> <p>通过页号查询页表，可知页面在内存中的起始地址</p> <p>页面在内存中的起始地址+页内偏移量=实际的物理地址</p> <p>在计算机内部，地址是用二进制表示的，如果<strong>页面大小</strong>刚好是<strong>2的整数幂</strong>，则计算机硬件可以很快速的把逻辑地址拆分成(页号，页内偏移量) $$ 结论：如果每个页面大小为2^{K}B,用二进制数表示逻辑地址，则末尾K位即为页内偏移量，其余部分就是页号 $$</p> <h1 id="基本地址变换机构">基本地址变换机构</h1> <p>基本地址变换结构可以借助进程的页表将逻辑地址转换为物理地址</p> <p>通常会在系统中设置一个<strong>页表寄存器</strong>(PTR)，存放<strong>页表在内存中的起始地址F</strong>和<strong>页表长度M</strong>。</p> <p>进程未执行时，页表的始址和页表长度<strong>放在进程控制块(PCB)中</strong>，当进程被调度时，操作系统内核会把它们放到页表寄存器中</p> <p>注意：<strong>页面大小是2的整数幂</strong></p> <p>设页面大小为L，逻辑地址A到物理地址E的变换过程如下：</p> <ol> <li>计算页号P和页内偏移量W(如果用十进制数手算，则P=A/L，W=A%L；但是在计算机实际运行时，逻辑地址结构是固定不变的，因此计算机硬件可以更快地得到二进制表示的页号、页内偏移量)</li> <li>比较页号P和页表长度M，若P**>=**M，则产生越界中断，否则继续执行。(注意：页号是从0开始的，而页表长度至少是1，<strong>因此P=M时也会越界</strong>)</li> <li>页表中页号P对应的<strong>页表项地址=页表地址F+页号P*页表项长度</strong>，取出该页表项内容b，即为内存块号。(注意区分<strong>页表项长度、页表长度、页面大小的区别。</strong> <strong>页表长度</strong>指的是这个页表中总共有几个页表项，即总共有几个页；<strong>页表项长度</strong>指的是每个页表项占多大的存储空间； <strong>页面大小</strong>指的是一个页面占多大的存储空间)</li> <li>计算E=b*L+W，用得到的物理地址E去访存。(如果内存块号、页面偏移量是用二进制表示的，那么把二者拼接起来就是最终的物理地址了)</li> </ol> <p>具体情况如图所示</p> <img src="https://b.1wind.cn/2025/08/bd708f45e0fcd2cac2b63c617c31e609.png" alt="image-20250820161051287" style="zoom:50%;"> <h1 id="具有快表的地址变换机构">具有快表的地址变换机构</h1> <h2 id="局部性原理">局部性原理</h2> <p><strong>时间局部性</strong>：如果执行了程序中的某条指令，那么不久后这条指令很有可能再次执行；如果某个数据被访问过，不久之后该数据很可能再次被访问。(因为程序中存在大量的循环)</p> <p><strong>空间局部性</strong>：一旦程序访问了某个存储单元，在不久之后，其附近的存储单元也很有可能被访问。(因为很多数据在内存中都是连续存放的)</p> <h2 id="快表">快表</h2> <p><strong>快表</strong>，又称<strong>联想寄存器(TLB，translation lookaside buffer)</strong>，是一种<strong>访问速度比内存快很多</strong>的高速缓冲(TLB不是内存！)，用来存放<strong>最近访问的页表项的副本</strong>，可以加速地址变换的速度。与此对应，内存中的页表常称为<strong>慢表</strong></p> <p><strong>TLB和普通Cache的区别---TLB之一页表项的副本，而普通Cache中可能会有其他各种数据的副本</strong></p> <p>引入快表后，地址的变换过程</p> <ol> <li>CPU给出逻辑地址，由某个硬件算得页号、页内偏移量，将页号与快表中的所有页号进行比较</li> <li>如果找到匹配的页号，说明要访问的页表项在快表中有副本，则直接从中取出该页对应的内存块号，再将内存块号与页内偏移量拼接形成物理地址，最后，<strong>访问</strong>该物理地址对应的<strong>内存单元</strong>。因此，若<strong>快表命中</strong>，则访问某个逻辑地址仅需<strong>一次访存</strong>即可</li> <li>如果没有找到匹配的页号，则需要<strong>访问内存中的页表</strong>，找到对应的页表项，得到页面存放的内存块号，再将内存块号与页内偏移量拼接成物理地址，最后，<strong>访问</strong>该物理地址对应的<strong>内存单元</strong>。因此，若<strong>快表未命中</strong>，则访问某个逻辑地址需要<strong>两次访存</strong>(<strong>注意：在找到页表项后，应同时将其存入快表</strong>，以便后面可能再次访问。但若快表已满，则必须按照一定的算法对旧的页表项进行替换)</li> </ol> <p>具体情况如图所示</p> <p><img src="https://b.1wind.cn/2025/08/cad15bd23463171b974bc31cd7bc661a.png" alt="image-20250821103722581"></p> <p>由于查询快表的速度比查询页表的速度快很多，因此只要快表命中，就可以节省很多时间。</p> <p>因为<strong>局部性原理</strong>，一般来说快表的命中率可以达到90%以上</p> <p>例：某系统使用基本分页存储管理，并采用了具有快表的地址变换机构。访问一次快表耗时1us，访问一次内存耗时100us。若快表的命中率为90%，那么访问一个逻辑地址的平均耗时是多少？</p> <p>(1+100)<code>*</code>0.9+(1+100+100)<code>*</code>0.1=<strong>111us</strong></p> <p>为什么是这样呢，因为1us是快表查询速度，查询到了访问一次100us，命中率是90%，所以乘以0.9，那么剩下的就是慢表的查询了，需要查询一次快表，发现没有查到，再去查慢表，再访问，就是如上公式了</p> <p>有的系统支持<strong>快表和慢表同时查找</strong>，如果是这样，平均耗时是(1+100)<code>*</code>0.9+(100+100)<code>*</code>0.1=<strong>110.9us</strong></p> <p>若未采用快表机制，则访问一个逻辑地址需要<strong>100+100=200us</strong></p> <p>显然，引入快表机制后，访问一个逻辑地址的速度快多了</p> <h1 id="两级页表">两级页表</h1> <p>单及页表存在着两个明显的问题</p> <ol> <li> <p><strong>页表必须连续存放，因此当页表很大时，需要占用很多个连续的页框</strong></p> <p>思考：我们是如何解决进程在内存中必须连续存储的问题的？</p> <p>将进程地址空间分页，并为其建立一张页表，记录各页面的存放位置</p> <p>同样的思路也可用于解决“页表必须连续存放”的问题，把必须连续存放的页表再分页</p> <p>思路：可将长长的页表进行分组，使每个内存块刚好可以放入一个分组(比如上个例子中，页面大小4KB，每个页表项4B，每个页面可存放1K个页表项，因此每1K个连续的页表项为一组，每组刚好占一个内存块，再将各组离散地放到各个内存块)</p> <p>另外，要为离散分配的页表再建立一张页表，称为<strong>页目录表</strong>，或称<strong>外层页表</strong>，或称<strong>顶层页表</strong></p> </li> <li> <p>没有必要让整个页表常驻内存，因为进程在一段时间内可能只需要访问某几个特定的页面</p> <ul> <li>可以在需要访问页面时才把页面调入内存(虚拟存储技术)。可以在页表项中增加一个标志位，用于表示该页面是否已经调入内存；若想访问的页面不在内存中，则产生缺页中断(内中断)，然后将目标页面从外存调入内存</li> </ul> </li> </ol> <h1 id="基本分段存储管理">基本分段存储管理</h1> <p>与“分页”最大的区别就是---离散分配时所分配地址空间的基本单位不同</p> <h2 id="分段">分段</h2> <p>进程的地址空间：按照程序<strong>自身的逻辑</strong>关系<strong>划分为若干个段</strong>，每个段都有一个段名(在低级语言中，程序员使用段名来编程)，<strong>每段从0开始编址</strong></p> <p>内存分配规则：以段位单位进行分配，<strong>每个段在内存中占据连续空间</strong>，但<strong>各段之间可以不相邻</strong></p> <p>分段系统的逻辑地址结构由段号(段名)和段内地址(段内偏移量)所组成。</p> <p><strong>段号的位数决定了每个进程最多可以分几个段</strong></p> <p><strong>段内地址位数决定了每个段的最大长度是多少</strong></p> <h2 id="段表">段表</h2> <p>程序分多个段，各段离散地装入内存，为了保证程序能正常运行，就必须能从物理内存中找到各个逻辑段的存放位置。为此，需为每个进程建立一张段映射表，简称“<strong>段表</strong>”</p> <ol> <li>每个段对应一个段表项，其中记录了该段在内存中的<strong>起始位置</strong>(又称“<strong>基址</strong>”)和<strong>段的长度</strong></li> <li><strong>各个段表项的长度是相同的</strong>。例如：某系统按字节寻址，采用分段存储管理，逻辑地址为(段号16位，段内地址16位)，因此用16位即可表示最大段长。物理内存大小为4GB(可用32位表示整个物理内存地址空间)。因此，可以让每个段表项占16+32=48位，即6B。由于段表项长度相同，因此<strong>段号可以是隐含的</strong>，<strong>不占存储空间</strong>。若段表存放的起始地址为M，则K号段对应的段表项存放的地址为M+K*6</li> </ol> <h2 id="地址变换">地址变换</h2> <p><img src="https://b.1wind.cn/2025/08/92e7c9e1e904f1ecf7840dc5d9f10b05.png" alt="image-20250822103943491"></p> <h2 id="分段页对比">分段、页对比</h2> <ul> <li><strong>页</strong>是<strong>信息的物理单位</strong>。分页的主要目的是为了实现离散分配，提高内存利用率。分页仅仅是系统管理上的需要，完全是系统行为，对<strong>用户是不可见的</strong></li> <li><strong>段</strong>是<strong>信息的逻辑单位</strong>。分段的主要目的是更好地满足用户需求。一个段通常包含着一组属于一个逻辑模块的信息。<strong>分段对用户是可见的</strong>，用户编程时需要显式地给出段名</li> <li>页的大小固定且由系统决定。段的长度却不固定，决定于用户编写的程序</li> <li><strong>分页</strong>的用户进程<strong>地址空间是一维的</strong>，程序员只需要给出一个记忆符即可表示一个地址</li> <li><strong>分段</strong>的用户进程<strong>地址空间是二维的</strong>，程序员在标识一个地址，既要给出段名，也要给出段内地址</li> </ul> <p><strong>分段</strong>比分页<strong>更容易实现信息的共享和保护</strong></p> <p>不能被修改的代码称为<strong>纯代码</strong>或<strong>可重入代码</strong>(不属于临界资源)，这样的代码是可以共享的。可修改的代码是不能共享的(比如，有一个代码段中有很多变量，各进程并发地同时访问可能造成数据不一致)</p> <h1 id="段页式管理方式">段页式管理方式</h1> <p>分段+分页---段页式管理方式</p> <p>分页管理</p> <ul> <li><strong>优点</strong>：内存空间利用率高，<strong>不会产生外部碎片</strong>，只会有少量的页内碎片</li> <li>缺点：不方便按照逻辑模块实现信息的共享和保护</li> </ul> <p>分段管理</p> <ul> <li>很方便按照逻辑模块实现信息的共享和保护</li> <li>如果段长过大，为其分配很大的连续空间会很不方便。另外，段式管理会产生外部碎片**(分段管理中产生的外部碎片也可以用“紧凑”来解决，只是需要付出较大的时间代价)**</li> </ul> <p>段页式系统的逻辑地址由段号、页号、页内地址(页内偏移量)组成。</p> <ul> <li><strong>段号的位数决定了每个进程最多可以分几个段</strong></li> <li><strong>页号位数决定了每个段最大有多少页</strong></li> <li><strong>页内偏移量决定了页面大小、内存块大小是多少</strong></li> </ul> <p>$$ 在上述例子中，若系统是按字节寻址的，则\ 段号占16位，因此在该系统中，每个进程最多有2^{16}=64K个段\ 页号占4位，因此每个段最多有2^{4}=16页\ 页内偏移量占12位，因此每个页面|每个内存块大小为2^{12}=4096=4KB $$</p> <p>“分段”对用户是可见的，程序员编程时需要显式地给出段号、段内地址。而将各段“分页”对用户是不可见的。系统会根据段内地址自动划分页号和页内偏移量。</p> <p>因此<strong>段页式</strong>管理的<strong>地址结构是二维的</strong></p> <p>每个段对应一个段表项，每个段表项由段号、<strong>页表长度</strong>、<strong>页表存放块号(页表起始地址)<strong>组成。每个</strong>段表项长度相等，段号是隐含的</strong>。</p> <p>每个页面对应一个页表项，每个页表项由页号、页面存放的内存块号组成。每个页表项长度相等，页号是隐含的</p> <h1 id="虚拟内存">虚拟内存</h1> <h2 id="传统存储管理方式的特征缺点">传统存储管理方式的特征、缺点</h2> <p><strong>一次性</strong>：<strong>作业必须一次性全部装入内存后才能开始运行</strong>。这会造成两个问题：①作业很大时，不能全部装入内存，导致大作业无法运行；②当大量作业要求运行时，由于内存无法容纳所有作业，因此只有少量作业能运行，导致<strong>多道程序并发度下降</strong></p> <p><strong>驻留性</strong>：一旦作业被装入内存，<strong>就会一直驻留在内存中</strong>，直至作业运行结束。事实上，在一个时间段内，只需要访问作业的一小部分即可正常运行，这就导致了内存中会驻留大量的、暂时用不到的数据，浪费了宝贵的内存资源</p> <h2 id="定义和特征">定义和特征</h2> <p>基于局部性原理，在程序装入时，可以将程序中<strong>很快会用到的部分装入内存，暂时用不到的部分留在外存</strong>，就可以让程序开始执行</p> <p>在程序执行过程中，当所访问的<strong>信息不在内存时</strong>，由<strong>操作系统负责将所需信息从外存调入内存</strong>，然后继续执行程序</p> <p>若内存空间不够，由<strong>操作系统负责</strong>将内存中<strong>暂时用不到的信息换出外存</strong></p> <p>在操作系统的管理下，在用户看来似乎有应该比实际内存大得多的内存，这就是虚拟内存</p> <p><strong>虚拟内存有以下三个主要特征</strong>：</p> <ol> <li><strong>多次性</strong>：无需在作业运行时一次性全部装入内存，而是运行被分成多次调入内存</li> <li><strong>对换性</strong>：在作业运行时无需一直常驻内存，而是允许在作业运行过程中，将作业换入、换出</li> <li><strong>虚拟性</strong>：从逻辑上扩充了内存的容量，使用户看到的内存容量，远大于实际的容量</li> </ol> <h2 id="请求分页管理">请求分页管理</h2> <p><strong>请求分页</strong>存储管理与<strong>基本分页</strong>存储管理的主要区别：</p> <p>在程序执行过程中，当所<strong>访问的信息不在内存时</strong>，<strong>由操作系统负责将所需信息从外存调入内存(操作系统要提供请求调页功能，将缺失页面从外存调入内存)</strong>，然后继续执行程序</p> <p>若内存空间不够，由操作系统负责<strong>将内存中暂时用不到的信息换出外存(操作系统要提供页面置换的功能，将暂时用不到的页面换出外存)</strong></p> <h3 id="页表机制">页表机制</h3> <p>与基本分页管理相比，请求分页管理中，为了实现“请求调页”，操作系统需要知道每个页面是否已经调入内存；如果还没调入，那么也需要知道该页面在外存中存放的位置</p> <p>当内存空间不够时，要实现“页面置换”，操作系统需要通过某些指标来决定到底换出哪个页面；有的页面没有被修改过，就不用再浪费时间写回外存。有的页面修改过，就需要将外存中的旧数据覆盖，因此，操作系统也需要记录各个页面是否被修改的信息</p> <p>页表如图所示</p> <p><img src="https://b.1wind.cn/2025/08/82d4c75e36b9205da2f6b07046c6b890.png" alt="image-20250823164546814"></p> <h3 id="缺页中断机构">缺页中断机构</h3> <p>假设此时要访问逻辑地址=(页号，页内偏移量)=(0,1024)</p> <p>在请求分页系统中，每当要访问的<strong>页面不在内存</strong>时，便产生一个<strong>缺页中断</strong>，然后由操作系统的<strong>缺页中断处理程序处理中断</strong></p> <p>此时<strong>缺页的进程阻塞</strong>，放入阻塞队列，调页<strong>完成后再将其唤醒</strong>，放回就绪队列</p> <p>如果内存中<strong>有空闲块</strong>，则为进程<strong>分配一个空闲块</strong>，将所缺页面装入该块，并修改页表中相应的页表项</p> <p>如果内存中<strong>没有空闲块</strong>，则<strong>由页面置换算法选择一个页面淘汰</strong>，若该页面在内存期间<strong>被修改过</strong>，则要将其<strong>写回外存</strong>。未修改过的页面不用写回外存</p> <p><strong>缺页中断</strong>是因为当前执行的指令想要访问的目标页面未调入内存而产生的，因此<strong>属于内中断</strong></p> <p><strong>一条指令</strong>在执行期间，可能产生多次缺页中断。(如copy A to B，即将逻辑地址A中的数据复制到逻辑地址B，而A、B属于不同的页面，则有可能产生两次中断)</p> <h1 id="页面置换算法">页面置换算法</h1> <p><strong>缺页次数</strong> = 在访问页面时，如果该页面不在内存块中（即没有命中），则需要从外存调入，计为一次缺页。</p> <h2 id="最佳置换算法">最佳置换算法</h2> <p>最佳置换算法(OPT，Optimal)：每次选择<strong>淘汰的页面</strong>将是<strong>以后永不使用</strong>，或者<strong>在最长时间内不再被访问的页面</strong>，这样可以保证最低的缺页率</p> <p>注意：缺页时未必发生页面置换。若还有可用的空闲内存块，就不用进行页面置换</p> <p>最佳置换算法可以保证最低的缺页率，但实际上，只有在进程执行的过程中才能知道接下来会访问到的是哪个页面。操作系统无法预判页面访问序列，因此，<strong>最佳置换算法是无法实现的</strong></p> <h2 id="先进先出置换算法">先进先出置换算法</h2> <p>先进先出置换算法(FIFO)：每次选择<strong>淘汰的页面</strong>是<strong>最早进入内存的页面</strong></p> <p>实现方法：把调入内存的页面根据调入的先后顺序排成一个队列，需要换出页面时选择队头页面即可</p> <p>队列的最大长度取决于系统为进程分配了多少个内存块</p> <p><strong>Belady异常</strong>---当为进程分配的物理块数增大时，缺页次数不减反增的异常现象</p> <p><strong>只有FIFO算法会产生Belady异常</strong>。另外，FIFO算法虽然<strong>实现简单</strong>，但是该算法与进程实际运行时的规律不适合，因为先进入的页面也有可能最经常被访问，因此，<strong>算法性能差</strong></p> <h2 id="最近最久未使用置换算法">最近最久未使用置换算法</h2> <p>最近最久未使用置换算法(LRU，least recently used)：每次<strong>淘汰的页面</strong>是<strong>最近最久未使用的页面</strong></p> <p>实现方法：赋予每个页面对应的页表项中，用<strong>访问字段记录该页面自上次被访问以来所经历的时间t</strong></p> <p>当需要淘汰一个页面时，选择现有页面中t值最大的，即最近最久未使用的页面</p> <p>该算法的实现需要专门的硬件支持，虽然算法<strong>性能好</strong>，但是<strong>实现困难</strong>，<strong>开销大</strong></p> <p>在手动做题时，若需要淘汰页面，可以逆向检查此时在内存中的几个页面号。在<strong>逆向扫描过程中最后一个出现的页号就是要淘汰的页面</strong></p> <h2 id="时钟置换算法">时钟置换算法</h2> <h3 id="简单型">简单型</h3> <p><strong>时钟置换算法</strong>是一种性能和开销较均衡的算法，又称<strong>CLOCK算法</strong>，或<strong>最近未用算法（NRU，Not Recently Used)</strong></p> <p><strong>简单的CLOCK算法</strong>实现方法：为每个页面设置一个<strong>访问位</strong>，再将内存中的页面都通过链接指针<strong>链接成一个循环队列</strong>。当某也被访问时，其访问位置为1。当需要淘汰一个页面时，只需检查页的访问位。</p> <p>如果是0，就选择该页换出；如果是1，则将它置为0，暂不换出，暂不换出，继续检查下一个页面，若第一轮扫描中所有页面都是1，则将这些页面的访问位依次置为0后，再进行第二轮扫描(第二轮扫描中一定会有访问位为0的页面，因此<strong>简单的CLOCK算法</strong>选择一个淘汰页面<strong>最多会经过两轮扫描</strong>)</p> <h3 id="改进型">改进型</h3> <p><strong>简单的时钟置换算法</strong>仅考虑到一个页面最近是否被访问过。事实上，如果被淘汰的页面没有被修改过，就不需要执行I/O操作写回外存。<strong>只有被淘汰的页面被修改过时，才需要写回内存</strong></p> <p>因此，除了考虑一个页面最近有没有被访问之外，操作系统还应考虑页面有没有被修改过。<strong>在其他条件都相同时，应优先淘汰没有修改过的页面</strong>，避免I/O操作。这就是改进型时钟置换算法的思想。</p> <p>为方便讨论，用（访问位，修改位）的形式表示各页面状态。如（1,1）表示一个页面近期被访问过，且被修改过</p> <p><strong>算法规则</strong>：将所有可能被置换的页面排成一个循环队列</p> <p>第一轮：从当前位置开始扫描到第一个（0，0）的帧用于替换。本轮扫描不修改任何标志位</p> <p>第二轮：若第一轮扫描失败，则重新扫描，查找第一个（0，1）的帧用于替换。本轮将所有扫描过的帧设为0</p> <p>第三轮：若第二轮扫描识别，则重新扫描，查找第一个（0，0）的帧用于替换。本轮扫描不修改任何标志位</p> <p>第四轮：若第三轮扫描识别，则重新扫描，查找第一个（0,1）的帧用于替换</p> <p>由于第二轮已将所有帧的访问位设为0，因此经过第三轮、第四轮扫描一定会有一个帧被选中，因此<strong>改进型CLOCK置换算法</strong>选择一个淘汰页面<strong>最多会进行四轮扫描</strong></p> <p>第一优先级：最近没访问，且没修过的页面</p> <p>第二优先级：最近没访问，但修改过的页面</p> <p>第三优先级：最近访问过，但没修过的页面</p> <p>第四优先级：最近访问过，且修改过的页面</p> <h1 id="页面分配策略">页面分配策略</h1> <h2 id="页面分配置换策略">页面分配、置换策略</h2> <p><strong>驻留集</strong>：指请求分页存储管理中给进程分配的物理块集合。</p> <p>在采用了虚拟存储技术的系统中，驻留集大小一般小于进程的总大小</p> <p>若驻留集太小，会导致缺页频繁，系统要花大量的时间来处理缺页，实际用于进程推进的时间很少；</p> <p>驻留集太大，又会导致多道程序并发度下降，资源利用率降低。所以应该选择一个合适的驻留集大小</p> <p><strong>固定分配</strong>：操作系统为每个进程分配一组固定数目的物理块，在进程运行期间不再改变。即，<strong>驻留集大小不变</strong></p> <p><strong>可变分配</strong>：先为每个进程分配一定数目的物理块，在进程运行期间，可根据情况做适当的增加或减少。</p> <p><strong>局部置换</strong>：发生缺页时只能选进程自己的物理块进行置换</p> <p><strong>全局置换</strong>：可以将操作系统保留的空闲物理块分配给缺页进程，也可以将别的进程持有的物理块置换到外存，再分配给缺页进程</p> <p><strong>全局置换意味着一个进程拥有的物理块数必然会改变，因此固定分配不会存在全局置换</strong></p> <p><strong>固定分配局部置换</strong>：系统为每个进程分配一定数量的物理块，在整个运行期间都不改变、若进程在运行中发生缺页，则只能从该进程在内存中的页面中选出一页换出，然后再调入需要的页面。这种策略的缺点是：很难在刚开始就确定应为每个进程分配多少个物理块才算合理。(采用这种策略的系统可以格局进程大小、优先级、或是根据程序员给出的参数来确定为一个进程分配的内存块数)</p> <p><strong>可变分配全局置换</strong>：刚开始会为每个进程分配一定数量的物理块。操作系统会保持一个空闲物理块队列。当某进程发生缺页时，从空闲物理块中取出一块分配给该进程；若已无空闲物理块，则可选择一个<strong>未锁定</strong>的页面换出外存，再将该物理块分配给缺页的进程。采用这种策略时，<strong>只要某进程发生缺页，都将获得新的物理块</strong>，仅当空闲物理块用完时，系统才选择一个未锁定的页面调出。被选择调出的页可能是系统中任何一个进程的页，因此这个<strong>被选中的进程拥有的物理块会减少，缺页率会增加</strong></p> <p><strong>可变分配局部置换</strong>：刚开始会为每个进程分配一定数量的物理块。当某进程发生缺页时，只允许从该进程自己的物理块中选出一个进行换出外存。如果进程在运行中频繁地缺页，系统会为该进程多分配几个物理块，直至该进程缺页率趋势适当程度；反之，如果进程在运行中缺页率特别低，则可适当减少分配给该进程的物理块</p> <p>可变分配<strong>全局</strong>置换：只要缺页就给分配新物理块</p> <p>可变分配<strong>局部</strong>置换：要根据发生<strong>缺页的频率</strong>来动态地增加或减少进程的物理块</p> <h2 id="何时调入页面">何时调入页面</h2> <ol> <li>预调页策略：根据局部性原理，一次调入若干个相邻的页面可能比一次调入一个页面更高效。但如果提前调入的页面中大多数都没被访问过。则又是低效的。因此可以预测不久之后可能访问到的页面，将它们预先调入内存，但目前预测成功率只有50%左右。故这种策略<strong>主要用于进程的首次调入</strong>，由程序员指出应该先调入哪些部分</li> <li>请求调页策略：进程<strong>在运行期间发现缺页时才将所缺页面调入内存</strong>。这种策略调入的页面一定会被访问到，但由于每次只能调入一页，而每次调页都要磁盘I/O操作，因此I/O开销较大</li> </ol> <h2 id="抖动颠簸现象">抖动(颠簸)现象</h2> <p>刚刚换出的页面马上又要换入内存，刚刚换入的页面马上又要换出外存，这种频繁的页面调度行为称为<strong>抖动</strong>或<strong>颠簸</strong>。产生抖动的<strong>主要原因</strong>是进程频繁访问的页面数目高于可用的物理块数(分配给进程的物理块不够)</p> <p>为进程分配的物理块太少，会使进程发生抖动现象。为进程分配的物理块太多，又会降低系统整体的并发度，降低某些资源的利用率</p> <p>为了研究应该为每个进程分配多少个物理块，Denning提出了进程“工作集”的概念</p> <p><strong>工作集</strong>：指在某段时间间隔里，进程实际访问页面的集合</p> <p><strong>工作集大小</strong>可能小于窗口尺寸，实际应用中，操作系统可以统计进程的工作集大小，根据工作集大小给进程分配若干内存块。如：窗口尺寸为5，经过一段时间的检测发现某进程的工作集最大为3，那么说明该进程由很好局部性，可以给这个进程分配3个以上的内存块即可满足进程的运行需要</p> <p>一般来说，<strong>驻留集大小不能小于工作集大小，否则进程运行过程中将频繁缺页</strong></p> <p>拓展：基于局部性原理可知，进程在一段时间内访问的页面与不久之后会访问的页面是有相关性的。因此，可以根据进程近期访问的页面集合(工作集)来设计一种页面置换算法---选择一个不在工作集中的页面进行淘汰</p> <h1 id="内存映射文件">内存映射文件</h1> <p>内存映射文件---操作系统向上层程序员提供的功能(系统调用)</p> <ul> <li>方便程序员访问文件数据</li> <li>方便多个进程共享同一个文件</li> </ul> <h1 id="文件">文件</h1> <h2 id="概念-12">概念</h2> <p>一个文件有哪些属性？</p> <ul> <li><strong>文件名</strong>：由创建文件的用户决定文件名，主要是为了方便用户找到文件。<strong>同一目录下不允许有重名文件</strong>。</li> <li><strong>标识符</strong>：一个系统内的各文件标识符唯一，对用户来说毫无可读性，因此标识符只是操作系统用于区分各个文件的一种内部名称</li> <li><strong>类型</strong>：指明文件的类型</li> <li><strong>位置</strong>：指明文件存放的路径(让用户使用)、在外存中的地址(操作系统使用，对用户不可见)</li> <li><strong>大小</strong>：指明文件大小</li> <li><strong>创建时间、上次修改时间</strong></li> <li><strong>文件所有者信息</strong></li> <li><strong>保护信息</strong>：对文件进行保护的访问控制信息</li> </ul> <p>无结构文件(如文本文件)---由一些二进制或字符流组成，又称“流式文件”</p> <p>有结构文件(如数据库表)---由一组相似的记录组成，又称“<strong>记录</strong>式文件”</p> <p><code>记录是一组相关数据项的集合</code></p> <p>数据项是文件系统中最基本的数据单位</p> <h2 id="逻辑结构">逻辑结构</h2> <h3 id="有结构文件">有结构文件</h3> <p>按文件是否有结构分类，可以分为无结构文件、有结构文件两种</p> <p><strong>无结构文件</strong>：文件内部的数据就是一系列二进制流或字符流组成。又称“<strong>流式文件</strong>”。如：Windows操作系统中的.txt文件</p> <p><strong>有结构文件</strong>：由一组相似的记录组成，又称“记录式文件”。每条记录由若干个数据项组成。如：数据库表文件。一般来说，每条记录有一个数据项可作为<strong>关键字</strong>。根据各条记录的长度(占用的存储空间)是否相等，又可分为<strong>定长记录</strong>和<strong>可变长记录</strong>两种</p> <h4 id="顺序文件">顺序文件</h4> <p><strong>顺序文件</strong>：文件中的记录一个接一个地顺序排列(逻辑上)，记录可以是<strong>定长</strong>的或<strong>可变长</strong>的。各个记录在物理上可以<strong>顺序存储</strong>或<strong>链式存储</strong></p> <p>顺序存储---逻辑上相邻的记录物理上也相邻(类似于顺序表)</p> <ul> <li>可变长记录 <ul> <li>无法实现随机存取。每次只能从第一个记录开始依次往后查找</li> </ul> </li> <li>定长记录 <ul> <li>可实现随机存储。记录长度为L，则第i个记录存放的相对位置是i*L</li> <li>若采用串结构，无法快速找到某关键字对应的记录</li> <li>若采用顺序结构，可以快速找到某关键字对应的记录</li> </ul> </li> </ul> <p>链式存储---逻辑上相邻的记录物理上不一定相邻(类似于链表)</p> <ul> <li>无论是定长/可变长记录，都无法实现随机存取，每次只能从第一个记录开始依次往后查找</li> </ul> <p>结论：定长记录的顺序文件，若物理上采用顺序存储，则可实现随机存取；若能再保证记录的顺序结构，则可实现快速检索(即根据关键字快速找到对应记录)</p> <h2 id="索引文件">索引文件</h2> <p>对于可变长记录文件，要找到第i个记录，必须先顺序的查找前i-1个记录，但是很多应用场景中又必须使用可变长记录。如何解决这个问题？</p> <p>建立一张索引表以加快文件检索速度。每条记录对应一个索引项</p> <p>文件中的这些记录在物理上可以离散地存放</p> <p><strong>索引表</strong>本身是<strong>定长记录的顺序文件</strong>。因此可以快速找到第i个记录对应的索引项。</p> <p>可将关键字作为索引号内容，若按关键字顺序排列，则还可以支持按照关键字折半查找</p> <p>每当要增加/删除一个记录时，需要对索引表进行修改。由于索引文件有很快的检索速度，因此<strong>主要用于对信息处理的及时性要求比较高的场合</strong></p> <p>另外，**可以用不同的数据项建立多个索引表。**如：学生信息表中，用关键字“学号”或“姓名”建立一张索引表，当然索引是唯一的，需要考虑其他问题</p> <h2 id="文件目录">文件目录</h2> <h3 id="文件控制块">文件控制块</h3> <p>目录文件中的一条记录就是一个“文件控制块(FCB)”</p> <p>FCB的有序集合称为“文件目录”，一个FCB就是一个文件目录项。</p> <p>FCB中包含了文件的<strong>基本信息(文件名、物理地址、逻辑结构、物理结构等)</strong>，存取控制信息(是否可读/可写、禁止访问的用户名单等)，使用信息(如文件的建立时间、修改时间等)</p> <p><strong>最重要、最基本的</strong>还是<strong>文件名、文件存放的物理地址</strong></p> <p>FCB实现了文件名和文件之间的映射。使用户(用户程序)可以实现“按名存取”</p> <h3 id="单级目录结构">单级目录结构</h3> <p>早期操作系统并不支持多级目录，整个系统中只建立<strong>一张目录表</strong>，每个文件占一个目录项</p> <p>单级目录实现了“按名存取”，但是<strong>不允许文件重名</strong></p> <p>在创建一个文件时，需要先检查目录表中有没有重名文件，确定不重名后才能允许创建文件，并将新文件对应的目录项插入目录表。</p> <p>显然，单级目录结构不适用于多用户操作系统</p> <h3 id="两级目录结构">两级目录结构</h3> <p>早期的多用户操作系统，采用两级目录结构。分为<strong>主文件目录</strong>(MFB，Master File Directory)和<strong>用户文件目录</strong>(UFD，User File Directory)</p> <p>主文件目录记录用户名及相应用户文件目录的存放位置，用户文件目录由该用户的文件FCB组成</p> <p><strong>允许不同用户的文件重名</strong>。文件名虽然相同，但是对应的其实是不同的文件</p> <p>两级目录结构允许不同用户的文件重名，也可以在目录上实现访问限制(检查此时登录的用户名是否匹配)。但是两级目录结构依然缺乏灵活性，用户不能对自己的文件进行分类</p> <h3 id="多级目录结构">多级目录结构</h3> <p>又称<strong>树形目录结构</strong></p> <p>用户(或用户进程)要访问某个文件时要用文件路径名标识文件，文件路径名是个字符串。各级目录之间用“/”隔开。<strong>从根目录出发</strong>的路径称为<strong>绝对路径</strong></p> <p>如果说，此时打开了“照片”的目录文件，也就是说，这张目录表已调入内存，那么可以把它设置为“当前目录”。当用户想要访问某个文件时，可以使用<strong>从当前目录出发</strong>的“<strong>相当路径</strong>”</p> <p><strong>树形目录结构</strong>可以很方便地对文件进行分类，层次结构清晰，也能够更有效地进行文件的管理和保护。但是，树形结构<strong>不便于实现文件的共享</strong>。为此，提出了“<strong>无环图目录结构</strong>”</p> <h3 id="无环图目录结构">无环图目录结构</h3> <p>在树形目录结构的基础上，增加一些指向同一节点的有向边，使整个目录成为一个<strong>有向无环图</strong>。可以更方便地实现多个用户间的文件共享</p> <p>可以用不同的文件名指向同一个文件，甚至指向同一个目录(共享同一目录下的所有内容)</p> <p>需要为<strong>每个共享结点设置一个共享计数器</strong>，用于记录此时有多少个地方在共享该结点。用户提出删除结点的请求时，只是删除该用户的FCB、并使<strong>共享计数器减1</strong>，并不会直接删除共享结点</p> <p>注意：共享文件不同于复杂文件。在共享文件中，由于<strong>各用户指向的是同一个文件，因此只要其中一个用户修改了文件数据，那么所有用户都可以看到文件数据的变化</strong></p> <h3 id="索引结点">索引结点</h3> <p>如果内容都放在一个表中，FCB的大小会过大，导致盘块增多，盘块增多的话，读写速度也会变慢</p> <p>如果我们能减少FCB，就能让检索速度变快，所以我们可以仅保留文件名用于检索</p> <p>当找到文件名对应的目录项时，才需要将索引结点调入内存，索引结点中记录了文件的各种信息，包括文件在外存中的存放位置，根据“存放位置”即可找到文件</p> <p>存放<strong>在外存中</strong>的索引结点称为“磁盘索引结点”，当索引结点<strong>放入内存</strong>后称为“内存索引结点”</p> <p>相比之下<strong>内存索引结点中需要增加一些信息</strong>，比如：文件是否被修改、此时有几个进程正在访问该文件等</p> <h2 id="物理结构">物理结构</h2> <h3 id="文件块磁盘块">文件块&#x26;磁盘块</h3> <p>在内存管理中，进程的逻辑地址空间被分为一个一个页面</p> <p>同样的，在外存管理中，为了方便对文件数据的管理，<strong>文件的逻辑地址空间也被分为了一个一个的文件“块”</strong></p> <p>于是文件的逻辑地址也可以表示为(<strong>逻辑块号，块内地址</strong>)的形式</p> <p><strong>操作系统为文件分配存储空间是以块为单位的</strong></p> <h2 id="分配方式">分配方式</h2> <h3 id="连续分配">连续分配</h3> <p><strong>连续分配</strong>方式要求<strong>每个文件在磁盘上占有一组连续的块</strong></p> <p>用户通过逻辑地址来操作自己的文件，操作系统如何实现从逻辑地址到物理地址的映射？</p> <p>(逻辑块号，块内地址)->(物理块号，块内地址)。只需转变块号就行，块内地址保持不变</p> <p>文件目录中记录存放的起始块号和长度(总共占用几个块)</p> <p>用户给出要访问的逻辑块号，操作系统找到该文件对应的目录项(FCB)</p> <p><strong>物理块号=起始块号+逻辑块号</strong></p> <p>当然，还需要检查用户提供的逻辑块号是否合法(逻辑块号>=长度就不合法)</p> <p>因为可以直接算出逻辑块号对应的物理块号，因此<strong>连续分配支持顺序访问和直接访问(即随机访问)</strong></p> <p>读取某个磁盘块时，需要移动磁头。访问的两个磁盘块相隔越远，移动磁头所需时间就越长</p> <p>结论：<strong>连续分配的文件在顺序读/写时速度最快</strong></p> <p><strong>缺点</strong>：</p> <p>当文件要拓展时，若没有连续的空闲磁盘块，就需要将该文件<strong>全部</strong>迁移到存在空闲磁盘块的区域</p> <img src="https://b.1wind.cn/2025/08/7ec905dbe45364e2327ceb53053b1bd9.png" alt="image-20250829164747474" style="zoom:50%;"> <p>而又因为必须采用连续分配，需要占用一组连续的块，存储空间利用率会变低，会产生难以利用的小的磁盘碎片，可以用紧凑来处理碎片，但是需要耗费很大的时间代价</p> <p>优点：支持顺序访问和直接访问(即随机访问)；连续分配的文件在顺序访问时速度最快</p> <p>缺点：不方便文件拓展；存储空间利用率低，会产生磁盘碎片</p> <h3 id="链接分配">链接分配</h3> <p><strong>链接分配</strong>采用离散分配的方式，可以为文件分配离散的磁盘块。分为<strong>隐式链接</strong>和<strong>显式链接</strong>两种</p> <h4 id="隐式链接">隐式链接</h4> <p>目录中记录了文件存放的起始块号和结束块号。当然，也可以增进一个字段来表示文件的长度</p> <p>除了文件的最后一个磁盘块之外，每个磁盘块中都会保存指向下一个盘块的指针，这些指针对用户是透明的</p> <p>那么，<strong>如何实现文件的逻辑块号到物理块号的转变</strong>？</p> <p>用户给出要访问的逻辑块号i，操作系统找到该文件对应的目录项(FCB)</p> <p>从目录项中找到起始块号(即0号块)，将0号逻辑块读入内容，由此知道1号逻辑块存放的物理块号，于是读入1号逻辑块，再找到2号逻辑块的存放位置…以此类推</p> <p>因此，读入i号逻辑块，总共需要i+1次磁盘I/O</p> <p>结论：采用**链式分配(隐式链接)**方式的文件，<strong>只支持顺序访问</strong>，<strong>不支持随机访问</strong>，查找效率低。另外，指向下一个盘块的指针也需要耗费少量的存储空间</p> <p><strong>是否方便拓展文件</strong>？</p> <p>若此时要拓展文件，则可以随便找一个空闲磁盘块，挂到文件的磁盘块尾，并修改文件的FCB</p> <p>结论：采用隐式链接的<strong>链接分配方式</strong>，<strong>很方便文件拓展</strong></p> <p>另外，所有空闲磁盘块都可以被利用，<strong>不会有碎片问题，外存利用率高</strong></p> <h4 id="显式链接">显式链接</h4> <p>把用于链接文件各物理块的指针显式地存放在一张表中。即文件分配表(FAT，File Allocation Table)</p> <p>目录中只需记录文件的起始块号</p> <p>如图所示</p> <img src="https://b.1wind.cn/2025/08/f04497f1d5415480e4de801cb2024395.png" alt="image-20250829214756391" style="zoom:50%;"> <p>如何实现文件的逻辑块号到物理块号的转变？</p> <p>用户给出要访问的逻辑块号i，操作系统找到该文件对应的目录项(FCB)</p> <p>从目录项中找到起始块号，若i>0，则查询内存中的文件分配表FAT，从后找到i号逻辑块对应的物理块号。<strong>逻辑块号转换成物理块号的过程不需要读磁盘操作</strong></p> <p>结论：采用<strong>链式分配(显式存储)<strong>方式的文件，支持顺序访问，也</strong>支持随机访问(想访问i号逻辑块时，并不需要依次访问之前的0~i-1号逻辑块)</strong>，由于块号转换的过程不需要访问磁盘，因此相比于隐式链接来说，访问速度快很多</p> <p>显然，显式链接也<strong>不会产生外部碎片，也可以很方便地对文件进行拓展</strong></p> <h3 id="索引分配">索引分配</h3> <p><strong>索引分配</strong>允许文件离散地分配在各个磁盘块中，系统会<strong>为每个文件建立一张索引表</strong>，索引表中<strong>记录了文件的各个逻辑块对应的物理块(索引表的功能类似于内存管理中的页表---建立逻辑页面到物理页之间的映射关系)。<strong>索引表存放的磁盘块称为</strong>索引块</strong>。文件数据存放的磁盘块称为<strong>数据块</strong></p> <p><strong>如何实现文件的逻辑块号到物理块号的转换</strong>？</p> <p>用户给出要访问的逻辑块号i，操作系统找到该文件对应的目录项(FCB)</p> <p>从目录项中可知索引表存放位置，将索引表从外存读入内存，并查找索引表即可知i号逻辑块在外存中的存放位置</p> <p>可见，<strong>索引分配方式可以支持随机访问。文件拓展也很容易实现(只需给文件分配一个空闲块，并增加一个索引表项即可)</strong></p> <ol> <li><strong>链接方案</strong>：如果索引表太大，一个索引块装不下，那么可以将多个索引块链接起来存放</li> <li><strong>多层索引</strong>：建立多层索引(原理类似于多级页表)。使第一层索引块指向第二层的索引块。还可根据文件大小的要求再建立第三层、第四层索引块[若采用多层索引，则各层索引表大小不能超过一个磁盘块]</li> <li><strong>混合索引</strong>：多种索引分配方式的结合。例如，一个文件的顶级索引表中，既包含<strong>直接地址索引(直接指向数据块)</strong>，又包含<strong>一级间接索引(指向单层索引表)</strong>、还包含<strong>两级间接索引(指向两层索引表)</strong></li> </ol> <h2 id="存储空间管理">存储空间管理</h2> <h3 id="划分和初始化">划分和初始化</h3> <ul> <li>存储空间的划分：将物理磁盘划分为一个个文件卷(逻辑卷、逻辑盘) <ul> <li>有的系统支持超大型文件，可支持由多个物理磁盘组成一个文件卷</li> </ul> </li> <li>存储空间的初始化：将各个文件卷划分为目录区、文件区 <ul> <li>目录区主要存放文件目录信息(FCB)、用于磁盘存储空间管理的信息</li> <li>文件区用于存放文件数据</li> </ul> </li> </ul> <h3 id="空闲表法">空闲表法</h3> <p><img src="https://b.1wind.cn/2025/08/95f9c2b831bf39c4f570dc3d85506b54.png" alt="image-20250830102253835"></p> <h3 id="空闲链表法">空闲链表法</h3> <p>空闲链表法又分为空闲盘块链和空闲盘区链</p> <ul> <li>空闲盘块链：以盘块为单位组成一条空闲链</li> <li>空闲盘区链：以盘区为单位组成一条空闲链</li> </ul> <p>如图所示</p> <img src="https://b.1wind.cn/2025/08/934d12fe5e61ff5f60a14f66b8a2b4f7.png" alt="image-20250830102656100" style="zoom:50%;"> <h4 id="空闲盘块链">空闲盘块链</h4> <p>操作系统保存着<strong>链头、链尾指针。</strong></p> <p>如何分配：若某文件申请K个盘块，则从链头开始依次摘下K个盘块分配，并修改空闲链的链头指针</p> <p>如何回收：回收的盘块依次挂到链尾，并修改空闲链的链尾指针</p> <p>适用于离散分配的物理结构。为文件分配多个盘块时可能要重复多次操作</p> <h4 id="空闲盘区链">空闲盘区链</h4> <p>操作系统保存着<strong>链头、链尾指针。</strong></p> <p>如何分配：若某文件申请K个盘块，则可以采用首次适应、最佳适应等算法，从链头开始检索，按照算法规则找到一个大小符合要求的空闲盘区，分配给文件。若没有合适的连续空闲块，也可以将不同盘区同时分配给一个文件，注意分配后可能要修改相应的链指针、盘区大小等数据</p> <p>如何回收：若回收区和某个空闲盘区相邻，则需要将回收区合并到空闲盘区中。若回收区没有和任何空闲区相邻，将回收区作为单独的应该空闲盘区挂到链尾</p> <p>离散分配、连续分配都适用。为一个文件分配多个盘块时效率更高</p> <h3 id="位示图法">位示图法</h3> <p>如图所示，基于二进制位表示存储空间</p> <img src="https://b.1wind.cn/2025/08/813351e9f4af4772a553ea01bfee4087.png" alt="image-20250830110202908" style="zoom:50%;"> <h3 id="成组链接法">成组链接法</h3> <p>UNIX采用的策略，适合大型文件系统。理解即可，不方便用文字描述的知识点很难作为考题</p> <p>无法描述，推荐看视频</p> <p><a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=66">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=66</a></p> <h2 id="基本操作">基本操作</h2> <h3 id="创建文件">创建文件</h3> <p>进行Create系统调用时，需要提供的几个主要参数：</p> <ol> <li>所需的外存空间大小(如：一个盘块，即1KB)</li> <li>文件存放路径</li> <li>文件名</li> </ol> <p>操作系统在处理Create系统调用时，主要做了两件事：</p> <ol> <li><strong>在外存中找到文件所需的空间</strong></li> <li>根据文件存放路径的信息找到该目录对应的目录文件，<strong>在目录中创建该文件对应的目录项</strong>。目录项中包含了文件名、文件在外存中的存放位置等信息</li> </ol> <h3 id="删除文件">删除文件</h3> <p>进行Delete系统调用时，需要提供的几个主要参数：</p> <ol> <li>文件存放路径</li> <li>文件名</li> </ol> <p>操作系统在处理Delete系统调用时，主要做了几件事：</p> <ol> <li>根据文件存放路径找到相应的目录文件，<strong>从目录中找到文件名对应的目录项</strong></li> <li>根据该目录项记录的文件在外存的存放位置、文件大小等信息，<strong>回收文件占用的磁盘块</strong></li> <li>从目标表中<strong>删除文件对应的目录项</strong></li> </ol> <h3 id="打开文件">打开文件</h3> <p>在很多操作系统中，在对文件进行操作之前，要求用户先使用open系统调用“打开文件”，需要提供的几个主要参数：</p> <ol> <li>文件存放路径</li> <li>文件名</li> <li>要对文件的操作类型(如：r只读;rw读写等)</li> </ol> <p>操作系统在处理open系统调用时，主要做了几件事：</p> <ol> <li>根据文件存放路径找到相应的目录文件，从目录中<strong>找到文件名对应的目录项</strong>，并检查该用户是否有指定的操作权限</li> <li><strong>将目录项复制到内存中的“打开文件表”中</strong>。并将对应表目的编号返回给用户。之后<strong>用户使用打开文件表的编号来指明要操作的文件</strong></li> </ol> <h3 id="关闭文件">关闭文件</h3> <p>进程在使用完文件后，要“关闭文件”</p> <p>操作系统在处理Close系统调用时，主要做了几件事：</p> <ol> <li>将进程的打开文件表相应表项删除</li> <li>回收分配给该文件的内存空间等资源</li> <li>系统打开文件表的打开计数器count减1，若count=0，则删除对应表项</li> </ol> <h3 id="读文件">读文件</h3> <p>进程使用read系统调用完成读操作。需要指明是哪个文件(在支持“打开文件”操作的系统中，只需要提供文件在打开文件表中的索引号即可)，还需要指明要读入多少数据、指明读入的数据要放在内存中的什么位置</p> <p>操作系统在处理read系统调用时，会从读指针指向的外存中，将用户指定大小的数据读入用户指定的内存区域中</p> <h3 id="写文件">写文件</h3> <p>进程使用write系统调用完成写操作，需要指明是哪个文件(在支持“打开文件”操作的系统中，只需要提供文件在打开文件表中的索引号即可)，还需要指明要写出多少数据、写回外存的数据放在内存中的什么位置</p> <p>操作系统在处理write系统调用时，会从用户指定的内存区域中，将指定大小的数据写回写指针指向的外存</p> <h2 id="文件共享">文件共享</h2> <h3 id="基于索引结点的共享方式硬链接">基于索引结点的共享方式(硬链接)</h3> <p>知识回顾：索引结点，是一种文件目录瘦身策略。由于检索文件时只需用到文件名，因此可以将除了文件名之外的其他信息放到索引结点中。这样目录项就只需要包含文件名、索引结点指针</p> <p>索引结点中设置一个链接计数变量count，用于表示链接到本索引结点上的用户目录项数</p> <p>若count=2，说明此时有两个用户目录项链接到该索引结点上，或者说有两个用户在共享此文件。若某个用户决定“删除”该文件，则只是要把用户目录中与该文件对应的目录项删除，且索引结点的count值减1</p> <p>若count>0，说明还有别的用户要使用该文件，暂时不能把文件数据删除，否则会导致指针悬空</p> <p>若count=0时系统负责删除文件</p> <h3 id="基于符号链的共享方式软链接">基于符号链的共享方式(软链接)</h3> <ul> <li>在一个Link型的文件中记录共享文件的存放路径(Windows快捷方式)</li> <li>操作系统根据路径一层层查找目录，最终找到共享文件</li> <li>即使软链接指向的共享文件已被删除，Link型文件依然存在，只是通过Link型文件中的路径去查找共享文件会失败(找不到对应目录项)</li> <li>由于用软链接的方式访问共享文件时要查询多级目录，会有多次磁盘I/O，因此用软链接访问</li> </ul> <h2 id="文件保护">文件保护</h2> <h3 id="口令保护">口令保护</h3> <p>为文件设置一个口令(如：abc112233)，用户请求访问该文件时必须提供“口令”</p> <p>口令一般存放在文件对应的FCB或索引结点中。用户访问文件前需要先输入“口令”，操作系统会将用户提供的口令与FCB中存储的口令进行对比，如果正确，则允许该用户访问文件</p> <ul> <li>优点：保存口令的空间开销不多，验证口令的时间开销也很小</li> <li>缺点：正确的“口令”存放在系统内部，不够安全</li> </ul> <h3 id="加密保护">加密保护</h3> <p>使用某个“密码”对文件进行加密，在访问文件时需要提供正确的“密码”才能对文件进行正确的解密</p> <ul> <li>优点：保密性强，不需要在系统中存储“密码”</li> <li>缺点：编码/译码，或者说加密/解密要花费一定时间</li> </ul> <h2 id="访问控制">访问控制</h2> <p>在每个文件的FCB（或索引结点）中增加一个<strong>访问控制列表（Access-Control List,ACL）</strong>，该表中记录了各个用户可以对该文件执行哪些操作</p> <p>精简的访问列表：以“组”为单位，标记各“组”用户可以对文件执行哪些操作。</p> <p>如：分为系统管理员、文件主、文件主的伙伴、其他用户 几个分组</p> <p>当某用户想要访问文件时，系统会检查该用户所属的分组是否有相应的访问权限</p> <h2 id="文件系统的层次结构">文件系统的层次结构</h2> <p>如图</p> <p><img src="https://b.1wind.cn/2025/08/444fe96e7baa7cc616b28fbdb99e493f.png" alt="image-20250830203054188"></p> <h2 id="文件系统的全局结构布局">文件系统的全局结构(布局)</h2> <p>物理格式化，即低级格式化---划分扇区，检测坏扇区，并用备用扇区替换坏扇区</p> <p>具体可看这个视频，比较抽象：<a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=71">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=71</a></p> <h2 id="虚拟文件系统">虚拟文件系统</h2> <p><a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=72">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=72</a></p> <h1 id="io设备">I/O设备</h1> <h2 id="基本概念和分类">基本概念和分类</h2> <p>I/O就是输入/输出(Input/Output)</p> <p>I/O设备就是可以将数据输入到计算机，或者可以接收计算机输出数据的外部设备，属于计算机中的硬件部件</p> <ul> <li>按使用特性分类 <ul> <li>人机交互类外部设备(eg:键盘、鼠标)</li> <li>存储设备(eg:移动硬盘、光盘)</li> <li>网络通信设备(eg:调制解调器)</li> </ul> </li> <li>按传输速率分类 <ul> <li>低速设备</li> <li>中速设备</li> <li>高速设备</li> </ul> </li> <li>按信息交换的单位分类 <ul> <li>块设备(传输快，可寻址)(eg:磁盘)</li> <li>字符设备(传输慢，不可寻址，常采用中断驱动方式)(eg:键盘、鼠标)</li> </ul> </li> </ul> <h2 id="控制器">控制器</h2> <h3 id="概念-13">概念</h3> <p>I/O设备的<strong>机械部件</strong>主要用来执行具体I/O操作</p> <p>如我们看得见摸得着的鼠标/键盘的按钮；显示器的LED屏；移动硬盘的磁臂、磁盘盘面</p> <p>I/O设备的<strong>电子部件</strong>通常是一块插入主板扩充槽的印刷电路板</p> <p>CPU无法直接控制I/O设备的机械部件，因此I/O设备还要有一个电子部件作为CPU和I/O设备机械部件之间的“中介”，用于实现CPU对设备的控制</p> <p>这个电子部件就是<strong>I/O控制器</strong>，又称<strong>设备控制器</strong>。CPU可控制I/O控制器，又由I/O控制器来控制设备的机械部件</p> <h3 id="功能">功能</h3> <ul> <li>接受和识别CPU发出的命令 <ul> <li>如CPU发来的read/write命令，I/O控制器中会有相应的<strong>控制寄存器</strong>来存放命令和参数</li> </ul> </li> <li>向CPU报告设备的状态 <ul> <li>I/O控制器中会有相应的<strong>状态寄存器</strong>，用于记录I/O设备的当前状态。如：1表示空闲，0表示忙碌</li> </ul> </li> <li>数据交换 <ul> <li>I/O控制器中会设置相应的<strong>数据寄存器</strong>。输出时，数据寄存器用于暂存CPU发来的数据，之后再由控制器传送设备。输入时，数据寄存器用于暂存设备发来的数据，之后CPU从数据寄存器中取走数据</li> </ul> </li> <li>地址识别 <ul> <li>类似于内存的地址，为了区分设备控制器中的各个寄存器，也需要给各个寄存器设置一个特定的“地址”。I/O控制器通过CPU提供的“地址”来判断CPU要读/写的是哪个寄存器</li> </ul> </li> </ul> <h3 id="组成-1">组成</h3> <p>如图</p> <img src="https://b.1wind.cn/2025/08/baf6487f1c92f0c52be8b7c259107bae.png" alt="image-20250831093610969" style="zoom:50%;"> <p>值得注意的小细节:</p> <ol> <li>一个I/O控制器可能会对应多个设备</li> <li>数据寄存器、控制寄存器、状态寄存器可能有多个(如：每个状态/控制寄存器对应一个具体的设备)，且这些寄存器都要有相应的地址，才能方便CPU操作。有的计算机会让这些寄存器占用内存地址的一部分，称为<strong>内存映像I/O</strong>；另一些计算机则采用I/O专用地址，即<strong>寄存器独立编址</strong></li> </ol> <h3 id="内存映像vs寄存器独立编址">内存映像v.s.寄存器独立编址</h3> <p><img src="https://b.1wind.cn/2025/08/1d6b32c1d74d9c369fbefb53a4d3d899.png" alt="image-20250831094217119"></p> <h2 id="控制方式">控制方式</h2> <h3 id="程序直接控制方式">程序直接控制方式</h3> <p>具体流程如图所示</p> <img src="https://b.1wind.cn/2025/08/10fdb2c4fa7fe79a968e3a6707025a15.png" alt="image-20250831103841841" style="zoom:50%;"> <ul> <li>CPU干预的频率 <ul> <li>很频繁，I/O操作开始之前、完成之后需要CPU介入，并且<strong>在等待I/O完成的过程中CPU需要不断地轮询检查</strong></li> </ul> </li> <li>数据传送的单位 <ul> <li>每次读/写一个字</li> </ul> </li> <li>数据的流向 <ul> <li>读操作(数据输入)：I/O设备->CPU(CPU的寄存器)->内存</li> <li>写操作(数据输出)：内存->CPU->I/O设备</li> <li>每个字的读/写都需要CPU的帮助</li> </ul> </li> <li>优缺点 <ul> <li>优点：实现简单。在读/写指令之后，加上实现循环检查的一系列指令即可(因此才称为“程序直接控制方式”)</li> <li><strong>缺点：CPU和I/O设备只能串行工作，CPU需要一直轮询检查，长期处于“忙等”状态，CPU利用率低</strong></li> </ul> </li> </ul> <h3 id="中断驱动方式">中断驱动方式</h3> <p>具体流程如图所示</p> <img src="https://b.1wind.cn/2025/08/abe1248d600ae9e7c91d7942706dcabf.png" alt="image-20250831144839895" style="zoom:50%;"> <p>引入<strong>中断机制</strong>。由于I/O设备速度很慢，因此在CPU发出读/写命令后，可<strong>将等待I/O的进程阻塞</strong>，先切换到别的进程执行。当I/O完成后，控制器会向CPU发出一个中断信号，CPU<strong>检测到中断信号后</strong>，会保存当前进程的运行环境信息，转去执行中断处理程序处理该中断。处理中断的过程中，CPU从I/O控制器读一个字的数据传送到CPU寄存器，再写入主存。接着，<strong>CPU恢复等待I/O的进程(或其他进程)的运行环境，然后继续执行</strong></p> <p>注意：</p> <ol> <li>CPU会在每个指令周期的末尾检查中断</li> <li>中断处理过程中需要保存、恢复进程的运行环境，这个过程是需要一定时间开销的。可见，如果中断发生的频率太高，也会降低系统性能</li> </ol> <ul> <li>CPU干预的频率 <ul> <li>每次I/O操作开始之前、完成之后需要CPU介入</li> <li><strong>等待I/O完成的过程中CPU可以切换到别的进程执行</strong></li> </ul> </li> <li>数据传送的单位 <ul> <li>每次读/写一个<strong>字</strong></li> </ul> </li> <li>数据的流向 <ul> <li>读操作(数据输入)：I/O设备->CPU->内存</li> <li>写操作(数据输出)：内存->CPU->I/O设备</li> </ul> </li> <li>主要缺点和主要优点 <ul> <li>优点：与“程序直接控制方式”相比，在“中断驱动方式”中，I/O控制器会通过中断信号主动报告I/O已完成，CPU不再需要不停地轮询。<strong>CPU和I/O设备可并行工作</strong>，CPU利用率明显得到提升</li> <li><strong>缺点</strong>：每个字在I/O设备与内存之间的传输，都需要经过CPU。而<strong>频繁的中断处理会消耗较多的CPU时间</strong></li> </ul> </li> </ul> <h3 id="dma方式">DMA方式</h3> <p>与“中断驱动方式”相比，DMA方式(Direct Memory Access，<strong>直接存储器存取</strong>。主要用于块设备的I/O控制)</p> <p>有这样几个改进</p> <ol> <li>数据的传送单位是“块”。不再是一个字、一个字的传送</li> <li>数据的流向是从设备直接放入内存，或者从内存直接到设备。不再需要CPU作为“快递小哥”</li> <li>仅在传送一个或多个数据块的开始和结束时，才需要CPU干预</li> </ol> <p><img src="https://b.1wind.cn/2025/08/22fc153a4db893fb7edddf443fdb1e60.png" alt="DMA操作步骤"></p> <p><img src="https://b.1wind.cn/2025/08/f362f87ffecff861c3c21e71ba3e972f.png" alt="DMA结构"></p> <ul> <li>CPU干预的频率 <ul> <li>仅在传送一个或多个数据块的开始和结束时，才需要CPU干预</li> </ul> </li> <li>数据传送的单位 <ul> <li>每次读/写<strong>一个或多个块(注意：每次读写的只能是连续的多个块，且这些块读入内存后在内存中也必须是连续的)</strong></li> </ul> </li> <li>数据的流向(<strong>不再需要经过CPU</strong>) <ul> <li>读操作(数据输入)：I/O设备->内存</li> <li>写操作(数据输出)：内存->I/O设备</li> </ul> </li> <li>优缺点 <ul> <li>优点：数据传输以“块”为单位，CPU介入频率进一步降低。数据的传输不再需要先经过CPU再写入内存，数据传输效率进一步增加。CPU和I/O设备的并行性得到提升</li> <li>缺点：CPU每发出一条I/O指令，只能读/写一个或多个连续的数据块。如果要读/写多个离散的数据块，或者要将数据分别写入到不同的内存区域时，CPU要分别发出多条I/O指令，进行多次中断处理才能完成</li> </ul> </li> </ul> <h3 id="通道控制方式">通道控制方式</h3> <p><img src="https://b.1wind.cn/2025/08/66a0d8c9e15a98ba2a4049ce24aa5cec.png" alt="完成一次I/O的步骤"></p> <ul> <li>CPU干预的频率 <ul> <li>极低，通道会根据CPU的指示执行相应的通道程序，只有完成一组数据块的读/写才需要发出中断信号，请求CPU干预</li> </ul> </li> <li>数据传送的单位 <ul> <li>每次读/写<strong>一组数据块</strong></li> </ul> </li> <li>数据的流向(<strong>在通道的控制下进行</strong>) <ul> <li>读操作(数据输入)：I/O设备->内存</li> <li>写操作(数据输出)：内存->I/O设备</li> </ul> </li> <li>优缺点 <ul> <li><strong>优点：CPU、通道、I/O设备可并行工作，资源利用率很高</strong></li> <li>缺点：实现复杂，需要专门的通道硬件支持</li> </ul> </li> </ul> <h2 id="软件层次结构">软件层次结构</h2> <h3 id="用户层软件">用户层软件</h3> <p><img src="https://b.1wind.cn/2025/08/a3303f2d3310ffe41f15e014744eabb9.png" alt="用户层软件"></p> <h3 id="设备独立性软件">设备独立性软件</h3> <p><strong>设备独立性软件</strong>，又称<strong>设备无关性软件</strong>。与设备的硬件特性无关的功能几乎都在这一层实现</p> <p>主要实现的功能：</p> <ol> <li>向上层提供统一的调用接口(如read/write 系统调用)</li> <li>设备的保护 <ul> <li>原理类似与文件保护。设备被看作是一种特殊的文件，不同用户对各个文件的访问权限是不一样的，同理，对设备的访问权限也不一样</li> </ul> </li> <li>差错处理 <ul> <li>设备独立性软件需要对一些设备的错误进行处理</li> </ul> </li> <li>设备的分配与回收</li> <li>数据缓冲区管理 <ul> <li>可以通过缓冲技术屏蔽设备之间数据交换单位大小和传输速度的差异</li> </ul> </li> <li>建立逻辑设备名到物理设备名的映射关系；根据设备类型选择调用相应的驱动程序 <ul> <li>用户或用户层软件发出I/O操作相关系统调用的系统调用时，需要指明此次要操作的I/O设备的逻辑设备名(eg:去学校打印店打印时,需要选择打印机1/打印机2/打印机3，其实这些都是<strong>逻辑设备名</strong>)</li> <li><strong>设备独立性软件</strong>需要通过“<strong>逻辑设备表(LUT,Logical Unit Table)</strong>”来确定逻辑设备对应的<strong>物理设备</strong>，并找到该设备对应的<strong>设备驱动程序</strong></li> <li>操作系统可以采用两种方式管理<strong>逻辑设备表(LUT)</strong>： <ul> <li>第一种方式，<strong>整个系统只设置一张LUT</strong>，这就意味着所有用户不能使用相同的逻辑设备名，因此这种方式只适用于单用户操作系统</li> <li>第二种方式，<strong>为每个用户设置一张LUT</strong>，各个用户使用的逻辑设备名就可以重复，适用于多用户操作系统。系统会在用户登录时为其创建一个用户管理进程，而LUT就存放在用户管理进程的PCB中</li> </ul> </li> </ul> </li> </ol> <h3 id="设备驱动程序">设备驱动程序</h3> <p>主要负责对硬件设备的具体控制,将上层发出的一系列命令(如read/write) 转化成特定设备“能听得懂”的一系列操作。包括设置设备寄存器；检查设备状态等</p> <p>不同的I/O设备有不同的硬件特性，具体细节只有设备的厂家才知道。因此厂家需要根据设备的硬件特性设计并提供相应的驱动程序</p> <p>注：驱动程序一般会以一个独立进程的方式存在</p> <h3 id="中断处理程序">中断处理程序</h3> <p>当I/O任务完成时，I/O控制器会发送一个<strong>中断信号</strong>，系统会<strong>根据中断信号类型</strong>找到相应的<strong>中断处理程序</strong>并执行。</p> <h2 id="输入输出应用程序接口和驱动程序接口">输入输出应用程序接口和驱动程序接口</h2> <p><img src="https://b.1wind.cn/2025/09/2d71c0e72f0b3d1743a1f283919f0282.png" alt="输入输出程序接口"></p> <p>极其抽象：<a href="https://www.bilibili.com/video/BV1YE411D7nH/?p=77&#x26;spm_id_from=333.1007.top_right_bar_window_history.content.click&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974">https://www.bilibili.com/video/BV1YE411D7nH/?p=77&#x26;spm_id_from=333.1007.top_right_bar_window_history.content.click&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974</a></p> <p><strong>阻塞I/O</strong>：应用程序发出I/O系统调用，<strong>进程需转为阻塞态等待</strong></p> <p><strong>非阻塞I/O</strong>：应用程序发出I/O系统调用，系统调用可迅速返回，<strong>进程无需阻塞等待</strong></p> <h2 id="假脱机技术spooling技术">假脱机技术(SPOOLing技术)</h2> <p>批处理阶段引入了<strong>脱机输入/输出技术</strong>(用磁带完成)：</p> <p>通常是将内容放到纸带机上后，通过一台外围控制机，慢速输入设备的数据先被输入到更快速的磁带上。之后主机可以从快速的磁带上读入数据，从而缓解了速度矛盾</p> <p>引入脱机技术后，缓解了CPU与慢速I/O设备的速度矛盾。另一方面，即使CPU在忙碌，也可以提前将数据输入到磁带：即使慢速的输出设备正在忙碌，也可以提前将数据输出到磁带</p> <p>Tips：为什么称为“脱机”---脱离主机的控制进行的输入/输出操作</p> <p>“<strong>假脱机技术</strong>”，又称“<strong>SPOOLing技术</strong>”是用软件的方式模拟脱机技术。SPOOLing系统的组成如下：</p> <p>通常是通过输入进程和输出进程来将数据进行输入和输出</p> <img src="https://b.1wind.cn/2025/09/b4ecfb82faf16ab8eb57fefa0702821b.png" alt="image-20250901204155514" style="zoom:50%;"> <h2 id="设备的分配和回收">设备的分配和回收</h2> <p>设备的固有属性可分为三种：独占设备、共享设备、虚拟设备</p> <ul> <li><strong>独占设备</strong>：一个时段只能分配给一个进程(如打印机)</li> <li><strong>共享设备</strong>：可同时分配给多个进程使用(如磁盘)，各进程往往是宏观上同时共享使用设备，而微观上交替使用</li> <li><strong>虚拟设备</strong>：采用SPOOLing技术将独占设备改造成虚拟的共享设备，可同时分配给多个进程使用(如采用SPOOLing技术实现的共享打印机)</li> </ul> <p>从进程运行的安全性上考虑，设备分配有两种方式：</p> <p><strong>安全分配方式</strong>：为进程分配一个设备后就将进程阻塞，本次I/O完成后才将进程唤醒(eg：考虑进程请求打印机打印输出的例子)</p> <p>一个时段内每个进程只能使用一个设备</p> <ul> <li>优点：破坏了“请求和保持”的条件，不会死锁</li> <li>缺点：对于一个进程来说，CPU和I/O设备只能串行工作</li> </ul> <p><strong>不安全分配方式</strong>：进程发出I/O请求后，系统为其分配I/O设备，进程可继续执行，之后还可以发出新的I/O请求。只有某个I/O请求得不到满足时才将进程阻塞</p> <p>一个进程可以同时使用多个设备</p> <ul> <li>优点：进程的计算任务和I/O任务可以并行处理，使进程迅速推进</li> <li>缺点：有可能发生死锁(死锁避免、死锁的检测和解除)</li> </ul> <p><strong>静态分配</strong>：进程运行前为其分配全部所需资源，运行结束后归还资源</p> <p><strong>动态分配</strong>：进程运行过程中动态申请设备资源</p> <p><strong>设备控制表(DCT)</strong>：系统为每个设备配置一张DCT，用于记录设备情况</p> <img src="https://b.1wind.cn/2025/09/f355f9d72a836958dac861a1bad20974.png" alt="设备控制表" style="zoom:50%;"> <p><strong>控制器控制表(COCT)</strong>：每个设备控制器都会对应一张COCT。操作系统根据COCT的信息对控制器进行操作和管理</p> <img src="https://b.1wind.cn/2025/09/adca4efd136e239d39bd5ffa89bee548.png" alt="控制器控制表" style="zoom:50%;"> <p><strong>通道控制表(CHCT)</strong>：每个通道都会对应一张CHCT。操作系统根据CHCT的信息对通道进行操作和管理</p> <img src="https://b.1wind.cn/2025/09/c0bfae03b926316cee301430a5143ca9.png" alt="image-20250902101227754" style="zoom:50%;"> <p><strong>系统设备表(SDT)</strong>：记录了<strong>系统中全部设备</strong>的情况，每个设备对应一个表目</p> <img src="https://b.1wind.cn/2025/09/092231eb076e4771dac1856fd1333d72.png" alt="系统设备表" style="zoom:50%;"> <p><strong>设备分配的步骤</strong></p> <ol> <li>根据进程请求的<strong>物理设备名</strong>查找SDT(注：物理设备名是进程请求分配设备时提供的参数)</li> <li>根据SDT找到DCT。若<strong>设备</strong>忙碌则将进程PCB挂到<strong>设备等待队列</strong>中，不忙碌则将<strong>设备</strong>分配给进程</li> <li>根据DCT找到COCT，若<strong>控制器</strong>忙碌则将进程PCB挂到<strong>控制器等待队列</strong>中，不忙碌则将<strong>控制器</strong>分配给进程</li> <li>根据COCT找到CHCT，若<strong>通道</strong>忙碌则将进程PCB挂到<strong>通道等待队列中</strong>，不忙碌则将<strong>通道</strong>分配给进程</li> </ol> <p><strong>注：只有设备、控制器、通道三者都分配成功时，这次设备分配才算成功，之后便可启动I/O设备进行数据传送</strong></p> <p>缺点：</p> <ol> <li>用户编程时必须使用“物理设备名”，底层细节对用户不透明，不方便编程</li> <li>若换了一个物理设备，则程序无法运行</li> <li>若进程请求的物理设备正在忙碌，则即使系统中还有同类型的设备，进程也必须阻塞等待</li> </ol> <p>改进方法：建立逻辑设备名与物理设备名的映射机制，用户编程时只需提供逻辑设备名</p> <p>改进后前两个设备分配步骤如下：</p> <ol> <li>根据进程请求的<strong>逻辑设备名</strong>查找SDT(<strong>注：用户编程时提供的逻辑设备名其实就是设备类型</strong>)</li> <li>查找SDT，找到用户进程<strong>指定类型的、并且空闲</strong>的设备，将其分配给该进程。操作系统<strong>在逻辑设备表(LUT)中新增一个表项</strong></li> </ol> <p><strong>逻辑设备表(LUT)建立了逻辑设备名与物理设备名之间的映射关系</strong></p> <p>某用户进程第一次使用设备时使用逻辑设备名向操作系统发出请求，操作系统根据用户进程指定的设备类型(逻辑设备名)查找系统设备表，找到一个空闲设备分配给进程，并在LUT中增加相应表项</p> <p><strong>如果之后用户进程再次通过相同的逻辑设备名请求使用设备，则操作系统通过LUT表即可知道用户进程实际要使用的是哪个物理设备了，并且也能知道该设备的驱动程序入口地址</strong></p> <p>逻辑设备表的设置问题：</p> <p>整个系统只有一张LUT：<strong>各用户所用的逻辑设备名不允许重复</strong>，适用于单用户操作系统</p> <p>每个用户一张LUT：<strong>不同用户的逻辑设备名可重复</strong>，适用于多用户操作系统</p> <h2 id="缓冲区管理">缓冲区管理</h2> <h3 id="概述">概述</h3> <p>太抽象了：<a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=81">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=81</a></p> <p>缓冲区是一个存储区域，可以由专门的硬件寄存器组成，也可利用内存作为缓冲区</p> <p>使用<strong>硬件作为缓冲区</strong>的<strong>成本较高</strong>，<strong>容量也较小</strong>，一般仅用在对速度要求非常高的场合(如存储器管理中所用的联想寄存器，由于对页表的访问频率极高，因此使用速度很快的联想寄存器来存放页表项的副本)</p> <p>一般情况下，更多的是利用<strong>内存作为缓冲区</strong>，“设备独立性软件”的缓冲区管理就是要组织管理好这些缓冲区</p> <p>缓冲区的作用</p> <ul> <li>缓和CPU与I/O设备之间速度不匹配的矛盾</li> <li>减少对CPU的中断频率，放宽对CPU中断相应时间的限制</li> <li>解决数据粒度不匹配的问题</li> <li>提高CPU与I/O设备之间的并行性</li> </ul> <h3 id="单缓存">单缓存</h3> <p>假设某用户进程请求某种块设备读入若干块的数据。若采用<strong>单缓冲</strong>的策略，操作系统会<strong>在主存中为其分配一个缓冲区</strong>(若题目中没有特别说明，一个缓冲区的大小就是一个块)</p> <p><strong>注意：当缓冲区数据非空时，不能往缓冲区冲入数据，只能从缓冲区把数据传出；当缓冲区为空时，可以往缓冲区冲入数据，但必须把缓冲区充满以后，才能从缓冲区把数据传出</strong></p> <img src="https://b.1wind.cn/2025/09/9a2ae4057233fc9546cf07ffb17e1d6f.png" alt="单缓存策略用时过程" style="zoom:50%;"> <h3 id="循环缓冲区">循环缓冲区</h3> <p>将多个<strong>大小相等</strong>的缓冲区链接成一个<strong>循环队列</strong></p> <p>注：以下图示中，橙色表示已充满数据的缓冲区，绿色表示空缓冲区</p> <img src="https://b.1wind.cn/2025/09/a002b18abb8acf3a5f7c62289d982bdc.png" alt="循环缓冲区" style="zoom:50%;"> <h3 id="缓冲池">缓冲池</h3> <p><strong>缓冲池</strong>由系统中共用的缓冲区组成。这些缓冲区按使用状况可以分为：空缓冲队列、装满输入数据的缓冲队列(输入队列)、装满输出数据的缓冲队列(输出队列)</p> <p>另外，根据一个缓冲区在实际运算中扮演的功能不同，又设置了四种工作缓冲区：用于收容输入数据的工作缓冲区(hin)、用于提取输入数据的工作缓冲区(sin)、用于收容输出数据的工作缓冲区(hout)、用于提取输出数据的工作缓冲区(sout)</p> <p>比较复杂，建议观看概述中的<strong>视频链接</strong></p> <h2 id="磁盘的结构">磁盘的结构</h2> <p>不抽象，比较难写笔记：<a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=82">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=82</a></p> <p><strong>磁盘、磁道、扇区</strong></p> <p>磁盘的表面由一些磁性物质组成，可以用这些磁性物质来记录二进制数据</p> <p>磁盘的盘面被划分为一个个磁道。</p> <p>一个磁道又被划分成一个个扇区，每个扇区就是一个“磁盘块”。各个扇区存放的数据量相同(如1KB)</p> <p>最内侧磁道上的扇区面积最小，因此数据密度最大</p> <p><strong>磁盘的物理地址</strong></p> <img src="https://b.1wind.cn/2025/09/836921f927c76585866fdac83d0f1cf9.png" alt="image-20250902155831286" style="zoom:50%;"> <p><strong>磁盘的分类</strong></p> <img src="https://b.1wind.cn/2025/09/a81ecaa5920e982b16e8060eb70348c1.png" alt="image-20250902160259759" style="zoom:50%;"> <p>盘片可以更换的称为<strong>可还盘磁盘</strong></p> <p>盘片不可更换的称为<strong>固定盘磁盘</strong></p> <h2 id="磁盘调度算法">磁盘调度算法</h2> <h3 id="读写-磁盘操作">读/写 磁盘操作</h3> <p>$$ 寻找时间(寻道时间)T_s：在读/写数据前，将磁头移动到指定磁道所花的时间 \ ①启动磁头臂是需要时间的。假设耗时为s; ②移动磁头也是需要时间的。假设磁头匀速移动，每跨域一个磁道耗时为m\总共需要跨越n条磁道。\ 则：寻道时间T_s=s+m<em>n \ 延迟时间T_R：通过旋转磁盘，使磁头定位到目标扇区所需要的时间。\ 设磁盘转速为r(单位：转/秒，或转/分)，则平均所需的延迟时间T_R=(1/2)</em>(1/r)=1/(2r)\ 传输时间T：从磁盘读出或向磁盘写入数据所经历的时间，假设磁盘转速为r，此次读/写的字节数为b，每个磁道上的字节 \ 数为N。则：传输时间T_t=(1/r)*(b/N)=b/(rN) \ 总的平均存取时间T_a=T_s+1/2r+b/(rN) $$</p> <p>算法比较多，都是跟之前类似的，不再赘述：<a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=83">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=83</a></p> <h2 id="减少磁盘延迟时间">减少磁盘延迟时间</h2> <p><a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=84">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=84</a></p> <h2 id="磁盘的管理">磁盘的管理</h2> <p><a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=85">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=85</a></p> <h2 id="固态硬盘ssd">固态硬盘SSD</h2> <p><a href="https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=86">https://www.bilibili.com/video/BV1YE411D7nH?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=86</a></p>https://blog.1wind.cn/posts/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/https://blog.1wind.cn/posts/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/数据结构与算法Sun, 11 May 2025 00:00:00 GMT<p>基本概念</p> <p>数据是<strong>信息的载体</strong>，是描述客观事物属性的数、字符及**所有能输入到计算机中并被计算机程序识别(二进制0和1)**和处理的符号的集合。数据是计算机程序加工的原料</p> <p><strong>数据元素</strong>是数据的基本单位，通常作为一个整体进行考虑和处理</p> <p>一个数据元素可由若干<strong>数据项</strong>组成，数据项是构成数据元素的不可分割的最小单位</p> <p><strong>结构</strong>是各个元素之间的关系</p> <p><strong>数据结构</strong>是相互之间存在一种或多种特定关系的数据元素的集合</p> <p><strong>数据对象</strong>是具有相同性质的数据元素的集合，是数据的一个子集</p> <h1 id="存储结构">存储结构</h1> <p>集合：各个元素同属一个集合，别无其他关系</p> <p>线性结构：数据元素之间是一对一的关系，除了第一个元素，所有元素都有前置元素；除了最后一个元素，所有元素都有后置元素</p> <p>树形结构：数据元素之间是一对多的关系</p> <p>图结构：数据元素之间是多对多的关系</p> <p>顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元，元素之间的关系由存储单元的邻接关系来提现</p> <p>链式存储：逻辑上相邻的元素在物理位置上可以不相邻，借助指示元素存储地址的指针来表示元素之间的逻辑关系</p> <p>索引存储：在存储元素信息的同时，还建立附加的索引表。索引表中的每项称为索引项，索引项的一般形式是（关键字，地址）</p> <p>散列存储：根据元素的关键字直接计算出该元素的存储地址，又称哈希（Hash）存储</p> <h1 id="算法">算法</h1> <p>程序 = 数据结构 + 算法</p> <p>数据结构：如何用数据正确地描述现实世界的问题，并存入计算机</p> <p>算法：如何高效地处理这些数据，以解决实际问题</p> <p>算法是对特定问题求解步骤的一种描述，它是指令的有限序列，其中的每条指令表示一个或多个操作</p> <h2 id="特性">特性</h2> <ul> <li> <p>有穷性。一个算法必须总在有穷步之后结束，且每一步都可在有穷时间内完成。</p> <ul> <li>注：算法必须是有穷的，而程序可以是无穷的</li> </ul> </li> <li> <p>确定性。算法中每条指令必须有确切的含义，对于相同的输入只能得出相同的输出</p> </li> <li> <p>可行性。算法中描述的操作都可以通过已经实现的基本运算执行有限次来实现。</p> </li> <li> <p>输入。一个算法有零个或多个输入，这些输入取自某个特定的对象的集合</p> </li> <li> <p>输出。一个算法有一个或多个输出，这些输出是与输入有着特定关系的量</p> </li> </ul> <h2 id="度量">度量</h2> <h3 id="时间复杂度">时间复杂度</h3> <p>如果我们想统计一种功能或者一种算法的使用时间，一般都称这里的时间是：<strong>时间复杂度</strong></p> <p>那么，通常计算这个时间，都是让算法先运行，事后统计运行时间</p> <p>但是这种方案存在一些问题</p> <ul> <li>和机器性能有关，越好的机器处理速度越快</li> <li>和编程语言有关，越高级的语言执行效率越低</li> <li>和编译程序产生的机器指令质量有关</li> <li>有些算法是不能事后再统计的，如：导弹控制算法</li> </ul> <p>算法的时间复杂度，通常是通过事前预估算法时间开销T(n)与问题规模n的关系(T表示“time”)</p> <p>时间复杂度可以只考虑阶数高的部分</p> <p>加法规则</p> <p>多项相加，只保留最高阶的项，且系数变为1，譬如O(n) + O(1)，那么只会保留O(n)</p> <p>常见数量集(从左到右依次递增)</p> <p><img src="https://b.1wind.cn/2025/06/d1642e31fa8b8c2d8e83e50bb656c9fd.png" alt="image-20250601204453712"></p> <p>三种复杂度</p> <ul> <li>最坏时间复杂度：考虑输入数据“最坏”的情况</li> <li>平均时间复杂度：考虑所有输入数据都等概率出现的情况</li> <li>最好时间复杂度：考虑输入数据“最好”的情况</li> </ul> <p>通常只考虑最坏时间复杂度和平均时间复杂度的情况</p> <h3 id="空间复杂度">空间复杂度</h3> <p>无论问题规模怎么变，算法运行所需的内存空间都是固定的常量，算法空间复杂度为S(n) = O(1)</p> <p>注：S表示“Space”</p> <h1 id="表">表</h1> <h2 id="线性表">线性表</h2> <p>定义：数据结构</p> <p>基本操作：运算</p> <p>注：数据结构三要素—逻辑结构、数据的运算、存储结构（物理结构） 存储结构不同，运算的实现方式不同</p> <h3 id="定义">定义</h3> <p>线性表是具有相同(每个数据元素所占空间一样大)数据类型的n(n>=0)个数据元素的有限序列(有次序)，其中n为表长，当n=0时线性表是一个<strong>空表</strong>。若用L命名线性表，则一般表示为->L={a1,a2,ai,ai+1,…,an}</p> <p>几个概念：</p> <p>ai是线性表中的“第i个”元素线性表中的<strong>位序</strong></p> <p>a1是<strong>表头元素</strong>，an是<strong>表尾元素</strong></p> <p>除第一个元素外，每个元素有且仅有一个<strong>直接前驱</strong>；除最后一个元素外，每个元素有且仅有一个<strong>直接后继</strong></p> <h3 id="基本操作">基本操作</h3> <p>InitList(&#x26;L)：初始化表。构造一个空的线性表L，分配内存空间</p> <p>DestroyList(&#x26;L)：销毁操作。销毁线性表，并释放线性表L所占用的内存空间(从无到有，从有到无)</p> <p>ListInsert(&#x26;L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e</p> <p>ListDelete(&#x26;L,i,&#x26;e)：删除操作。删除表L中的第i个位置的元素，并用e返回删除元素的值</p> <p>LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素</p> <p>GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值</p> <p>其他常用操作：</p> <p>Length(L)：求表长。返回线性表L的长度，即L中数据元素的个数</p> <p>PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值</p> <p>Empty(L)：判空操作。若L为空表，则返回true，否则返回false</p> <h2 id="顺序表">顺序表</h2> <h3 id="定义-1">定义</h3> <p>线性表是具有<strong>相同</strong>(每个数据元素所占空间一样大)数据类型的n(n>=0)个数据元素的有限序列</p> <p>顺序表—用<strong>顺序存储</strong>的方式实现线性表顺序存储</p> <p>把<strong>逻辑相邻</strong>的元素存储在<strong>物理位置上也相邻</strong>的存储单元中，元素之间的关系由存储单元的邻接关系来提现</p> <p>通常来说，元素位置一般这样计算：</p> <p>LOC->起始位置</p> <p>n->第n个数</p> <p>size->数据元素大小</p> <p>第n个值的位置->LOC(L) + (n-1) * size</p> <h3 id="动态分配">动态分配</h3> <p>声明结构体及头文件</p> <div class="expressive-code"><link rel="stylesheet" href="/_astro/ec.zq8gl.css"><script type="module" src="/_astro/ec.8zarh.js"></script><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#include</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#566D35;--1:#C3E88D">stdlib.h</span><span style="--0:#256F74;--1:#89DDFF">></span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitSize</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">10</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 默认的最大长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 指示动态分配数组的指针,这里的int可以改为任意的elementType，当然，后面对应的参数也需要同步修改</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> MaxSize</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 顺序表最大容量</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 顺序表的当前长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">}SeqList</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#include <stdlib.h>#define InitSize 10 // 默认的最大长度typedef struct{ // 指示动态分配数组的指针,这里的int可以改为任意的elementType，当然，后面对应的参数也需要同步修改 int *data; int MaxSize; // 顺序表最大容量 int length; // 顺序表的当前长度}SeqList;"><div></div></button></div></figure></div> <p>初始化列表</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitList</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SeqList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 用malloc 函数申请一片连续的存储空间</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化容量*类型大小 = 总空间</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">InitSize</span><span style="--0:#256F74;--1:#89DDFF">*sizeof(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 声明数组长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 声明最大容量</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">MaxSize</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> InitSize</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="void InitList(SeqList &#x26;L){ // 用malloc 函数申请一片连续的存储空间 // 初始化容量*类型大小 = 总空间 L.data = (int *)malloc(InitSize*sizeof(int)); // 声明数组长度 L.length = 0; // 声明最大容量 L.MaxSize = InitSize;}"><div></div></button></div></figure></div> <p>增加动态数组的长度</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">IncreaseSize</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SeqList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">len</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 将旧数据copy</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 开辟新空间</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">((</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">MaxSize</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178">len</span><span style="--0:#256F74;--1:#89DDFF">)*sizeof(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 将数据复制到新区域</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">MaxSize</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">MaxSize</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178"> len</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将顺序表最大长度增加len</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">free</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 释放旧空间</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="void IncreaseSize(SeqList &#x26;L,int len){ // 将旧数据copy int *p = L.data; // 开辟新空间 L.data = (int *)malloc((L.MaxSize+len)*sizeof(int)); for (int i=0;i < L.length;i++){ // 将数据复制到新区域 L.data[i] = p[i] } L.MaxSize = L.MaxSize + len; // 将顺序表最大长度增加len free(p); // 释放旧空间}"><div></div></button></div></figure></div> <p>main函数启动</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">main</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">SeqList L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //声明顺序表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InitList</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //初始化顺序表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 插入元素...</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">IncreaseSize</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">5</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="int main(){ SeqList L; //声明顺序表 InitList(L); //初始化顺序表 // 插入元素... IncreaseSize(L, 5) return 0;}"><div></div></button></div></figure></div> <h3 id="特点">特点</h3> <ol> <li>随机访问,即可以在O(1)时间内找到第i个元素</li> <li>存储密度高,每个节点只存储数据元素</li> <li>拓展容量不方便(即便采用动态分配的方式实现,拓展长度的时间复杂度也比较高)</li> <li>插入、删除操作不方便。需要移动大量元素</li> </ol> <h3 id="基本操作-1">基本操作</h3> <h4 id="插入">插入</h4> <p>ListInsert(&#x26;L,i,e):插入操作。在表L中的第i个位置上插入指定元素e</p> <p>这里采用静态分配方式实现的顺序表</p> <p>静态分配是指在程序编译时，变量或数据结构所需要的内存空间就已经确定，并在程序运行期间保持不变</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MaxSize</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">10</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 定义最大长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">MaxSize</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 用静态的“数组”存放数据元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 顺序表的长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">}SqList</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 顺序表的类型定义</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#define MaxSize 10 // 定义最大长度typedef struct{ ElemType data[MaxSize]; // 用静态的“数组”存放数据元素 int length; // 顺序表的长度}SqList; // 顺序表的类型定义"><div></div></button></div></figure></div> <p><img src="https://b.1wind.cn/2025/06/16ae89cf0664db6d4987f6231a0def62.png" alt="image-20250604143203403"></p> <p>具体操作</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">ListInsert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">--)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将第i个元素及之后的元素后移</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#BE2F2C;--1:#F07178">e</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 在位置i处放入e</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">++;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 长度+1</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="void ListInsert(SqList &#x26;L,int i,int e){ for(int j=L.length;j>=i;j--) // 将第i个元素及之后的元素后移 L.data[j]=L.data[j-1] L.data[i-1]=e; // 在位置i处放入e L.length++; // 长度+1}"><div></div></button></div></figure></div> <p>假设数组L内有元素{1,2,3},希望在第2个位置上插入4</p> <p>那么，当前操作将会先让数组后移，若位置为2，则在索引1的位置上赋值，因为具体数据已经后移了，所以可以直接放入{1,4,2,3},再将长度+1</p> <p>但是这种代码有一定的问题，比如元素满了，索引错误等，这里给出一个相对来说比较好的示例</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">ListInsert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">||</span><span style="--0:#BE2F2C;--1:#F07178"> i </span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 判断i的范围是否有效</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#BE2F2C;--1:#F07178">MaxSize</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 查看当前存储空间是否已满</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">--)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 元素后移</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#BE2F2C;--1:#F07178">e</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 放入e</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">++;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 长度+1</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool ListInsert(SqList &#x26;L,int i,int e){ if (i < 1|| i > L.length+1) // 判断i的范围是否有效 return false; if (L.length>=MaxSize) // 查看当前存储空间是否已满 return false; for(int j=L.length;j>=i;j--) // 元素后移 L.data[j]=L.data[j-1] L.data[i-1]=e; // 放入e L.length++; // 长度+1 return true;}"><div></div></button></div></figure></div> <p><strong>好的算法,应该具有健壮性.能够处理异常情况,并给使用者反馈</strong></p> <h4 id="删除">删除</h4> <p>ListDelete(&#x26;L,i,&#x26;e)：删除操作。删除表L中<strong>第i个</strong>位置的元素，并用e返回删除元素的值</p> <p><img src="https://b.1wind.cn/2025/06/3182ac55d89bccd567d4e3771f6d0ab7.png" alt="image-20250604152226398"></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">ListDelete</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">||</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 判断i的范围是否有效</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">e</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将被删除的元素赋值给e</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">++)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将第i个位置后的元素前移</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">--;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //长度-1</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool ListDelete(SqList &#x26;L,int i,int &#x26;e){ if (i < 1 || i>L.length) // 判断i的范围是否有效 return false; e=L.data[i-1] // 将被删除的元素赋值给e for(int j=i;j<L.length;j++) // 将第i个位置后的元素前移 L.data[j-1]=L.data[j]; L.length--; //长度-1 return true;}"><div></div></button></div></figure></div> <p>假设数组L中有元素{1,2,3},要被删除的是第二个元素，那么e则得到了L.data[1]，则是2</p> <p>将第i个位置后的元素后移，则是2后面的元素前移</p> <p>L.data[1]=Ldata[2],所以3移动到2的位置上，实现删除</p> <h4 id="查找">查找</h4> <p>静态分配及动态分配</p> <p>GetElem(L,i)：按位查找操作。获取表L中<strong>第i个位置</strong>的元素的值</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#4C6690;--1:#82AAFF">GetElem</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqList </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">i</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="ElemType GetElem(SqList L,int i){ return L.data[i-1];}"><div></div></button></div></figure></div> <p>LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在顺序表L中查找第一个元素值等于e的元素，并返回其位序</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">LocateElem</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SeqList </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 在顺序表L中查找第一个元素值等于e的元素，并返回其位序int LocateElem(SeqList L,int e){ for(int i=0;i<L.length;i++) return i+1; return 0;}"><div></div></button></div></figure></div> <h2 id="链表">链表</h2> <h3 id="单链表">单链表</h3> <p>存储结构图如下</p> <img src="https://b.1wind.cn/2025/06/143319fe7daa08e1f75130705c5fe5d0.png" alt="image-20250604204456362" style="zoom:50%;"> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> LNode</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 定义单链表结点类型</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 每个节点存放一个数据元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 指针指向下一个节点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="struct LNode{ // 定义单链表结点类型 ElemType data; // 每个节点存放一个数据元素 struct LNode *next; // 指针指向下一个节点}"><div></div></button></div></figure></div> <ul> <li>LNode：结点</li> <li>data：数据域</li> <li>next：指针域</li> </ul> <p><code>struct LNode *p = (struct LNode*)malloc(sizeof(struct LNode));</code> 增加一个新的结点:在内存中申请一个结点所需空间,并用指针p指向这个结点</p> <p>typedef 是 可以将某些类型改名的一种方式</p> <p>通常<code>typedef 类型 名称</code>->譬如<code>typedef int zhengshu</code>，我们就可以使用<code>zhengshu a = 1;</code>来声明一个整数</p> <p>那么我们也可以<code>typedef struct LNode LNode</code>、<code>typedef struct LNode *LinkList</code></p> <p>此时，要表示一个单链表时，只需声明一个<strong>头指针</strong>L，指向单链表的第一个节点</p> <p><code>LNode * L</code>-><code>声明一个指向单链表第一个节点的指针</code></p> <p><code>LinkList L</code>-><code>声明一个指向单链表第一个节点的指针</code>(代码可读性更强)</p> <p>强调这是一个单链表 —>使用LinkList</p> <p>强调这是一个结点 —>使用LNode*</p> <h4 id="不带头节点">不带头节点</h4> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> LNode</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 定义单链表节点类型</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 每个节点存放一个数据元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //指针指向下一个节点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">LNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//初始化一个空的单链表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitList</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">L </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 空表，暂时还没有任何节点(防止脏数据)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">test</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LinkList L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //声明一个指向单链表的指针(注意，此处并没有创建一个结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//初始化一个空表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InitList</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 判断单链表是否为空</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Empty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">==NULL);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct LNode{ // 定义单链表节点类型 ElemType data; // 每个节点存放一个数据元素 struct LNode *next; //指针指向下一个节点}LNode,*LinkList//初始化一个空的单链表bool InitList(LinkList &#x26;L){ L = NULL; // 空表，暂时还没有任何节点(防止脏数据) return true;}void test(){ LinkList L; //声明一个指向单链表的指针(注意，此处并没有创建一个结点) //初始化一个空表 InitList(L);}// 判断单链表是否为空bool Empty(LinkList L){ return (L==NULL);}"><div></div></button></div></figure></div> <h4 id="带头节点">带头节点</h4> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> LNode</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 定义单链表节点类型</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 每个节点存放一个数据元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //指针指向下一个节点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">LNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//初始化一个单链表(带头节点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitList</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">L </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //分配一个头节点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">L </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //内存不足，分配失败</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //头节点后暂无节点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">test</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LinkList L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //声明一个指向单链表的指针(注意，此处并没有创建一个结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//初始化一个空表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InitList</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct LNode{ // 定义单链表节点类型 ElemType data; // 每个节点存放一个数据元素 struct LNode *next; //指针指向下一个节点}LNode,*LinkList//初始化一个单链表(带头节点)bool InitList(LinkList &#x26;L){ L = (LNode *) malloc(sizeof(LNode)); //分配一个头节点 if (L == NULL) return false; //内存不足，分配失败 L->next = NULL; //头节点后暂无节点 return true;}void test(){ LinkList L; //声明一个指向单链表的指针(注意，此处并没有创建一个结点) //初始化一个空表 InitList(L);}"><div></div></button></div></figure></div> <h4 id="插入-1">插入</h4> <p>ListInsert(&#x26;L,i,e)：插入操作[<strong>携带头节点</strong>]。在表L中的<strong>第i个位置</strong>(找到第i-1个结点，将新结点插入其后)上插入指定元素e</p> <p>定义单链表</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> LNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">LNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct LNode{ ElemType data; struct LNode *next;}LNode,*LinkList;"><div></div></button></div></figure></div> <p>具体实现</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在第i个位置插入元素e(带头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">ListInsert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 如果插入位置不正确，结束，插入位置由1开始</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 指针p指向当前扫描到的结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 当前p指向的是第几个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // L指向头结点，头结点是第0个结点(不存数据)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> j </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 循环找到 i - 1个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 如果i = 1，说明插在表头，不进入循环</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 如果i = 2，说明插入在第二个结点后</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 所以p向下移动，结点位置变更</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">++;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 如果i = 2，说明p此时在1的位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 如果节点元素只有5个,但插入位置在7，此时p == NULL，i值不合法</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> </span></span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">/*当p 在 第五个元素时，p->next就是NULL了</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> </span></span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">我们找到的通常是i-1的位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> </span></span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">这样就可以在最后一个元素的next处添加新元素了*/</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // i值不合法</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">s </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 开辟空间</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> e</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 添加数据</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 让s.next -> p.next</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">26</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">27</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 在第i个位置插入元素e(带头结点)bool ListInsert(LinkList &#x26;L,int i,ElemType e){ if (i < 1) // 如果插入位置不正确，结束，插入位置由1开始 return false; LNode *p; // 指针p指向当前扫描到的结点 int j=0; // 当前p指向的是第几个结点 p = L; // L指向头结点，头结点是第0个结点(不存数据) while(p != NULL &#x26;&#x26; j < i-1){ // 循环找到 i - 1个结点 // 如果i = 1，说明插在表头，不进入循环 // 如果i = 2，说明插入在第二个结点后 // 所以p向下移动，结点位置变更 p = p->next; j++; } // 如果i = 2，说明p此时在1的位置 // 如果节点元素只有5个,但插入位置在7，此时p == NULL，i值不合法 /*当p 在 第五个元素时，p->next就是NULL了 我们找到的通常是i-1的位置 这样就可以在最后一个元素的next处添加新元素了*/ if (p == NULL) return false; // i值不合法 LNode *s = (LNode *)malloc(sizeof(LNode)); // 开辟空间 s->data = e; // 添加数据 s->next=p->next; // 让s.next -> p.next p->next = s; return true;}"><div></div></button></div></figure></div> <p>详细说明该代码过程，并配图</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF">s </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#5A676D;--1:#EEFFFF">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 开辟空间</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> e</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 添加数据</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 让s.next -> p.next</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code=" LNode *s = (LNode *)malloc(sizeof(LNode)); // 开辟空间 s->data = e; // 添加数据 s->next=p->next; // 让s.next -> p.next p->next = s; return true;"><div></div></button></div></figure></div> <p><code> 假设在i = 1添加 那么s.next -> p.next，p此时是头结点，p.next说明p.next = 第一个结点 s.next -> 第一个结点,s去指向了第一个结点，s此时可以算是第一个结点，而原第一个结点变为第二个结点 p.next -> s，此时头结点指向了第一个结点，第一个结点s.next->第二个结点 此时连接成功 i = other时也是同理，这里就不一一举例了，具体可看下图所示</code></p> <p><img src="https://b.1wind.cn/2025/06/668df8ceac4855cf5e6191c8af31b449.png" alt="image-20250605083724292"></p> <p>ListInsert(&#x26;L,i,e):插入操作.在表L中的<strong>第i个位置</strong>(找到第i-1个结点，将新结点插入其后)上插入指定元素e</p> <p>由于不存在头结点(第0个结点)因此i=1时需要特殊处理</p> <p>结构体声明与上述一致,这里就不再赘述了</p> <p>以下是具体代码实现</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">ListInsert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 有效性判断</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 由于没有头结点，第一个结点操作与其他结点操作不同</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">s </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> e</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">L </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> s</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 变为最新结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 指针p指向当前扫描到的结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> j </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 当前p指向第几个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // p指向第一个结点(注意：不是头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">!=NULL</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> j </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">++;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 不合法</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">s </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> e</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">26</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool ListInsert(LinkList &#x26;L,int i,ElemType e){ if (i < 1) // 有效性判断 return false; if(i == 1){ // 由于没有头结点，第一个结点操作与其他结点操作不同 LNode *s = (LNode *)malloc(sizeof(LNode)); s->data = e; s->next = L; L = s; // 变为最新结点 return true; } LNode *p; // 指针p指向当前扫描到的结点 int j = 1; // 当前p指向第几个结点 p = L; // p指向第一个结点(注意：不是头结点) while(p!=NULL &#x26;&#x26; j < i-1){ p=p->next; j++; } if (p == NULL) return false; // 不合法 LNode *s = (LNode *)malloc(sizeof(LNode)); s->data = e; s->next=p->next; p->next;s; return true;}"><div></div></button></div></figure></div> <p>只有第一个结点有差别</p> <p><strong>前插操作</strong></p> <p>如果我们想在某个结点前插入一个结点,该怎么做呢?</p> <p>直接贴代码</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在p结点前插入元素e</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InsertPriorNode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF"> ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 条件判断</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">s </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 内存分配失败</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">e</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 在p结点前插入元素ebool InsertPriorNode(LNode *p, ElemType e){ if (p==NULL) // 条件判断 return false; LNode *s = (LNode *)malloc(sizeof(LNode)); if (s==NULL) // 内存分配失败 return false s->next=p->next; p->next=s; s->data=p->data; p->data=e; return true;}"><div></div></button></div></figure></div> <p>详细介绍此处的内容</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">e</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code=" s->next=p->next; p->next=s; s->data=p->data; p->data=e; return true;"><div></div></button></div></figure></div> <p>将s的下一个结点指向p的下一个结点，此时s就连接了p的下一个结点，p去指向了s</p> <p>具体情况如下 p -> s -> p.next</p> <p>此时已经互连了,想实现前插操作,就将两边的数据互换</p> <p>p.data = s.data,s.data = p.data，也就意味着s -> p -> p.next</p> <p>这样的时间复杂度是O(1)</p> <h4 id="删除-1">删除</h4> <p>ListDelete(&#x26;L,i,&#x26;e)：删除操作。删除表L中第i个位置(找到第i-1个结点，将其指针指向第i+1结点，并释放第i个结点)的元素，并用e返回删除元素的值</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">ListDelete</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 执行p扫描到的结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> j </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //当前p指向的是第几个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //L指向头结点，头结点是第0个结点(不存数据)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> j </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 直到找到i-1个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">++;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // i值不合法</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // i - 1个结点后无其他结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">q </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //q指向被删除的结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">e </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 获取值</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 结点断开(删除)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">free</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">q</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 释放结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool ListDelete(LinkList &#x26;L,int i,ElemType &#x26;e){ if (i < 1) return false; LNode *p; // 执行p扫描到的结点 int j = 0; //当前p指向的是第几个结点 p = L; //L指向头结点，头结点是第0个结点(不存数据) while (p != NULL &#x26;&#x26; j < i-1){ // 直到找到i-1个结点 p = p->next; j++; } if (p==NULL) return false; // i值不合法 if (p->next == NULL) return false; // i - 1个结点后无其他结点 LNode *q = p->next; //q指向被删除的结点 e = q->data; // 获取值 p->next = q->next; // 结点断开(删除) free(q); // 释放结点 return true;}"><div></div></button></div></figure></div> <p>删除指定结点p</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">DeleteNode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">q </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 令q指向p的后继结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p </span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#BE2F2C;--1:#F07178"> data</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 与后继结点交换数据域</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">q </span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 断开结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">free</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">q</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool DeleteNode(LNode *p){ if (p==NULL) return false; LNode *q = p->next; // 令q指向p的后继结点 p->data = p -> next -> data // 与后继结点交换数据域 p->next = q -> next; // 断开结点 free(q); return true;}"><div></div></button></div></figure></div> <p>譬如想删除p，那么我们让q指向p->next</p> <p>p的数据变成p下一个节点的数据，p的下一个节点，变成q的下一个节点</p> <p>因为数据交换了，相当于p成了下一个节点，再让p去指向之前的q，因为q是p的下一个节点</p> <p>那么q的下一个节点，就是如今p的next了，此时原先的p就被删除了</p> <p>则q -> p.next，p.data = p.next.data,p.next = q.next</p> <p>如果p是最后一个节点，此时只能从表头开始寻找，不然会出现问题</p> <p>因为p->next->data会出现问题，这里会有<strong>NULL.data！！！</strong></p> <h4 id="查找-1">查找</h4> <p>本节仅探讨带头结点的情况</p> <p><strong>按位查找</strong></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 按位查找,返回第i个元素(带头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">GetElem</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">i</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 指针p指向当前扫描到的结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 当前p指向的是第几个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // L指向头结点，头节点是第0个结点(不存数据)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 循环找到第i个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">++;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> p</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 按位查找,返回第i个元素(带头结点)LNode * GetElem(LinkList L,int i){ if (i < 0) return NULL; LNode *p; // 指针p指向当前扫描到的结点 int j=0; // 当前p指向的是第几个结点 p = L; // L指向头结点，头节点是第0个结点(不存数据) while(p != NULL &#x26;&#x26; j<i){ // 循环找到第i个结点 p=p->next; j++; } return p;}"><div></div></button></div></figure></div> <p><strong>按值查找</strong></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">LocateElem</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 获取第一个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> e</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 当p不为空并且p的数据不为查找值时</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 向下查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> p</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="LNode * LocateElem(LinkList L,ElemType e){ LNode *p = L->next; // 获取第一个结点 while(p != NULL &#x26;&#x26; p->data != e) // 当p不为空并且p的数据不为查找值时 p = p->next; // 向下查找 return p;}"><div></div></button></div></figure></div> <h4 id="建立">建立</h4> <p><strong>尾插法初始化带头结点的单链表</strong></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#4C6690;--1:#82AAFF">List_TailInsert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 正向建立单链表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> x</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 设ElemType为整型</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#BE2F2C;--1:#F07178">LinkList</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 建立投结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#BE2F2C;--1:#F07178">r </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // r为表尾指针,s为新结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">scanf</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#BE2F2C;--1:#F07178">%d</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#256F74;--1:#89DDFF">,&#x26;</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 输入新结点的值</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#A64930;--1:#F78C6C">9999</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 输入9999表示结束</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 创建新结点的空间</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> x</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 赋值新结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">r</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 表尾指针指向新结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">r</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 表尾指针指向表尾</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">scanf</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#BE2F2C;--1:#F07178">%d</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#256F74;--1:#89DDFF">,&#x26;</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 继续输入</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">r</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 尾结点指针置空</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="LinkList List_TailInsert(LinkList &#x26;L){ // 正向建立单链表 int x; // 设ElemType为整型 L=(LinkList)malloc(sizeof(LNode)); // 建立投结点 LNode *s,*r = L; // r为表尾指针,s为新结点 scanf(&#x22;%d&#x22;,&#x26;x); // 输入新结点的值 while (x!=9999){ // 输入9999表示结束 s=(LNode *)malloc(sizeof(LNode)); // 创建新结点的空间 s->data = x; // 赋值新结点 r->next=s; // 表尾指针指向新结点 r=s; // 表尾指针指向表尾 scanf(&#x22;%d&#x22;,&#x26;x); // 继续输入 } r->next = NULL; // 尾结点指针置空 return L;}"><div></div></button></div></figure></div> <p>举个栗子：</p> <p>刚开始初始化的情况如下：r,s(头结点) -> NULL</p> <p>假设第一次要输入10</p> <ul> <li>r(头结点) -> s(10)</li> <li>头结点 -> r,s(10)</li> </ul> <p>第二次输入15</p> <ul> <li>头结点 -> r,s(10) -> s(15)</li> <li>头结点 -> s(10) -> r,s(15)</li> </ul> <p>第三次输入20</p> <ul> <li>头结点 -> s(10) -> r,s(15) -> s(20)</li> <li>头结点 -> s(10) -> s(15) -> r,s(20)</li> </ul> <p>第四次输入9999结束</p> <p>头结点 -> s(10) -> s(15) -> r,s(20) -> NULL</p> <p>return L -> end;</p> <p><strong>头插法初始化带头结点的单链表</strong></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#4C6690;--1:#82AAFF">List_HeadInsert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 逆向建立单链表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> x</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#BE2F2C;--1:#F07178">LinkList</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 创建头结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化为空链表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">scanf</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#BE2F2C;--1:#F07178">%d</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#256F74;--1:#89DDFF">,&#x26;</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 输入结点的值</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#A64930;--1:#F78C6C">9999</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 创建新结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">scanf</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#BE2F2C;--1:#F07178">%d</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#256F74;--1:#89DDFF">,&#x26;</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="LinkList List_HeadInsert(LinkList &#x26;L){ // 逆向建立单链表 LNode *s; int x; L=(LinkList)malloc(sizeof(LNode)); // 创建头结点 L->next=NULL; // 初始化为空链表 scanf(&#x22;%d&#x22;,&#x26;x); // 输入结点的值 while(x!=9999){ s=(LNode*)malloc(sizeof(LNode)); // 创建新结点 s->data=x; s->next=L->next; L->next=s; scanf(&#x22;%d&#x22;,&#x26;x); } return L;}"><div></div></button></div></figure></div> <p>这里就简单一些了</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#5A676D;--1:#EEFFFF">LNode</span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#5A676D;--1:#EEFFFF">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 创建新结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">x</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">scanf</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#BE2F2C;--1:#F07178">%d</span><span style="--0:#256F74;--1:#89DDFF">"</span><span style="--0:#256F74;--1:#89DDFF">,&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code=" s=(LNode*)malloc(sizeof(LNode)); // 创建新结点 s->data=x; s->next=L->next; L->next=s; scanf(&#x22;%d&#x22;,&#x26;x);"><div></div></button></div></figure></div> <p>具体叙述一下这里的情况</p> <ol> <li>创建新结点</li> <li>新结点指向头结点的下一个数据，即第一个结点</li> <li>头结点指向新结点</li> </ol> <p>其实就是在第一个结点前，让新结点->next 指向 第一个结点，那么新结点就在第一个位置了，再让头结点->next指向新结点就行了</p> <h3 id="双链表">双链表</h3> <h4 id="带头结点">带头结点</h4> <p>构建结构体</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> DNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> DNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">prior</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#BE2F2C;--1:#F07178">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">DNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF">DLinkList</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct DNode{ ElemType data; struct DNode *prior,*next;}DNode,*DLinkList;"><div></div></button></div></figure></div> <p>DNode * = DLinkList</p> <p>初始化双链表</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitDLinkList</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">DLinklist </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">L </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">DNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">DNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 分配一个头结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 头结点的prior永远指向NULL</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 头结点之后暂时没有结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool InitDLinkList(DLinklist &#x26;L){ L = (DNode *)malloc(sizeof(DNode)); // 分配一个头结点 if (L==NULL) return false; L->prior = NULL; // 头结点的prior永远指向NULL L->next = NULL; // 头结点之后暂时没有结点 return true;}"><div></div></button></div></figure></div> <h4 id="插入-2">插入</h4> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在p结点之后插入s结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InsertNextDNode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">DNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">DNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">s</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">||</span><span style="--0:#BE2F2C;--1:#F07178"> s </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 非法参数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 如果p结点存在后继结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 在p结点之后插入s结点bool InsertNextDNode(DNode *p,DNode *s){ if (p == NULL || s == NULL) // 非法参数 return false; s->next=p->next; if (p->next != NULL) // 如果p结点存在后继结点 p->next->prior=s; s->prior=p; p->next=s; return true}"><div></div></button></div></figure></div> <p>先让s的下一个结点去指向p原先的下一个结点，即s 的下一个结点为 p.next</p> <p>如果p存在后继结点，那么让p的后继结点的前结点为s，如果不存在，说明p是最后一个结点，则无需指向s</p> <p>最后让s的前结点变为p，p的后继结点变为s</p> <h4 id="删除-2">删除</h4> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 删除p结点的后继结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">DeleteNextDNode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">DNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">DNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">q </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 找到p的后继结点q</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">q</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // p没有后继</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // p去跳过q这个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">!=NULL)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // q不是最后一个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 那么q的下一个结点的上一个指向为p</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">free</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">q</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 释放空间</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 删除p结点的后继结点bool DeleteNextDNode(DNode *p){ if (p==NULL) return false; DNode *q = p->next; // 找到p的后继结点q if (q==NULL) return false; // p没有后继 p->next=q->next; // p去跳过q这个结点 if(q->next!=NULL) // q不是最后一个结点 q->next->prior=p; // 那么q的下一个结点的上一个指向为p free(q); // 释放空间 return true;}"><div></div></button></div></figure></div> <h4 id="遍历">遍历</h4> <p>查找等其他操作，都建立在遍历的基础上</p> <p><strong>后向遍历</strong></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">!=NULL){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="while (p!=NULL){ p=p->next}"><div></div></button></div></figure></div> <p><strong>前向遍历</strong></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">!=NULL){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="while (p!=NULL){ p=p->prior}"><div></div></button></div></figure></div> <p><strong>前向遍历(跳过头结点)</strong></p> <p>只要prior不为空，说明还没到头结点，如果为空，说明已经是头结点了，因为头结点的prior==NULL</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span><span style="--0:#256F74;--1:#89DDFF">!=NULL){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="while (p->prior!=NULL){ p=p->prior}"><div></div></button></div></figure></div> <h3 id="循环单链表">循环单链表</h3> <p>结构定义</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> LNode</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 订阅单链表结点类型</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 下一个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">LNode</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct LNode{ // 订阅单链表结点类型 ElemType data; // 元素 struct LNode *next; // 下一个结点}LNode, *LinkList;"><div></div></button></div></figure></div> <p>初始化循环单链表</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitList</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">L </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 分配一个头结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 内存不足</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 头结点next指向头结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool InitList(LinkList &#x26;L){ L = (LNode *)malloc(sizeof(LNode)); // 分配一个头结点 if (L==NULL) return false; // 内存不足 L->next = L; // 头结点next指向头结点 return true;}"><div></div></button></div></figure></div> <p>判断链表是否为空</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Empty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> L</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool Empty(LinkList L){ if (L->next == L) return true; else return false;}"><div></div></button></div></figure></div> <p>如果只有L自己，说明是空</p> <p>判断结点p是否为循环单链表的表尾结点</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">isTail</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkList </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178">L</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool isTail(LinkList L,LNode *p){ if (p->next==L) return true; else return false;}"><div></div></button></div></figure></div> <p>如果p的下一个结点是头结点，说明是表尾了</p> <h3 id="循环双链表">循环双链表</h3> <p>相当于闭环的双链表</p> <p>表头结点的prior指向表尾结点；</p> <p>表尾结点的next指向头结点；</p> <h4 id="插入-3">插入</h4> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在p结点之后插入s结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InsertNextDNode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">DNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">DNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">s</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将s插入到p之后</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 在p结点之后插入s结点bool InsertNextDNode(DNode *p,DNode *s){ s->next=p->next; // 将s插入到p之后 p->next->prior=s; s->prior=p; p->next=s;}"><div></div></button></div></figure></div> <p>举例说明(如图所示)：</p> <p>最麻烦的只有上面两句</p> <p>解释一下，s->next=p->next，其实就是s的下一个结点是p的下一个结点，那么，s的下一个结点就拿到了p后面的值</p> <p>p的下一个结点的上一个选择是s，其实一样的道理，因为p下一个结点只会有值，它是循环的链表</p> <p>如果p是最后一个值，那么它的prior就是head，而head原先的prior是p，因为p是最后一个结点，也就是说，head替换了prior，将prior改为s，如果p不是最后一个值，那么其实就是将p的下一个结点的上一个结点的prior改为s，此时，s的下一个结点是p->next，p->next->prior是s，最后两行就是让p和s互相加一下线即可</p> <img src="https://b.1wind.cn/2025/06/c4e9a5becc3dac35676cde8711e61fca.png" alt="image-20250606162723888" style="zoom: 50%;"> <h4 id="删除-3">删除</h4> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//删除p的后继结点q</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">prior</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#4C6690;--1:#82AAFF">free</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="//删除p的后继结点qp->next=q->next;q->next->prior=p;free(q);"><div></div></button></div></figure></div> <p>p后面的结点直接跳过q，变成q后面的结点，q后面的结点的前置变为p，也就是跳过q，最后释放q</p> <h3 id="静态链表">静态链表</h3> <p>静态链表：分配一整片连续的内存空间，各个结点集中安置</p> <p>0号结点充当“头结点”</p> <p>下一个结点的数组下标表示游标</p> <p>游标为-1表示已经到达表尾，游标充当指针</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MaxSize</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">10</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 静态链表的最大长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 静态链表结构类型的定义</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 存储数据元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 下一个元素的数组下标</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">SLinkList</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">MaxSize</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#define MaxSize 10 // 静态链表的最大长度typedef struct{ // 静态链表结构类型的定义 ElemType data; // 存储数据元素 int next; // 下一个元素的数组下标}SLinkList[MaxSize];"><div></div></button></div></figure></div> <p>等价于</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MaxSize</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">10</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> Node</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> Node SLinkList</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">MaxSize</span><span style="--0:#256F74;--1:#89DDFF">]</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#define MaxSize 10struct Node{ ElemType data; int next;}typedef struct Node SLinkList[MaxSize]"><div></div></button></div></figure></div> <p>typedef是别名的意思，如果我们声明SLinkList a;那么这里的a相当于<code>Node a[MaxSize]</code>的数组，有10个元素的结构体数组</p> <p>查找：从头结点出发挨个往后遍历结点</p> <p>插入位序为i的结点：</p> <ol> <li>找到一个空的结点，存入数据元素</li> <li>从头结点出发找到位序为i-1的结点</li> <li>修改新结点的next为-1</li> <li>修改i-1号结点的next</li> </ol> <p>删除某个结点：</p> <ol> <li>从头结点出发找到前驱结点</li> <li>修改前驱结点的游标</li> <li>被删除结点next设为-2，即特殊数值充当空闲结点</li> </ol> <p>静态链表：用数组方式实现的链表</p> <h1 id="栈">栈</h1> <p>栈(Stack)是只允许在一端进行插入或删除操作的线性表</p> <p>栈顶：允许插入和删除的一端</p> <p>栈底：不允许插入和删除的一端</p> <h2 id="初始化">初始化</h2> <p>构建结构体</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MaxSize</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">10</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 定义栈中元素的最大个数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#5A676D;--1:#EEFFFF"> </span></span><span style="--0:#5A676D;--1:#EEFFFF">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">MaxSize</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 静态数组存放栈中元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> top</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 栈顶指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">}SqStack</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#define MaxSize 10 // 定义栈中元素的最大个数typedef struct{ ElemType data[MaxSize]; // 静态数组存放栈中元素 int top; // 栈顶指针}SqStack;"><div></div></button></div></figure></div> <p>初始化栈</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitStack</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqStack </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#256F74;--1:#89DDFF">=-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="void InitStack(SqStack &#x26;S){ S.top=-1;}"><div></div></button></div></figure></div> <p>判断栈空</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">StackEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqStack </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#256F74;--1:#89DDFF">==-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool StackEmpty(SqStack S){ return S.top==-1;}"><div></div></button></div></figure></div> <h2 id="进栈">进栈</h2> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Push</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqStack </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> MaxSize</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 栈满，报错</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> x</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool Push(SqStack &#x26;S,ElemType x){ if (S.top == MaxSize-1) // 栈满，报错 return false; S.top = S.top + 1; S.data[S.top] = x; return true;}"><div></div></button></div></figure></div> <h2 id="出栈">出栈</h2> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Pop</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqStack </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#256F74;--1:#89DDFF">==-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 栈空</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 栈顶元素先出栈</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 指针减1</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool Pop(SqStack &#x26;S,ElemType &#x26;x){ if (S.top==-1) return false; // 栈空 x=S.data[S.top]; // 栈顶元素先出栈 S.top=S.top-1; // 指针减1 return true;}"><div></div></button></div></figure></div> <p>数据依然保存在内存中，但是在逻辑上删除了</p> <h2 id="读栈顶元素">读栈顶元素</h2> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">GetTop</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqStack </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">top</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool GetTop(SqStack S,ElemType &#x26;x){ if (S.top == -1) return false; x=S.data[S.top]; return true;}"><div></div></button></div></figure></div> <h2 id="链式存储实现">链式存储实现</h2> <p>添加结点</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InsertNextNode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">e</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">s </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">LNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LNode</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 创建结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> e</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool InsertNextNode(LNode *p,ElemType e){ if (p==NULL) return false; LNode *s = (LNode *)malloc(sizeof(LNode)); // 创建结点 if (s==NULL) return false; s->data = e; s->next=p->next; p->next=s; return true;}"><div></div></button></div></figure></div> <h1 id="队列">队列</h1> <p>队列（Queue)是只允许在一端进行插入，在另一端删除的<strong>线性表</strong></p> <p>特点：先进入队列的元素先出队列（先进先出FIFO）</p> <p>队头：允许删除的一端</p> <p>队尾：允许插入的一端</p> <h2 id="顺序实现">顺序实现</h2> <h3 id="初始化-1">初始化</h3> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MaxSize</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">10</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType </span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">MaxSize</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 用静态数组存放队列元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> front</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">rear</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 队头指针和队尾指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">SqQueue</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化队列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Squeue </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化时 队头队尾指针指向0</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">testQueue</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 声明一个队列(顺序存储)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">SqQueue Q</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InitQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 判断队列是否为空</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">QueueEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqQueue </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#define MaxSize 10typedef struct{ ElemType data[MaxSize]; // 用静态数组存放队列元素 int front,rear; // 队头指针和队尾指针}SqQueue;// 初始化队列void InitQueue(Squeue &#x26;Q){ // 初始化时 队头队尾指针指向0 Q.rear=Q.front=0;}void testQueue(){ // 声明一个队列(顺序存储) SqQueue Q; InitQueue(Q);}// 判断队列是否为空bool QueueEmpty(SqQueue Q){ if (Q.rear==Q.front) return true; else return false;}"><div></div></button></div></figure></div> <h3 id="入队">入队</h3> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">EnQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqQueue </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">((</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">%</span><span style="--0:#BE2F2C;--1:#F07178"> MaxSize </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 判断队满</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> x</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 新元素插入队尾</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">%</span><span style="--0:#BE2F2C;--1:#F07178"> MaxSize</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 队尾指针+1取模</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool EnQueue(SqQueue &#x26;Q,ElemType x){ if ((Q.rear + 1) % MaxSize == Q.front) // 判断队满 return false; Q.data[Q.rear] = x; // 新元素插入队尾 Q.rear=(Q.rear + 1) % MaxSize; // 队尾指针+1取模}"><div></div></button></div></figure></div> <p>通过模运算将存储空间在逻辑上变成了环状</p> <p>举个栗子：假设有队列3个元素,那么我们模拟一下入队的效果</p> <p>因为front和rear一开始都是在一个位置，那么通过该方法，先判断是否队满，那么队尾+1取余最大值3，结果是1，与front不同，所以队列未满，将元素插入队尾，并将队尾指针后移，此时rear是1</p> <p>第二次也是同理，说说第三次，第三次时rear是2,rear + 1 取余3，结果为0，与front相同，说明队满</p> <p>为什么只存了两个元素就队满呢，因为rear = front是判断队列是否为空的，若让rear = front，此时队列会为空，就不好做后续操作了，目前只能按照取余法，牺牲一个存储单位来判断</p> <p><strong>第二种方案</strong>，新加一个变量size，专门用来记录队列长度，入队size++，出队size—，当size==MaxSize时队满，size==0时队空</p> <p><strong>第三种方案</strong>，新加一个变量tag，用来标记是删除还是插入操作， 初始化时tag为0，每次删除操作成功后，都令tag=0，每次插入操作成功后，都令tag=1；队满条件：front == rear &#x26;&#x26; tag == 1，因为只有插入操作，才可能导致队满，因为上一次是插入操作，而此时front == rear，所以队满；队空条件：front == rear &#x26;&#x26; tag == 0，如果是删除操作，才可能导致队空，因为上一次是删除操作，所以队空</p> <h3 id="出队">出队</h3> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 出队（删除一个队头元素，并用x返回）</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">DeQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SQueue </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 队空报错</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 获取队头元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">%</span><span style="--0:#BE2F2C;--1:#F07178"> MaxSize</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 出队（删除一个队头元素，并用x返回）bool DeQueue(SQueue &#x26;Q,ElemType &#x26;x){ if (Q.rear == Q.front) return false; // 队空报错 x=Q.data[Q.front]; // 获取队头元素 Q.front = (Q.front + 1) % MaxSize;}"><div></div></button></div></figure></div> <p>举个栗子：假设有队列3个元素,那么我们模拟一下出队的效果</p> <p>先判断是否为空，其实是队尾和队头相同时，我们假设队头为0，队尾为2，先进行一次出队看看，那么先判断队列，不为空，获取元素，front + 1，此时front为1</p> <p>如果再获取一次，那么队头和队尾就相同了，所以我们进行一次入队操作，因为此时front = 1，rear = 2，那么判断rear + 1 取余 3，结果为0，与front不相同，说明此时队未满，那么2的位置插入一个元素，并且rear + 1是3，对MaxSize取余，循环回到0的位置，那么下一次若队列未满，也可继续进行入队操作</p> <p>如果想获取队头元素，只需要移除出队操作中的~~Q.front = (Q.front + 1) % MaxSize;~~即可，不让队头元素后移</p> <p>队列元素个数：(rear + MaxSize - front) % MaxSize</p> <h2 id="链式存储">链式存储</h2> <h3 id="初始化-2">初始化</h3> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> LinkNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> LinkNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">next</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LinkNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">front</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178"> rear</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">LinkQueue</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化队列(带头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkQueue </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化时 front、rear都指向头结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">LinkNode</span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LinkNode</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front </span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">testLinkQueue</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LinkQueue Q</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 声明一个队列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InitQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化队列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//判断队列是否为空</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">IsEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkQueue </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">26</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">27</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">28</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct LinkNode{ ElemType data; struct LinkNode *next;}typedef struct{ LinkNode *front, * rear;}LinkQueue;// 初始化队列(带头结点)void InitQueue(LinkQueue &#x26;Q){ // 初始化时 front、rear都指向头结点 Q.front = Q.rear = (LinkNode*)malloc(sizeof(LinkNode)); Q.front ->next = NULL;}void testLinkQueue(){ LinkQueue Q; // 声明一个队列 InitQueue(Q); // 初始化队列}//判断队列是否为空bool IsEmpty(LinkQueue Q){ if(Q.front == Q.rear) return true; else return false;}"><div></div></button></div></figure></div> <p>不带头结点</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化队列(不带头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkQueue </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化时 front、rear都指向NULL</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//判断队列是否为空(不带头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">IsEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkQueue </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 初始化队列(不带头结点)void InitQueue(LinkQueue &#x26;Q){ // 初始化时 front、rear都指向NULL Q.front=NULL; Q.rear=NULL;}//判断队列是否为空(不带头结点)bool IsEmpty(LinkQueue Q){ if (Q.front == NULL) return true; else return false;}"><div></div></button></div></figure></div> <h3 id="入队-1">入队</h3> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 新元素入队(带头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">EnQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkQueue </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LinkNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#BE2F2C;--1:#F07178">LinkNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LinkNode</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将新结点插入到rear之后</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">s</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 修改表尾指针为最新值</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 新元素入队(带头结点)void EnQueue(LinkQueue &#x26;Q,ElemType x){ LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode)); s->data=x; s->next=NULL; Q.rear->next=s; // 将新结点插入到rear之后 Q.rear=s; // 修改表尾指针为最新值}"><div></div></button></div></figure></div> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 新元素入队(不带头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">EnQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkQueue </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LinkNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">s </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">LinkNode </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">LinkNode</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">s</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 因为不带头结点的空队列，rear和front都是默认指向NULL的</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> s</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 所以第一个元素需要特别处理，让front和rear同时指向第一个元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> s</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> s</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 新结点插入到rear后</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> s</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 修改rear为最新结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 新元素入队(不带头结点)void EnQueue(LinkQueue &#x26;Q,ElemType x){ LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode)); s->data=x; s->next=NULL; if (Q.front == NULL){ // 因为不带头结点的空队列，rear和front都是默认指向NULL的 Q.front = s; // 所以第一个元素需要特别处理，让front和rear同时指向第一个元素 Q.rear = s; } else{ Q.rear->next = s; // 新结点插入到rear后 Q.rear = s; // 修改rear为最新结点 }}"><div></div></button></div></figure></div> <h3 id="出队-1">出队</h3> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 队头元素出队(不带头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">DeQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkQueue </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 空队列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LinkNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178"> p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 因为带头结点，所以头结点的下一个结点就是第一个元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 返回队头元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 修改头结点的next指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 如果是最后一个结点，那么修改rear结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 此时rear == front，队列为空</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">free</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 释放空间</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 队头元素出队(不带头结点)bool DeQueue(LinkQueue &#x26;Q,ElemType &#x26;x){ if (Q.front == Q.rear) return false; // 空队列 LinkNode * p = Q.front->next; // 因为带头结点，所以头结点的下一个结点就是第一个元素 x=p->data; // 返回队头元素 Q.front->next=p->next; // 修改头结点的next指针 if (Q.rear==p) Q.rear = Q.front; // 如果是最后一个结点，那么修改rear结点 // 此时rear == front，队列为空 free(p); // 释放空间 return true;}"><div></div></button></div></figure></div> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 队头元素出队(不带头结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">DeQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">LinkQueue </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 空队列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LinkNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 指向此次出队的结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 修改front，如果是第一个结点则回到NULL，如果后续有结点则指向后续结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> p</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 最后一个结点出队，front->rear->NULL</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">front</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Q</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">rear</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">free</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 队头元素出队(不带头结点)bool DeQueue(LinkQueue &#x26;Q,ElemType &#x26;x){ if (Q.front == NULL) return false; // 空队列 LinkNode *p = Q.front; // 指向此次出队的结点 x=p->data; Q.front=p->next; // 修改front，如果是第一个结点则回到NULL，如果后续有结点则指向后续结点 if (Q.rear == p){ // 最后一个结点出队，front->rear->NULL Q.front = NULL; Q.rear = NULL; } free(p); return true;}"><div></div></button></div></figure></div> <h2 id="双端队列">双端队列</h2> <p>双端队列：只允许从两端插入、两端删除的线性表</p> <p>输入受限的双端队列：只允许从一端插入、两端删除的线性表</p> <p>输出受限的双端队列：只允许从两端插入、一端删除的线性表</p> <p><strong>考点：判断输出序列合法性</strong></p> <p>若数据元素输入序列为1,2,3,4，则哪些输出序列是合法的，哪些是非法的</p> <p>栈是先进后出</p> <p>栈中合法的序列，双端队列中也一定合法</p> <h1 id="括号匹配">括号匹配</h1> <p>括号匹配是匹配两边是否有对应存在的括号，像这种( ( ) )，就是可以匹配成功的，通常使用栈来实现该特性</p> <img src="https://b.1wind.cn/2025/06/5d637a6994f4b7d717e59100d17cb1cc.png" alt="image-20250615153959643" style="zoom: 67%;"> <p>代码详情</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MaxSize</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">10</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 订阅栈中元素的最大个数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#5A676D;--1:#EEFFFF"> data</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">MaxSize</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 静态数组存放栈中元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> top</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 栈顶指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">}SqStack</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化栈</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InitStack</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqStack </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 判断栈是否为空</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">StackEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqStack </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 新元素入栈</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Push</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqStack </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 栈顶元素出栈，用x返回</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Pop</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SqStack </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">bracketCheck</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">str</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">length</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">SqStack S</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InitStack</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化栈</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 遍历括号数组</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">str</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#566D35;--1:#C3E88D">(</span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">||</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">str</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#566D35;--1:#C3E88D">[</span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">||</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">str</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#566D35;--1:#C3E88D">{</span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">Push</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">str</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 扫描到左括号，入栈</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#4C6690;--1:#82AAFF">StackEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">))</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 扫描到右括号且栈空</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#BE2F2C;--1:#F07178"> topElem</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">Pop</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">topElem</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 不为空，栈顶元素出栈</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">26</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">str</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#566D35;--1:#C3E88D">)</span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> topElem </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#566D35;--1:#C3E88D">(</span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">27</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">28</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">str</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#566D35;--1:#C3E88D">]</span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> topElem </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#566D35;--1:#C3E88D">[</span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">29</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">30</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">str</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#566D35;--1:#C3E88D">}</span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> topElem </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#566D35;--1:#C3E88D">{</span><span style="--0:#256F74;--1:#89DDFF">'</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">31</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">32</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">33</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">34</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">StackEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 检索完所有括号，栈空说明匹配成功</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">35</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#define MaxSize 10 // 订阅栈中元素的最大个数typedef struct{ char data[MaxSize]; // 静态数组存放栈中元素 int top; // 栈顶指针}SqStack;// 初始化栈void InitStack(SqStack &#x26;S)// 判断栈是否为空void StackEmpty(SqStack S)// 新元素入栈bool Push(SqStack &#x26;S,char x)// 栈顶元素出栈，用x返回bool Pop(SqStack &#x26;S,char &#x26;x)bool bracketCheck(char str[],int length){ SqStack S; InitStack(S); // 初始化栈 for(int i=0;i<length;i++){ // 遍历括号数组 if (str[i] == &#x27;(&#x27; || str[i] == &#x27;[&#x27; || str[i] == &#x27;{&#x27;){ Push(S,str[i]); // 扫描到左括号，入栈 } else{ if (StackEmpty(S)) // 扫描到右括号且栈空 return false; char topElem; Pop(S,topElem); // 不为空，栈顶元素出栈 if (str[i] == &#x27;)&#x27; &#x26;&#x26; topElem != &#x27;(&#x27;) return false; if (str[i] == &#x27;]&#x27; &#x26;&#x26; topElem != &#x27;[&#x27;) return false; if (str[i] == &#x27;}&#x27; &#x26;&#x26; topElem != &#x27;{&#x27;) return false; } } return StackEmpty(S); // 检索完所有括号，栈空说明匹配成功}"><div></div></button></div></figure></div> <p>总结：</p> <p>用栈实现括号匹配</p> <p>依次扫描所有字符，遇到左括号入栈，遇到右括号则弹出栈顶元素检查是否匹配。</p> <p>匹配失败的情况：</p> <ol> <li>左括号单个</li> <li>右括号单个</li> <li>左右括号不匹配</li> </ol> <h1 id="栈在表达式中的应用">栈在表达式中的应用</h1> <p>中缀表达式：运算符在两个操作数中间，例如a+b</p> <p>后缀表达式：运算符在两个操作数后面，例如ab+</p> <p>前缀表达式：运算符在两个操作数前面，例如-ab</p> <p><strong>中缀转后缀的手算方法：</strong></p> <ol> <li>确定中缀表达式中各个运算符的运算顺序</li> <li>选择下一个运算符，按照[左操作数 右操作数 运算符]的方式组合成一个新的操作数</li> <li>如果还有运算符没被处理，就继续2的操作</li> </ol> <img src="https://b.1wind.cn/2025/06/bee03f7adb3218ad066c6a552374ecb9.png" alt="image-20250617154814168" style="zoom:50%;"> <p>这里有两个中缀表达式转后缀的情况，我们发现有一个运算式却存在着两个结果，通常来说，因为运算顺序不唯一，因此对应的后缀表达式也不唯一</p> <img src="https://b.1wind.cn/2025/06/70a7aa6c0c87870cdbfaf0d28eecc020.png" alt="image-20250617160033315" style="zoom:50%;"> <p>所以我们都会遵循左优先原则，只要左边的运算符可以运算，就优先算左边的，这就是左优先原则，比如我们看左式和右式，其实括号内和最右边的除法都可以先算，但是括号更靠近左边，所以优先算括号内的</p> <p>摘自王道考研数据结构与算法的一句话：<strong>右边的没有错，只是不合适。就像你一样，你也没有错，只是你不合适</strong></p> <p><strong>中缀表达式转后缀表达式（机算）</strong></p> <p>初始化一个栈，用于保存暂时还不能确定运算顺序的运算符</p> <p>从左到右处理各个元素，直到末尾。可能遇到三种情况：</p> <ol> <li>遇到操作数。直接加入到后缀表达式</li> <li>遇到界限符。遇到“（”直接入栈；遇到“）”则依次弹出栈内运算符并加入后缀表达式，直到弹出“（”为止。注意“（”不加入后缀表达式</li> <li>遇到运算符。依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到“（”或栈空则停止。之后再把当前运算符入栈。</li> </ol> <p>按上述方法处理完所有字符后，将栈中剩余运算符依次弹出，并加入后缀表达式。</p> <p><strong>后缀表达式的手算方法</strong></p> <ul> <li>从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应运算，合体为一个操作数</li> <li>注意：两个操作数的左右顺序</li> </ul> <img src="https://b.1wind.cn/2025/06/c1adfa4e20d4e62da8ed2d61ac1c718b.png" alt="image-20250617173728524" style="zoom:50%;"> <p><strong>中缀转前缀的手算方法：</strong></p> <ol> <li>确定中缀表达式中各个运算符的运算顺序</li> <li>选择下一个运算符，按照[运算符 左操作数 右操作数]的方式组合成一个新的操作数</li> <li>如果还有运算符没被处理，就继续②</li> </ol> <p>右优先原则：只要右边的运算符能先计算，就优先算右边的</p> <p><img src="https://b.1wind.cn/2025/06/1c3dcc21033be63390080af3def2576e.png" alt="image-20250617175644572"></p> <h2 id="后缀表达式">后缀表达式</h2> <p>用栈实现后缀表达式的计算：</p> <ol> <li>从左往右扫描下一个元素，直到处理完所有元素</li> <li>若扫描到操作数则压入栈，并回到①的操作；否则执行③</li> <li>若扫描到运算符，则弹出两个栈顶元素，执行相应运算，运算结果压回栈顶，回到①</li> </ol> <p>若表达式合法，则最后栈中只会留下一个元素，就是最终结果</p> <h2 id="前缀表达式">前缀表达式</h2> <p>用栈实现前缀表达式的计算：</p> <ol> <li>从右往左扫描下一个元素，直到处理完所有元素</li> <li>若扫描到操作数则压入栈，并回到①，否则执行③</li> <li>若扫描到运算符，则弹出两个栈顶元素，执行相应操作，运算结果压回栈顶，回到①</li> </ol> <h2 id="中缀表达式">中缀表达式</h2> <p>用栈实习中缀表达式的计算：</p> <p>初始化两个栈，操作数栈和运算符栈</p> <p>若扫描到操作数，压入操作数栈</p> <p>若扫描到运算符或界限符，则按照“中缀转后缀”相同的逻辑压入运算符栈（期间也会弹出运算符，每当弹出应该运算符时，就需要再弹出两个操作数栈的栈顶元素并执行相应运算，运算结果再压回操作数栈）</p> <h1 id="栈在递归中的应用">栈在递归中的应用</h1> <p>递归算法计算阶乘</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 计算正整数 n!</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">factorial</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">n</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">||</span><span style="--0:#BE2F2C;--1:#F07178"> n</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> n</span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#4C6690;--1:#82AAFF">factorial</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">main</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> x </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">factorial</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">10</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 计算正整数 n!int factorial(int n){ if (n==0 || n==1) return 1; else return n*factorial(n-1);}int main(){ int x = factorial(10); return 0;}"><div></div></button></div></figure></div> <p>递归调用时，函数调用栈可称为“递归工作栈”</p> <p>每进入一层递归，就将递归调用所需信息压入栈顶</p> <p>每退出一层递归，就从栈顶弹出相应信息</p> <p>举个栗子：比如最开始是main函数，main函数里调用func1，func1里调用func2，很显然它们是依次入栈的</p> <p>main -> func1 -> func2，也就是说，最先从栈顶被释放的是func2</p> <p>递归算法求斐波那契数列</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Fib</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">n</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">n </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">n </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">Fib</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">)+</span><span style="--0:#4C6690;--1:#82AAFF">Fib</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">main</span><span style="--0:#256F74;--1:#89DDFF">(){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> x </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">Fib</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#A64930;--1:#F78C6C">4</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="int Fib(int n){ if (n == 0) return 0; else if(n == 1) return 1; else return Fib(n-1)+Fib(n-2);}int main(){ int x = Fib(4); return 0;}"><div></div></button></div></figure></div> <img src="https://b.1wind.cn/2025/06/29b91d3ff08b3b11f378557d093eda58.png" alt="image-20250624201532241" style="zoom:50%;"> <p>总结：</p> <ul> <li>函数调用的特点：最后被调用的函数最先执行结束（LIFO）</li> <li>函数调用时，需要用一个“函数调用栈”存储： <ol> <li>调用返回地址</li> <li>实参</li> <li>局部变量</li> </ol> </li> <li>递归调用时，函数调用栈可称为“递归工作栈”，每进入一层递归，就将递归调用所需信息压入栈顶，每退出一层递归，就从栈顶弹出相应信息</li> <li>缺点：效率低，太多层递归可能会导致栈溢出：可能包含很多重复计算</li> <li>可以自定义栈将递归算法改为非递归算法</li> </ul> <h1 id="特殊矩阵的压缩存储">特殊矩阵的压缩存储</h1> <h2 id="一维数组">一维数组</h2> <p>ElemType a[10]; // ElemType型一维数组</p> <p><img src="https://b.1wind.cn/2025/06/260182f5cc02e892247c4fef8d0caac4.png" alt="image-20250624211941979"></p> <p>起始地址：LOC</p> <p>各数组元素大小相同，且物理上连续存放。</p> <p>数组元素a[i]的存放地址=LOC+i*sizeof(ElemType) (0&#x3C;=i&#x3C;=10)</p> <h2 id="二维数组">二维数组</h2> <p>ElemType b[2] [4];</p> <p>行优先存储：将数组数据一行一行的存</p> <p>M行N列的二维数组b[M] [N]中，若按行优先存储，则b[i] [j]的存储地址=LOC+(i<code>*</code>N+j)*sizeof(ElemType)</p> <p>这个公式是让初始地址去加上后续的数组字节来找到对应的行优先数组值</p> <p>列优先存储：将数组数据一列一列的存</p> <p>M行N列的二维数组b[M] [N]中，若按列优先存储，则b[i] [j]的存储地址=LOC+(j<code>*</code>M+i)*sizeof(ElemType)</p> <h2 id="对称矩阵">对称矩阵</h2> <p>若n阶方阵[n×n的矩阵，行列数相同的矩阵]中任意一个元素aij都有aij=aji，则该矩阵为对称矩阵</p> <p>策略：只存储主对角线+下三角区</p> <p>按行优先原则将各元素存入一维数组</p> <p>如果我们想获取压缩矩阵的某个值，那我们可以编写一个矩阵下标->一维数组下标的方法</p> <img src="https://b.1wind.cn/2025/06/86aa198ed35f6469bf9fbb90a4e22756.png" alt="image-20250625203210907" style="zoom:50%;"> <p><img src="https://b.1wind.cn/2025/06/6fe936777331b83b2a76adec50eb1875.png" alt="image-20250625201539525"></p> <p>简单解释一下这个公式，按照行优先原则，那么下三角区的行位置，第一行0个，第二行1个，第n行n-1个，以此类推</p> <p>那么我们想计算出对应的位置，就要知道它大概在哪个位置，则1+2+3+4+n-1…(计算等差公式)而列的位置就是第几个了</p> <p>数组下标就根据这个公式算，因为一维数组下标是从0开始，所以-1，矩阵下标无需-1</p> <img src="https://b.1wind.cn/2025/06/d0766b34212ebd70c314107410bed2b3.png" alt="image-20250625202341947" style="zoom:50%;"> <p>上三角算法其实也是类似的，也是列元素依次增加计算，最后加上行的位置</p> <h2 id="三角矩阵">三角矩阵</h2> <p>下三角矩阵：除了主对角线和下三角区，其余的元素都相同</p> <img src="https://b.1wind.cn/2025/06/a66211bc40e7076f485f90875801be18.png" alt="image-20250625194639273" style="zoom:50%;"> <p>压缩存储策略：按行优先原则将橙色区元素存入一维数组中。并在最后一个位置存储常量c</p> <p><img src="https://b.1wind.cn/2025/06/f494ac410e440efb5cc1097eee2d104a.png" alt="image-20250625205100286"></p> <p>下三角矩阵的下三角区及主对角线元素其实和对称矩阵没差别，但是上三角区的元素都是常量，并且只在最后一个位置存储这些相同的值，所以只需要找到最后一个位置，也就是一维数组的最后一个值</p> <p>上三角矩阵：除了主对角线和上三角区，其余的元素都相同</p> <img src="https://b.1wind.cn/2025/06/e555109696a06603007c95b174392e61.png" alt="image-20250625194654096" style="zoom:50%;"> <p><img src="https://b.1wind.cn/2025/06/948c491925cf422cc21b8d9a979cab45.png" alt="image-20250625212402468"></p> <p>第一行有n个元素，第二行有n-1个元素，如果我们需要找到第i个元素，就要拿到i-1行的空间，那么就该计算1->i-1个行的位置，那么如果我们想找到i-1个行的位置，此时就需要通过n-i+2的方式，因为找的是i-1的位置，所以i不能为1，i为1时这个就不成立了，因为i=1时，计算的就是第0行的空间了，很显然没有第0行</p> <p>请不要疑惑，因为这里计算的是<code>i-1</code>个元素，也就是说，i=2时，计算的是第一行的空间，因为i=2计算的是i-1个行的空间，即第一行的空间！！！</p> <p>并且最后需要加入j-i个元素，也就是行前面还需要多少的元素</p> <p>我认为这里需要重点说明一下公式：<code>n-i+2</code></p> <p>我们需要知道每一行有几个元素</p> <p>第一行：有n个元素</p> <p>第二行：有n-1个元素</p> <p>第i行有<code>n-i+1</code>个元素</p> <p>那么，多出来的1从哪来的呢？</p> <p>我们要计算的是到某一行的整体个数</p> <p>则进行公式替换，因为i = i -1</p> <p>故公式为：<code>n - (i - 1) + 1</code> = <code>n - i + 1 + 1</code> = <code>n - i + 2</code></p> <p>我们最后从逻辑上来解释</p> <p>比如说，我们假设k = i - 1</p> <p>如果说，我们想算第三行的元素，就得拿到前两行一共有多少个元素，再加进去，那么i - 1 = 2，公式的目的是计算任意k(i)行的元素个数，那么这里-1其实是一样的，-1更方便了，因为它直接就算出了前i行所需的个数，然后加入进去，就可以得出结果了</p> <h2 id="三对角矩阵">三对角矩阵</h2> <p>三对角矩阵，又称带状矩阵：</p> <p>当|i-j| > 1时，有aij = 0(1&#x3C;=i,j&#x3C;=n)</p> <p>什么意思呢，也就是说，行号-列号的绝对值大于1时，那么这个元素为0</p> <p>如图所示</p> <img src="https://b.1wind.cn/2025/06/4fcb1bb44efbb4609a4a995b1cbbc14f.png" alt="image-20250626135708863" style="zoom:50%;"> <p>压缩存储策略：</p> <p>按行优先(或列优先)原则，只存储带状部分</p> <p>前i-1行共有3(i-1)-1个元素</p> <p>解释一下这个公式</p> <p><strong>这个公式计算的是第i行开始前，我们存储了多少个元素</strong></p> <p>因为我们想计算第i个元素，就得跳过其前面的元素</p> <p>除了第一行和最后一行是2个元素，其他都是3个元素</p> <p>假设第1行到i-1行元素都是3个元素，那么前i行就是3i了，而前i-1行就是3(i-1)了</p> <p>但是！第一行是个特例，所以我们需要从总数里减去1</p> <p>因此，前i-1行的元素个数就是<code>3*(i-1)-1</code></p> <p>当i = 2时，第2行开始前的元素就是3*1 - 1 = 2，没问题，第一行的元素确实是2</p> <p>当然这里的i = 1就不成立了，因为i = 1是第一行前的元素，这个计算是没有意义的</p> <p>aij是i行第j - i + 2个元素</p> <p>这个公式说明aij是它自己所在的这一行里，第几个被存储的非0元素</p> <p>比如说，我们看第i行的非零元素，它们通常是a[i,i-1],a[i,i],a[i,i+1]</p> <p>那么带入公式</p> <ul> <li>列号是j = i - 1，代入公式(i-1) - i + 2 = 1，这是第一个</li> <li>列号是j = i，代入公式i - i + 2 = 2，这是第二个</li> <li>列号是j = i + 1，代入公式(i + 1) - i + 2 = 3，这是第三个</li> </ul> <p>现在很显然，我们可以很清楚的知道，第aij个元素是第几个非0元素</p> <p>aij是第2i+j-2个元素</p> <p>这个公式是前面两个公式相加后的简化，目的是最终的位置在哪，因为第一个公式是计算前i-1行的元素，我们再加上它在列的位置，就知道它在哪了</p> <p>(3(i - 1) - 1) + (j - i + 2)</p> <p>= (3i - 3 - 1) + (j - i + 2)</p> <p>= 3i - 4 + j - i + 2</p> <p>= 2i +j -2</p> <p><strong>若已知数组下标k，如何得到i,j?【反向求解】</strong></p> <p>第k + 1个元素，在第几行？第几列</p> <p>前i - 1行共3(i-1)-1个元素</p> <p>前i行共3i-1个元素</p> <p>[</p> <p>3i-1计算的是第一行+其他i-1行的个数(除去第一行的总个数)</p> <p>很显然其他i-1行是3(i-1)，为什么呢？</p> <p>因为我们去除了第一行，其他的元素个数都是3，除最后一行</p> <p>第一行是2个，那么相加即为3i - 3 + 2 = 3i - 1</p> <p>]</p> <p>显然，3(i-1)-1&#x3C; k + 1 &#x3C;= 3i-1</p> <p>k会大于前i-1行的元素个数，并小于等于前i行的元素个数</p> <p>把不等式解出来得i为下述公式</p> <p>i=(k+2)/3 -> 向上取整 或 i = (k+1)/3+1 -> 向下取整</p> <p>由k = 2i+j-3[该公式由上述推导]，得</p> <p>j = k-2i+3</p> <p>我们确认一下这里的元素，k是第k个元素，i是行，j是列</p> <h2 id="稀疏矩阵">稀疏矩阵</h2> <p>稀疏矩阵：非零元素远远少于矩阵元素的个数</p> <img src="https://b.1wind.cn/2025/06/7850aa010f3df4106bf9c706b4fcbb25.png" alt="image-20250626160603342" style="zoom:50%;"> <p>压缩存储策略：</p> <p>顺序存储—三元组&#x3C;行，列，值></p> <img src="https://b.1wind.cn/2025/06/e87fcc7c2f76ddb0058e6ee564931e6a.png" alt="image-20250626160547745" style="zoom:50%;"> <p>方法二：十字链表法</p> <p>一图胜千言</p> <img src="https://b.1wind.cn/2025/06/dd1597a3d3dd1cc3092b74ee97b4b267.png" alt="image-20250626161232659" style="zoom:50%;"> <p>定义两个指针数组，分别指向每一列和每一行</p> <h1 id="串">串</h1> <p>串，即字符串（String）是由零个或多个字符组成的有限序列。一般记为</p> <p>S=‘a1a2a3…an’(n>=0)</p> <p>其中S是串名，单引号括起来的字符序列是串的值；</p> <p>ai可以是字母、数字或其他字符；</p> <p>串中字符的个数n称为串的长度</p> <p>n=0时的串称为空串（用空集表示）</p> <p>例：</p> <p>S=“HelloWorld”[注：有的地方用双引号，有的地方用单引号]</p> <p>T=‘Phone’</p> <p>子串：串中任意个连续的字符组成的字序列。</p> <p>Eg：‘Pho’，‘one’是串T的子串</p> <p>主串：包含子串的串。</p> <p>Eg：T是’Pho’的主串</p> <p>字符在主串中的位置：字符在串中的序号</p> <p>Eg：h在T中的位置是2（第一次出现）</p> <p>子串在主串中的位置：子串的第一个字符在主串中的位置</p> <p>Eg：‘hone’在T中的位置为2，其实就是子串首个字符出现的位置</p> <p><strong>注意：位序从1开始，而不是从0</strong></p> <p>当然，空串和空格串是不一样的</p> <p>M=”，M是空串</p> <p>N=’ ‘N是由三个空格字符组成的空格串，每个空格字符占1B</p> <p>串是一种特殊的线性表，数据元素之间呈线性关系</p> <p>串的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等）</p> <p>串的基本操作，如增删改查等通常以子串为操作对象</p> <h2 id="基本操作-2">基本操作</h2> <p>假设有串T=“”，S=“iPhone 11 Pro Max?”，W=“Pro”</p> <p>StrAssign(&#x26;T,chars)：赋值操作。把串T赋值为chars中的内容</p> <p>StrCopy(&#x26;T,S)：复制操作。把串S复制到串T</p> <p>StrEmpty(S)：判空操作。若S为空串，则返回TRUE，否则返回FALSE</p> <p>StrLength(S)：求串长。返回串S的元素个数</p> <p>ClearString(&#x26;S)：清空操作。将S清为空串</p> <p>DestroyString(&#x26;S)：销毁串。将串S销毁（回收存储空间）</p> <p>Concat(&#x26;T,S1,S2)：串联接。用T返回由S1和S2联接而成的新串</p> <p>SubString(&#x26;Sub,S,pos,len)：求子串。用Sub返回串S的第pos个字符起长度为len的子串</p> <p>Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则返回0</p> <p>StrCompare(S,T):比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S&#x3C;T，则返回值&#x3C;0</p> <p>这里的比较操作是针对字符大小来判断的，</p> <p>Eg：d>a，因为d在a的后面</p> <p>abstract&#x3C;abstraction，长串前缀相同时，长串更大</p> <p>任何数据存到计算机中一定是二进制数。</p> <p>需要确定一个字符和二进制数的对应规则，这就是编码</p> <p>“字符集”：</p> <ul> <li>英文字符---ASCII字符集</li> <li>中英文---Unicode字符集</li> </ul> <p>英文字符大小通常根据ASCII字符集来确定</p> <h2 id="存储结构-1">存储结构</h2> <h3 id="顺序存储">顺序存储</h3> <p>顺序存储其实就是通过顺序表来存储，而ElemType改为了char</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MAXLEN</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">255</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 预定义最大串为255</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#5A676D;--1:#EEFFFF"> ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">MAXLEN</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 每个分量存储一个字符,静态数组实现(定长顺序存储)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 串的实际长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">}SString</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">ch</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 按串长分配存储区，ch指向串的基地址(动态数组实现堆分配存储)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 串的长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">HString</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">HString S</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">S.ch </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">MAXLEN </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">sizeof(</span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">S.length </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#define MAXLEN 255 // 预定义最大串为255typedef struct{ char ch[MAXLEN]; // 每个分量存储一个字符,静态数组实现(定长顺序存储) int length; // 串的实际长度}SString;typedef struct{ char *ch; // 按串长分配存储区，ch指向串的基地址(动态数组实现堆分配存储) int length; // 串的长度}HString;HString S;S.ch = (char *)malloc(MAXLEN * sizeof(char));S.length = 0;"><div></div></button></div></figure></div> <p>上述说明的是方案一，写明Length，写明数组</p> <p>方案二</p> <p>在ch[0]，即数组首位充当Length，优点：字符的位序和数组下标相同</p> <p>方案三</p> <p>没有Length变量，以字符’\0’表示结尾（对应ASCII码的0）</p> <p>类似这样：<code>w a n g \0</code></p> <p>方案四</p> <p>舍弃ch[0]，由ch[1]开始存储数据，并专门声明Length用来表示字符串有多长</p> <p>这样就可以截取方案一、二的优点了</p> <h3 id="链式存储-1">链式存储</h3> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> StringNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#BE2F2C;--1:#F07178"> ch</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 每个结点存1个字符</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> StringNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178"> next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 在32位的系统中，此处占用4个字节</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">StringNode</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF"> String</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct StringNode{ char ch; // 每个结点存1个字符 struct StringNode * next; // 在32位的系统中，此处占用4个字节}StringNode, * String;"><div></div></button></div></figure></div> <p>此时就出现了一个问题</p> <p>我们存储内容只存一个字节，而辅助存储的next指针却要4个字节，我们称这种情况为</p> <p>存储密度低：每个字符1B，每个指针4B</p> <p>如何解决该问题呢？</p> <p>我们可以让每个结点存储多个字符，以此来提高存储密度</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> StringNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">4</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 此处存储的信息可以更多</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> StringNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178"> next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 在32位的系统中，此处占用4个字节</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">StringNode</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF"> String</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct StringNode{ char ch[4]; // 此处存储的信息可以更多 struct StringNode * next; // 在32位的系统中，此处占用4个字节}StringNode, * String;"><div></div></button></div></figure></div> <h2 id="操作实现">操作实现</h2> <p>以下操作采用顺序存储方案四</p> <p>SubString(&#x26;Sub,S,pos,len)：求子串。用Sub返回串S的第pos个字符起长度为len的子串</p> <p>结构</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MAXLEN</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">255</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">char</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">MAXLEN</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 每个分量存储一个字符</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> length</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">SString</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#define MAXLEN 255typedef struct{ char ch[MAXLEN]; // 每个分量存储一个字符 int length;}SString;"><div></div></button></div></figure></div> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 求子串</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">SubString</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Sub</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">pos</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">len</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 子串范围越界</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">pos </span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178"> len </span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 如果第pos个字符+len-1大于总长度时，说明字符越界</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">pos</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">pos</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178">len</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Sub</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#BE2F2C;--1:#F07178">pos</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 这里的第一个位置是不放内容的</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">Sub</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> len</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 求子串bool SubString(SString &#x26;Sub,SString S,int pos,int len){ // 子串范围越界 if (pos + len - 1 > S.length) // 如果第pos个字符+len-1大于总长度时，说明字符越界 return false; for (int i=pos;i<pos+len;i++){ Sub.ch[i-pos+1] = S.ch[i]; // 这里的第一个位置是不放内容的 } Sub.length = len; return true;}"><div></div></button></div></figure></div> <p>StrCompare(S,T)：比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S&#x3C;T，则返回值&#x3C;0</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">StrCompare</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> i </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 如果长度小于这两个数组，此时说明还未结束</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">])</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 若字符不同</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // ASCII码字符相减</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 扫描过的所有字符都相同，则长度长的串更大</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="int StrCompare(SString S,SString T){ for (int i = 1;i <= S.length &#x26;&#x26; i <= T.length;i++){ // 如果长度小于这两个数组，此时说明还未结束 if (S.ch[i] != T.ch[i]) // 若字符不同 return S.ch[i] - T.ch[i]; // ASCII码字符相减 } // 扫描过的所有字符都相同，则长度长的串更大 return S.length-T.length;}"><div></div></button></div></figure></div> <p>Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Index</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">StrLength</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">),</span><span style="--0:#BE2F2C;--1:#F07178">m</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">StrLength</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 获取两个字符串的长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">SString sub</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //暂存字符串</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#BE2F2C;--1:#F07178">m</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // n-m+1是为了计算可以获取到的子串次数，依次向后，这里+1是把第一次包含进去</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">SubString</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">sub</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">m</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 截取子串</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#4C6690;--1:#82AAFF">StrCompare</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">sub</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">)!=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 比对子串</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 返回位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 不存在子串</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="int Index(SString S,SString T){ int i=1,n=StrLength(S),m=StrLength(T); // 获取两个字符串的长度 SString sub; //暂存字符串 while(i<=n-m+1){ // n-m+1是为了计算可以获取到的子串次数，依次向后，这里+1是把第一次包含进去 SubString(sub,S,i,m); // 截取子串 if(StrCompare(sub,T)!=0) ++i; // 比对子串 else return i; // 返回位置 } return 0; // 不存在子串}"><div></div></button></div></figure></div> <h2 id="朴素模式匹配算法">朴素模式匹配算法</h2> <p>字符串模式匹配：在主串中找到与模式串相同的子串，并返回其所在位置</p> <p>主串：123456</p> <p>模式串：56</p> <p>模式串：78</p> <p>子串与模式串不同</p> <ul> <li>子串---主串的一部分，<strong>一定存在</strong></li> <li>模式串---不一定在主串中能找到</li> </ul> <p>朴素模式匹配算法：暴力解决问题</p> <p>主串长度为n，模式串长度为m</p> <p>朴素模式匹配算法，将主串中所有长度为m的子串依次与模式串对比，直到找到一个完全匹配的子串，或所有的子串都不匹配为止。</p> <p>而我们最多能对比<code>n-m+1</code>个子串，这里+1是第一次的对比加入进去</p> <p>看到这里是不是感觉有些熟悉呢？</p> <p>其实在操作实现中的Index方法里，我们已经实现了朴素模式匹配算法，但这是通过字符串的基本方法来实现的</p> <p>接下来我们将通过数组下标实现朴素模式匹配算法</p> <p>直接上代码解析</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Index</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 模式串和主串相同</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 继续比较后继字符</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 主串来到原字符下一个位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 通常来说是+1，即向后一位，但这里采用的是模式四，第0位被舍弃了，所以+2</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 模式串回到首位</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 如果j超过了模式串的长度，说明已经找到了，返回位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="int Index(SString S,SString T){ int i=1,j=1; while(i<=S.length &#x26;&#x26; j<=T.length){ if (S.ch[i] == T.ch[j]){ // 模式串和主串相同 ++i;++j; // 继续比较后继字符 } else{ i=i-j+2; // 主串来到原字符下一个位置 // 通常来说是+1，即向后一位，但这里采用的是模式四，第0位被舍弃了，所以+2 j=1; // 模式串回到首位 } } // 如果j超过了模式串的长度，说明已经找到了，返回位置 if (j>T.length) return i-T.length; else return 0;}"><div></div></button></div></figure></div> <p>这样的时间复杂度最坏会达到O(nm)</p> <h1 id="kmp算法">KMP算法</h1> <p>KMP算法相当于朴素模式匹配算法的优化版</p> <p>简单说明一下旧版的KMP算法</p> <img src="https://b.1wind.cn/2025/06/c36d639511cf97d9f8762ecfc2cbb6fb.png" alt="image-20250629204038639" style="zoom:50%;"> <p>原方法是遍历主串，对应的遍历模式串，如果主串与模式串不符合，就让主串后移，模式串回到原位，这种方法确实稳妥，但是太慢了</p> <p>KMP算法只需要看模式串，我们会额外声明一个next数组作为辅助使用</p> <p>拿google为例，如果两个字符匹配，则i++，j++，i是主串,j是模式串</p> <p>若j=1时发生不匹配，让i++，而j依然是1</p> <p>若j=2 时发生不匹配，则应让j回到1</p> <p>若j=3时发生不匹配，则应让j回到1</p> <p>若j=4时发生不匹配，则应让j回到1</p> <p>若j=5时发生不匹配，则应让j回到2，这里是因为google，j=5时，数据为l，很显然前面已经有了g，符合第一个g的标准，就没有必要从原先的g重新开始了，而是直接让j回到o，相当于少匹配一次g</p> <p>若j=6 时发生不匹配，则应让j回到1</p> <p>而j=next[k]，其实是说明了上述的情况</p> <p>具体代码如下：</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Index_KMP</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">next</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">j </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化主串、模式串序号</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">||</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]==</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 当j为next[1]时，说明首字符不匹配，两者后移，让主串后移，并让模式串回到首位</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">++</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 模式串后移</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 匹配成功</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="int Index_KMP(SString S,SString T,int next[]){ int i = 1,j = 1; // 初始化主串、模式串序号 while(i<=S.length &#x26;&#x26; j<=T.length){ if(j==0 || S.ch[i]==T.ch[j]){ // 当j为next[1]时，说明首字符不匹配，两者后移，让主串后移，并让模式串回到首位 ++i; ++j; }else{ j=next[j]; // 模式串后移 } } if(j>T.length) return i-T.length; // 匹配成功 else return 0;}"><div></div></button></div></figure></div> <p>串的<strong>前缀</strong>：包含第一个字符，且不包含最后一个字符的子串</p> <p>例如：abcdefg，前缀就有：a、ab、abc、abcd、abcde、abcdef</p> <p>串的<strong>后缀</strong>：包含最后一个字符，且不包含第一个字符的子串</p> <p>例如：abcdefg，后缀就是g、fg、efg、defg、cdefg、bcdefg</p> <p>我们主要看最长相等的匹配前后缀，通过匹配的前后缀就可以填充next数组了</p> <p>举个栗子，我们以ababaa来制作next数组</p> <table><thead><tr><th>索引j</th><th>对应的字符</th><th>子串</th><th>前缀</th><th>后缀</th><th>公共部分</th><th>最长公共前后缀长度</th><th>next[j]</th></tr></thead><tbody><tr><td>0</td><td>a</td><td>a</td><td>无</td><td>无</td><td>无</td><td>0</td><td>0</td></tr><tr><td>1</td><td>b</td><td>ab</td><td>a</td><td>b</td><td>无</td><td>0</td><td>0</td></tr><tr><td>2</td><td>a</td><td>aba</td><td>a,ab</td><td>a,ba</td><td>a</td><td>1</td><td>1</td></tr><tr><td>3</td><td>b</td><td>abab</td><td>a,ab,aba</td><td>b,ab,bab</td><td>ab</td><td>2</td><td>2</td></tr><tr><td>4</td><td>a</td><td>ababa</td><td>a,ab,aba,abab</td><td>a,ba,aba,baba</td><td>a,aba</td><td>3</td><td>3</td></tr><tr><td>5</td><td>a</td><td>ababaa</td><td>a,ab,aba,abab,ababa</td><td>a,aa,baa,abaa,babaa</td><td>a</td><td>1</td><td>1</td></tr></tbody></table> <p>那么next数组就是[0,0,1,2,3,1]</p> <p>特别的，next[0]是为0的</p> <p>当然，我们是把next[1]来作为第一个字符使用的，所以通常来说，next[1]=0</p> <p>我们务必要知道<strong>最长相等的前后缀长度</strong></p> <p>另一种方法：当第j个字符匹配失败，由前1~j-1个字符组成的串记为S，则next[j]=S的最长相等前后缀长度+1</p> <p>比如拿ababaa来说，如果在索引5的a时匹配失败，那么由ababa组成S</p> <p>S的最长相等前后缀是：aba aba，那么长度是3，3+1是4</p> <p>next[5]=4</p> <p>这两个情况不同，但得到的结果都是对的</p> <p>在考研处学习的是第二种方法</p> <p>这里给出相应代码</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 求模式串T的next数组</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">get_next</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">next</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // i是模式串，j是记录公共前缀长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 无前后缀必为0</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">||</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]==</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 首位或字符相同，只有字符相同，才会走下去</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 模式串前进，并且公共前缀长度增加</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 若pi=pj，则next[j+1]=next[j]+1</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 对应的模式串赋予公共前缀长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 否则令j=next[j]，循环继续</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 并且第一个子串next[1]必定是回到第一个位置，会让串向后走</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //回溯到上一个正确的前后缀位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 求模式串T的next数组void get_next(SString T,int next[]){ int i=1,j=0; // i是模式串，j是记录公共前缀长度 next[1]=0; // 无前后缀必为0 while(i<T.length){ if(j==0||T.ch[i]==T.ch[j]){ // 首位或字符相同，只有字符相同，才会走下去 ++i;++j; // 模式串前进，并且公共前缀长度增加 // 若pi=pj，则next[j+1]=next[j]+1 next[i]=j; // 对应的模式串赋予公共前缀长度 } else // 否则令j=next[j]，循环继续 // 并且第一个子串next[1]必定是回到第一个位置，会让串向后走 j=next[j]; //回溯到上一个正确的前后缀位置 }}"><div></div></button></div></figure></div> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//KMP算法</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Index_KMP</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">SString </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">get_next</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">next</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 求next数组</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">||</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]==</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 继续比较后续字符</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 模式串移动</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j </span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#BE2F2C;--1:#F07178">　</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 匹配成功，返回索引</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="//KMP算法int Index_KMP(SString S,SString T){ int i=1,j=1; int next[T.length+1]; get_next(T,next); // 求next数组 while(i<=S.length &#x26;&#x26; j<=T.length){ if (j==0 || S.ch[i]==T.ch[j]){ ++i;++j; // 继续比较后续字符 }else j=next[j]; // 模式串移动 } if (j >　T.length) return i-T.length; // 匹配成功，返回索引 else return 0;}"><div></div></button></div></figure></div> <p>最后在这里说一下自己对于next数组的理解</p> <p>next数组真的是最重点的内容了，只要掌握了next数组，就掌握了KMP</p> <p>next数组的第一个位置存放的是0，这是绝对的，因为如果j在第一个字符就匹配失败了，就需要让模式串做重开操作，并让对应主串往后，第二个位置存放的是1，这是绝对的，因为一般来说，第二个位置匹配失败的话，都会回到第一个位置重新匹配公共前后缀，不同就让主串后移，因为第二个匹配失败了，第一个也失败了，第三个乃至后面的，都是根据是否匹配成功来决定，如果匹配成功，说明了一点，此时的前后缀相同，那么长度++，并记录回归位置，如果匹配失败，回到上一次位置，因为上一次位置有成功匹配过的前后缀，对其继续匹配，如果成功，说明前后缀相同，长度++，不同就继续回归，直到回到最前面</p> <p><strong>求nextval数组</strong></p> <p>先求next数组，再由next数组求nextval数组</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">nextval</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--1:#EEFFFF">j</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#5A676D;--1:#EEFFFF">T.length</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--1:#EEFFFF">j</span><span style="--0:#256F74;--1:#89DDFF">++){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]]==</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">ch</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">])</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">nextval</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">nextval</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">nextval</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">next</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="nextval[1] = 0;for(int j=2;j<=T.length;j++){ if (T.ch[next[j]]==T.ch[j]) nextval[j]=nextval[next[j]]; else nextval[j]=next[j];}"><div></div></button></div></figure></div> <h1 id="树">树</h1> <h2 id="基本概念">基本概念</h2> <p>树：从树根生长，逐级分支</p> <img src="https://b.1wind.cn/2025/07/fa237a3002c65438f06e2742ed7ddc6a.png" alt="image-20250703200415466" style="zoom:50%;"> <p>空树：结点数为0的树</p> <p>非空树的特性</p> <ul> <li>有且仅有一个根节点</li> <li>前驱：前面的结点，比如C的前驱是A</li> <li>后继：后面的结点，比如A的后继是C</li> <li>没有后继的结点称为“叶子结点”（或终端结点）</li> <li>有后继的结点称为“分支结点”（或非终端结点）</li> </ul> <p>树除了根节点外，任何一个结点有且仅有一个前驱，如果存在多于一个前驱，说明它不是树</p> <p>树是一个n(n>=0)个结点的有限集合，n=0时，称为空树，这是一种特殊情况。在任意一棵非空树中应满足：</p> <ol> <li>有且仅有一个特定的称为根的结点</li> <li>当n>1时，其余结点可分为m(m>0)个互不相交的有限集合T1,T2…Tn，其中每个集合本身又是一棵树，并且称为根节点的子树</li> </ol> <p>属性：</p> <ul> <li>结点的层次（深度）---从上往下数[默认从1开始]</li> <li>结点的高度 ---从下往上数</li> <li>树的高度（深度） ---总共多少层</li> <li><strong>结点的度</strong> ---有几个孩子（分支）</li> <li><strong>树的度</strong> ---各结点的度的最大值</li> </ul> <p>有序树---逻辑上看，树中结点的各子树从左至右是有次序的，不能互换</p> <p>无序树---逻辑上看，树中结点的各子树从左至右是无次序的，可以互换</p> <p><img src="https://b.1wind.cn/2025/07/f19970b4cc09f9c61b882f4f76b5c50c.png" alt="image-20250703203903771"></p> <p>如图所示，左侧为有序树，右侧为无序树</p> <p>森林是(m>0)棵互不相交的树的集合,m可为0，空森林</p> <p><img src="https://b.1wind.cn/2025/07/ed071f3ce02ca0090d616b67c95d55ea.png" alt="image-20250703204114068"></p> <p>如图所示，左侧为森林，右侧为树</p> <h2 id="常考性质">常考性质</h2> <p>结点数=总度数+1</p> <p>结点的度---结点有几个孩子(分支)</p> <p>度为m的树、m叉树的区别</p> <p>树的度---各结点的度的最大值</p> <p>m叉树---每个结点最多只能有m个孩子的树</p> <table><thead><tr><th>度为m的树</th><th>m叉树</th></tr></thead><tbody><tr><td>任意结点的度&#x3C;=m(最多m个孩子)</td><td>任意结点的度&#x3C;=m(最多m个孩子)</td></tr><tr><td>至少有一个结点度=m（有m个孩子）</td><td>允许所有的结点的度都&#x3C;=m</td></tr><tr><td>一定是非空树，至少有m+1个结点</td><td>可以是空树</td></tr></tbody></table> <p>度为m的树，至少有应该结点的度=m，并且不能为空，至少有m+1个结点</p> <p>m叉树可以为m叉空树，度也是任意的，可以为空</p> <p>$$ 度为m的树第i层至多有m^{i-1}个结点(i>=1) $$</p> <p>$$ m叉树第i层至多有m^{i-1}个结点(i>=1) $$</p> <p>$$ 高度为h的m叉树至多有\frac{m^{h}-1}{m-1}个结点 $$</p> <p>高度为h的m叉树至少有h个结点。</p> <p>高度为h、度为m的树至少有h+m-1个结点</p> <p>$$ 具有n个结点的m叉树的最小高度为 [log_m(n(m-1)+1)] $$</p> <h2 id="存储结构-2">存储结构</h2> <h3 id="顺序存储-1">顺序存储</h3> <h4 id="双亲表示法">双亲表示法</h4> <p>思路：用数组顺序存储各个结点。每个结点中保存数据元素、指向双亲结点（父结点）的“指针”</p> <img src="https://b.1wind.cn/2025/07/c892aed2df6d6b9e4d56681ccee61a50.png" alt="image-20250713141259962" style="zoom:50%;"> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MAX_TREE_SIZE</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">100</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 树中最多结点数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 树的结点定义</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 数据元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> parent</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 双亲位置域</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">PTNode</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 树的类型定义</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">PTNode </span><span style="--0:#5A676D;--1:#EEFFFF">nodes</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">MAX_TREE_SIZE</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 双亲表示</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> n</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 结点数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">PTree</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="#define MAX_TREE_SIZE 100 // 树中最多结点数typedef struct{ // 树的结点定义 ElemType data; // 数据元素 int parent; // 双亲位置域}PTNode;typedef struct{ // 树的类型定义 PTNode nodes[MAX_TREE_SIZE]; // 双亲表示 int n; // 结点数}PTree;"><div></div></button></div></figure></div> <p>森林。森林是m(m>=0)棵互不相交的树的集合</p> <p>也可以通过这种形式来表示</p> <img src="https://b.1wind.cn/2025/07/dd24f59680fc9cae16342006ce9ef06c.png" alt="image-20250713141925526" style="zoom:50%;"> <p>这样的话，根节点就是多个-1组成，其他的就找到对应的父结点的位置即可</p> <p>优点：找双亲（父结点很方便）</p> <p>缺点：找孩子不方便，只能从头到尾遍历整个数组</p> <p>适用于找“父亲”多，找“孩子”少的应用场景。如：并查集</p> <h4 id="孩子表示法">孩子表示法</h4> <p>孩子表示法：用数组顺序存储各个结点。每个结点中保存数据元素、孩子链表头指针</p> <p>如下图所示</p> <p>存储了元素，每个元素都会有与之对应的子结点的索引，可以很方便的找到子元素</p> <img src="https://b.1wind.cn/2025/07/380b0b756991b6e919bea70ec33569e7.png" alt="image-20250713143110815" style="zoom:50%;"> <p>因为既使用到了数组，又使用到了链表，所以孩子表示法算是一种顺序存储+链式存储的组合</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> CTNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> child</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 孩子结点在数组中的位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> CTNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">next</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 下一个孩子</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> CTNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">firstChild</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 第一个孩子</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">CTBox</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">CTBox </span><span style="--0:#5A676D;--1:#EEFFFF">nodes</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">MAX_TREE_SIZE</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> n</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">r</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 结点数和根的位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">CTree</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="struct CTNode{ int child; // 孩子结点在数组中的位置 struct CTNode *next; // 下一个孩子}typedef struct{ ElemType data; struct CTNode *firstChild; // 第一个孩子}CTBox;typedef struct{ CTBox nodes[MAX_TREE_SIZE]; int n,r; // 结点数和根的位置}CTree;"><div></div></button></div></figure></div> <p>该方法也可运用于森林</p> <img src="https://b.1wind.cn/2025/07/e16d252b8ebf3948c79cf6e807ef7e5b.png" alt="image-20250713143817166" style="zoom:50%;"> <p>注：用孩子表示法存储森林，需要在结构体中记录多个根的位置</p> <p>优点：找孩子很方便</p> <p>缺点：找双亲（父结点）不方便，只能遍历每个链表</p> <p>适用于找“孩子”多，找“父亲”少的应用场景。如：服务流程树</p> <h4 id="孩子兄弟表示法">孩子兄弟表示法</h4> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> CSNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 数据域</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> CSNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">firstchild</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#BE2F2C;--1:#F07178">nextsibling</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 第一个孩子和右兄弟指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">CSNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF">CSTree</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct CSNode{ ElemType data; // 数据域 struct CSNode *firstchild,*nextsibling; // 第一个孩子和右兄弟指针}CSNode,*CSTree"><div></div></button></div></figure></div> <p>也可以用于存储森林，该方法从存储视角来看<strong>形态与二叉树类似</strong></p> <h1 id="二叉树">二叉树</h1> <p>二叉树是n(n>=0)个结点的有限集合：</p> <ol> <li>或者为<strong>空二叉树</strong>，即n=0</li> <li>或者由一个根结点和两个互不相交的被称为根的左子树和右子树组成。左子树和右子树又分别是一颗二叉树。</li> </ol> <p>特点：</p> <ol> <li>每个结点至多只有两棵子树</li> <li>左右子树不能颠倒（二叉树是有序树）</li> </ol> <img src="https://b.1wind.cn/2025/07/4b2d91b34172f4865546db503cc13994.png" alt="image-20250705195507232" style="zoom:50%;"> <h2 id="特殊类型">特殊类型</h2> <h3 id="满二叉树">满二叉树</h3> <p>$$ 一棵高度为h，且含有2^h-1个结点的二叉树 $$</p> <img src="https://b.1wind.cn/2025/07/7fca2c8a6d41a59dd94d2195ebd3c952.png" alt="image-20250705211408439" style="zoom:50%;"> <p>特点：</p> <ol> <li>只有最后一层有叶子结点</li> <li>不存在度为1的结点</li> <li>按层序从1开始编号，结点i的左孩子为2i，右孩子为2i+1；结点i的父节点为[i/2]（如果有的话）</li> </ol> <h3 id="完全二叉树"><strong>完全二叉树</strong></h3> <p>当且仅当其每个结点都与高度为h的满二叉树中编号为1~n的结点一一对应时，称为完全二叉树</p> <img src="https://b.1wind.cn/2025/07/b439a1d6748add6b4891225e45d55707.png" alt="image-20250705213724996" style="zoom:50%;"> <p>特点：</p> <ol> <li>只有最后两层可能有叶子结点</li> <li>最多只有一个度为1的结点</li> <li>同上③</li> <li>i&#x3C;=[n/2]为分支结点，i>[n/2]为叶子结点</li> </ol> <h3 id="二叉排序树"><strong>二叉排序树</strong></h3> <p>一颗二叉树或者是空二叉树，或者是具有如下性质的二叉树：</p> <p>左子树上所有结点的关键字均<strong>小于</strong>根节点的关键字；</p> <p>右子树上所有结点的关键字均<strong>大于</strong>根节点的关键字；</p> <p>左子树和右子树又各是一棵二叉排序树。</p> <img src="https://b.1wind.cn/2025/07/a15d73c752f7e401456e78fb06a05bbc.png" alt="image-20250705214225746" style="zoom:50%;"> <p>二叉排序树可用于元素的排序、搜索</p> <h3 id="平衡二叉树">平衡二叉树</h3> <p>平衡二叉树。树上任一结点的左子树和右子树的深度之差不超过1</p> <img src="https://b.1wind.cn/2025/07/5b10ea4650e96c039c5daffbea72548b.png" alt="image-20250705214558420" style="zoom:50%;"> <p>平衡二叉树能有更高的搜索效率</p> <h2 id="性质">性质</h2> <h3 id="二叉树-1">二叉树</h3> <p>$$ 设非空二叉树中度为0、1、2的结点个数分部为n_0、n_1、n_2，则n_0=n_2+1(叶子结点比二分支结点多一个) $$</p> <p>假设树中结点总数为n，则</p> <ol> <li>$$ <ol> <li>n=n_0+n_1+n_2 \</li> <li>n=n_1+2n_2+1 $$</li> </ol> </li> </ol> <p>$$ 二叉树第i层至多有2^i-1个结点(i>=1) \ m叉树第i层至多有m^{i-1}个结点(i>=1) \ 高度为h的二叉树至多有2^h-1个结点(满二叉树) \ 高度为h的m叉树至多有\frac{m^h-1}{m-1}个结点 $$</p> <h3 id="完全二叉树-1">完全二叉树</h3> <p>$$ 具有n个(n>0)结点的完全二叉树的高度h为\left \lfloor log_2(n+1) \right \rfloor \left \lfloor [log2^n]+1 \right \rfloor \ 高为h的满二叉树共有2^h-1个结点 $$</p> <p>$$ 对于完全二叉树，可以由结点数n推出度为0、1和2的结点个数为n_0、n_1、n_2 \</p> <p>完全二叉树最多只有一个度为1的结点，即n_1=0或1 \</p> <p>n_0=n_2+1 -> n_0-n_2=1 -> 偶数-奇数才为1 -> 偶数+奇数必为奇数 -> n_0+n_2一定是奇数\</p> <p>若完全二叉树有2k个（偶数）结点，则必有n_1=1，n_0=k，n_2=k-1\</p> <p>若完全二叉树有2k-1个（奇数）结点，则必有n_1=0，n_0=k，n_2=k-1\</p> <p>已知res=n_0+n_1+n_2，n_0+n_2为奇数\</p> <p>则n1+奇数 = 偶数 -> n_1 = 1\</p> <p>则n1+奇数 = 奇数 -> n_1 = 0\ $$</p> <h3 id="总结">总结</h3> <p>$$ 二叉树 ：\ n0 = n2 + 1 \ 第i层至多有2^{i-1}个结点(i>=1) \ 高度为h的二叉树至多有2^h - 1个结点 \</p> <p>完全二叉树： \ 具有n个(n>0)结点的完全二叉树的高度h为\left \lfloor log_2(n+2) \right \rfloor 或\left \lfloor log2^n \right \rfloor + 1 \ 对于完全二叉树，可以由结点数n推出0、1、2的结点个数为n_0、n_1、n_2（突破点：完全二叉树最多只会有一个度为1的结点） $$</p> <h2 id="存储结构-3">存储结构</h2> <h3 id="顺序存储-2">顺序存储</h3> <p>二叉树的顺序存储中，一定要把二叉树的结点编号与完全二叉树对应起来</p> <ul> <li> <p>i的左孩子 ---2i</p> </li> <li> <p>i的右孩子 ---2i+1</p> </li> <li> <p>$$</p> <ul> <li>i的父节点 ---\left \lfloor i/2 \right \rfloor $$</li> </ul> </li> </ul> <p>$$ 最坏情况：高度为h且只有h个结点的单支树（所有结点只有右孩子），也至少需要2^h-1个存储单元 $$</p> <p>结论：二叉树的顺序存储结构，只适合存储完全二叉树，因为一旦它只有右孩子，就有很多的空单元</p> <h3 id="链式存储-2">链式存储</h3> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 二叉树的结点（链式存储）</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> BiTNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 数据域</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> BiTNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">lchild</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#BE2F2C;--1:#F07178">rchild</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 左、右孩子指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">BiTNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF">BiTree</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 二叉树的结点（链式存储）typedef struct BiTNode{ ElemType data; // 数据域 struct BiTNode *lchild,*rchild; // 左、右孩子指针}BiTNode,*BiTree;"><div></div></button></div></figure></div> <p>n个结点的二叉链表共有n+1个空链域</p> <h2 id="遍历-1">遍历</h2> <p>二叉树的递归特性：</p> <ol> <li>要么是个空二叉树</li> <li>要么就是由“根节点+左子树+右子树”组成的二叉树</li> </ol> <img src="https://b.1wind.cn/2025/07/682069897b474f607aedb671fc9df140.png" alt="image-20250710145625322" style="zoom:50%;"> <ul> <li>先序遍历（先根遍历）->根左右（NLR）</li> <li>中序遍历->左根右（LNR）</li> <li>后序遍历->左右根（LRN）</li> </ul> <p>先序遍历（PreOrder）的操作过程如下：</p> <ol> <li>若二叉树为空，则什么也不做</li> <li>若二叉树非空： <ol> <li>访问根结点</li> <li>先序遍历左子树</li> <li>先序遍历右子树</li> </ol> </li> </ol> <p>结构体如下</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> BiTNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> BitNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">lchild</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#BE2F2C;--1:#F07178">rchild</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">BiTNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF">BiTree</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct BiTNode{ ElemType data; struct BitNode *lchild,*rchild;}BiTNode,*BiTree;"><div></div></button></div></figure></div> <p>具体算法如下</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">PreOrder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">BiTree </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">!=NULL){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问根结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">PreOrder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 递归遍历左子树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">PreOrder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 递归遍历右子树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="void PreOrder(BiTree T){ if(T!=NULL){ visit(T); // 访问根结点 PreOrder(T->lchild); // 递归遍历左子树 PreOrder(T->rchild); // 递归遍历右子树 }}"><div></div></button></div></figure></div> <p>中序遍历和后序遍历跟前序遍历的差别不是很大,只是改了顺序</p> <p>其实就是递归调用自身去找左右结点</p> <h3 id="层序遍历">层序遍历</h3> <p>从根结点开始自左向右依次变为一个顺序的数据</p> <img src="https://b.1wind.cn/2025/07/5f234993193203e167c124d8a71e10df.png" alt="image-20250710155803652" style="zoom:50%;"> <p>算法思想:</p> <ol> <li>初始化一个辅助队列</li> <li>根结点入队</li> <li>若队列非空,则队头结点出队,访问该结点,并将其左、右孩子插入队尾（如果有的话）</li> <li>重复③直到队列为空</li> </ol> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 层序遍历</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">LevelOrder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">BiTree </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">LinkQueue Q</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InitQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化辅助队列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">BiTree p</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">EnQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将根节点入队</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#4C6690;--1:#82AAFF">IsEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">)){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 队列不空则循环</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">DeQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 队头结点出队</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问出队结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">EnQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 左孩子入队</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">EnQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 右孩子入队</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 层序遍历void LevelOrder(BiTree T){ LinkQueue Q; InitQueue(Q); // 初始化辅助队列 BiTree p; EnQueue(Q,T); // 将根节点入队 while(!IsEmpty(Q)){ // 队列不空则循环 DeQueue(Q,p); // 队头结点出队 visit(p); // 访问出队结点 if(p->lchild != NULL) EnQueue(Q,p->lchild); // 左孩子入队 if(p->rchild != NULL) EnQueue(Q,p->rchild); // 右孩子入队 }}"><div></div></button></div></figure></div> <h2 id="由遍历序列构建二叉树">由遍历序列构建二叉树</h2> <p>只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树</p> <p>因为一种序列会存在着多种形态，没法逆推</p> <p>前序+中序遍历序列</p> <p>举个栗子：</p> <ul> <li>前序遍历序列：A D B C E</li> <li>中序遍历序列：B D C A E</li> </ul> <p>前序遍历是：根 左 右，那么这说明第一个必然是根结点，也就是说，A肯定是根结点</p> <p>中序遍历是：左 根 右，那么根左边就是左子树，右边是右子树</p> <p>则前序遍历中的：D B C是左子树，E是右子树</p> <p>且中序遍历中的：B D C是左子树，E是右子树</p> <p>那么E已经定下来了，接着区分左子树的根节点，前序遍历中：D B C，D是根结点，B是左，C是右</p> <p>中序遍历中的左是B，根是D，C是右</p> <p>最终结果为</p> <img src="https://b.1wind.cn/2025/07/2b32a675b7dd7c1762b007c968581e7f.png" alt="image-20250711184243052" style="zoom: 67%;"> <p>后序的也是类似的，后序遍历的根节点在最后</p> <p>我们就可以通过后序+中序来完整的找出这棵树</p> <p>后序不赘述了，跟前序是一样的</p> <p>层序+中序</p> <p>层序是根左右依次往下，只要找到根，就可以通过中序来找出所有的</p> <p>结论：前序、后序、层序的两两组合是唯一无法确定的一棵二叉树</p> <h2 id="线索二叉树">线索二叉树</h2> <h3 id="概念">概念</h3> <p>指向前驱、后继的指针称为线索</p> <p>指向前驱的称为前驱线索</p> <p>指向后继的称为后继线索</p> <p>n个结点的二叉树，有n+1个空链域，可用来记录前驱、后继的信息</p> <p>将其对应的空置的左、右孩子结点，左孩子指向前驱，右孩子指向后继(此处指的是中序线索二叉树)</p> <p>二叉树也可以叫二叉链表</p> <p>线索二叉树又叫线索链表</p> <p>代码示例</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 二叉树的结点(链式存储)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> BiTNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> BiTNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">lchild</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#BE2F2C;--1:#F07178">rchild</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">BiTNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF">BiTree</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 二叉树的结点(链式存储)typedef struct BiTNode{ ElemType data; struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;"><div></div></button></div></figure></div> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 线索二叉树结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> ThreadNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">lchild</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#BE2F2C;--1:#F07178">rchild</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> ltag</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">rtag</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 左右线索标志</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadTree</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 线索二叉树结点typedef struct ThreadNode{ ElemType data; struct ThreadNode *lchild,*rchild; int ltag,rtag; // 左右线索标志}ThreadNode,*ThreadTree;"><div></div></button></div></figure></div> <ul> <li>tag==0，表示指针指向孩子</li> <li>tag==1，表示指针是线索</li> </ul> <p>其他的二叉树是类似的</p> <h3 id="线索化">线索化</h3> <p>中序线索化</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 全局变量pre，指向当前访问结点的前驱</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF">pre</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 线索二叉树结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> ThreadNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType data</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#BE2F2C;--1:#F07178"> ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">lchild</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#BE2F2C;--1:#F07178">rchild</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> ltag</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">rtag</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 左、右线索标志</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode</span><span style="--0:#256F74;--1:#89DDFF">,*</span><span style="--0:#5A676D;--1:#EEFFFF"> ThreadTree</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 中序线索化二叉树T</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">CreateInThread</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadTree </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">pre</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // pre初始化为NULL</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">!=NULL){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 非空二叉树才能线索化</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InThread</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 中序线索化二叉树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">pre </span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">pre</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rtag</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 处理遍历的最后一个结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 中序遍历二叉树，一边遍历一边线索化</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InThread</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadTree </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">!=NULL){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InThread</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 中序遍历左子树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问根结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">26</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InThread</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 中序遍历右子树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">27</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">28</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">29</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">30</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">q</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">31</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">==NULL){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 左子树为空，建立前驱线索</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">32</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">pre</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">33</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">q</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">ltag</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">34</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">35</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">pre</span><span style="--0:#256F74;--1:#89DDFF">!=NULL</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">pre</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">==NULL){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">36</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">pre</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">q</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 建立前驱结点的后继线索</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">37</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">pre</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rtag</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">38</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">39</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">pre</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">q</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 向前移动pre指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">40</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 全局变量pre，指向当前访问结点的前驱ThreadNode *pre=NULL;// 线索二叉树结点typedef struct ThreadNode{ ElemType data; struct ThreadNode *lchild,*rchild; int ltag,rtag; // 左、右线索标志}ThreadNode,* ThreadTree;// 中序线索化二叉树Tvoid CreateInThread(ThreadTree T){ pre=NULL; // pre初始化为NULL if(T!=NULL){ // 非空二叉树才能线索化 InThread(T); // 中序线索化二叉树 if (pre -> rchild == NULL) pre->rtag=1; // 处理遍历的最后一个结点 }}// 中序遍历二叉树，一边遍历一边线索化void InThread(ThreadTree T){ if (T!=NULL){ InThread(T->lchild); // 中序遍历左子树 visit(T); // 访问根结点 InThread(T->rchild); // 中序遍历右子树 }}void visit(ThreadNode *q){ if (q->lchild==NULL){ // 左子树为空，建立前驱线索 q->lchild=pre; q->ltag=1; } if (pre!=NULL &#x26;&#x26; pre->rchild==NULL){ pre->rchild=q; // 建立前驱结点的后继线索 pre->rtag=1; } pre=q; // 向前移动pre指针}"><div></div></button></div></figure></div> <p>前序和后序是类似的</p> <p>但是前序会有一个问题，当访问的是根结点时，根结点恰好左结点是空的，那么就会将左结点->前驱结点指向上一个结点，对吧，如果上一个结点是根结点，并且它的左结点是之前这个所谓的”根结点”</p> <p>此时会按照根，左，右的顺序访问，这样访问的问题就是下一个访问的是左结点，那么这个左结点又会按照根左右的顺序回头继续这样</p> <p>导致无限循环</p> <p>这个问题解决起来其实不难，在该根结点做了前驱线索化后，存在一个tag标记，只要这里有tag标记，不进行左结点回头就行了</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">tag </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">PreThread</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">lchild</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // lchild不是前驱线索</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="if (T->tag == 0) PreThread(T->lchild); // lchild不是前驱线索"><div></div></button></div></figure></div> <h3 id="寻找前驱后继">寻找前驱后继</h3> <h4 id="中序">中序</h4> <p>中序线索二叉树找中序后继(后继是该结点的下一个结点)</p> <p>在中序线索二叉树找到指定结点*p的中序后继next</p> <ol> <li>若p->rtag==1，则next=p->rchild，因为此时右结点被线索化了，说明它是后继结点</li> <li>若p->rtag==0 <ol> <li>p必有右孩子</li> <li>next = p的右子树中最左下的结点，因为中序结点最先访问的是左结点</li> </ol> </li> </ol> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 找到以P为根的子树，第一个被中序遍历的结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#4C6690;--1:#82AAFF">Firstnode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//循环找到最左下结点(不一定是叶结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">ltag</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> p</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在中序线索二叉树中找到结点p的后继结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#4C6690;--1:#82AAFF">Nextnode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 右子树中最左下结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rtag</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">Firstnode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // rtag==1直接返回后继线索</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 对中序线索二叉树进行中序遍历(利用线索实现的非递归算法)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Inorder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">Firstnode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">!=NULL;</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">Nextnode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">))</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 找到以P为根的子树，第一个被中序遍历的结点ThreadNode *Firstnode(ThreadNode *p){ //循环找到最左下结点(不一定是叶结点) while(p->ltag==0)p=p->lchild; return p;}// 在中序线索二叉树中找到结点p的后继结点ThreadNode *Nextnode(ThreadNode *p){ // 右子树中最左下结点 if(p->rtag==0)return Firstnode(p->rchild); else return p->rchild; // rtag==1直接返回后继线索}// 对中序线索二叉树进行中序遍历(利用线索实现的非递归算法)void Inorder(ThreadNode *T){ for(ThreadNode *p=Firstnode(T);p!=NULL;p=Nextnode(p)) visit(p);}"><div></div></button></div></figure></div> <p>中序线索二叉树找中序前驱(前驱是该结点的下一个结点)</p> <p>在中序线索二叉树中找到指定结点*p的中序前驱pre</p> <ol> <li>若p->ltag==1，则pre=p->lchild</li> <li>p->ltag==0 <ol> <li>p必有左孩子</li> <li>pre = p的左子树中最右下结点</li> </ol> </li> </ol> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 找到以P为根的子树，最后一个被中序遍历的结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#4C6690;--1:#82AAFF">Lastnode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 循环找到最右下结点(不一定是叶结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rtag</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> p</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在中序线索二叉树中找到结点p的前驱结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#4C6690;--1:#82AAFF">Prenode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">p</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 左子树最右下结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=></span><span style="--0:#BE2F2C;--1:#F07178">ltag</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">Lastnode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // ltag==1直接返回前驱线索</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 对中序线索二叉树进行逆向中序遍历</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">RevInorder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">ThreadNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">Lastnode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">!=NULL;</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">Prenode</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">))</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 找到以P为根的子树，最后一个被中序遍历的结点ThreadNode *Lastnode(ThreadNode *p){ // 循环找到最右下结点(不一定是叶结点) while(p->rtag==0)p=p->rchild; return p;}// 在中序线索二叉树中找到结点p的前驱结点ThreadNode *Prenode(ThreadNode *p){ // 左子树最右下结点 if(p=>ltag==0)return Lastnode(p->lchild); else return p->lchild; // ltag==1直接返回前驱线索}// 对中序线索二叉树进行逆向中序遍历void RevInorder(ThreadNode *T){ for(ThreadNode *p=Lastnode(T);p!=NULL;p=Prenode(p)) visit(p);}"><div></div></button></div></figure></div> <h4 id="先序">先序</h4> <p>在先序线索二叉树中找到指定结点*p的后继</p> <ol> <li>若p->rtag==1，则next = p->rchild</li> <li>若p->rtag==0 <ol> <li>若p有左孩子，则先序后继为左孩子</li> <li>若p没有左孩子，则先序后继为右孩子</li> </ol> </li> </ol> <p>它跟中序差别很大，因为它是按照根、左、右的顺序来的，所以无论是哪个，都不需要继续往后找，因为左孩子和右孩子都会是根结点</p> <p>在先序线索二叉树中找到指定结点*p的前驱pre</p> <ol> <li>若p->ltag==1，则next = p->lchild</li> <li>若p>ltag==0</li> </ol> <p>此时出现了一个问题，左右子树中的结点只可能是后继，不可能是前驱</p> <p>因为是按照根、左、右的顺序来的，所以没办法</p> <p>除非从头开始先序遍历，一个个的找</p> <p>假设能找到父结点(该假设建立在可以逆向寻找父结点的情况下)，具体情况如下</p> <img src="https://b.1wind.cn/2025/07/693cc003ea1fc2f1777f6382c004425b.png" alt="image-20250713112342576" style="zoom:67%;"> <h4 id="后序">后序</h4> <p>在后序线索二叉树中找到指定结点*p的后序前驱pre</p> <ol> <li>若p->ltag==1，则pre = p->lchild</li> <li>若p->ltag==0 <ol> <li>p必有左孩子 <ol> <li>若p有右孩子，则后序前驱为右孩子，因为根是最后访问的，前驱指的是前一个，所以是右孩子</li> <li>若p没有右孩子，则后序前驱为左孩子</li> </ol> </li> </ol> </li> </ol> <p>因为后序是左、右、根来遍历的</p> <p>在后序线索二叉树中找到指定结点*p的后序后继next</p> <ol> <li>若p->rtag==1，则next = p->rchild</li> <li>若p->rtag==0 <ol> <li>p必有右孩子 <ol> <li>后序遍历中，左右子树中的结点只可能是根的前驱，不可能是后继</li> </ol> </li> </ol> </li> </ol> <p>因为左右遍历完了才到根，所以没法找到后序的后继，除非从头开始遍历</p> <p>假设能找到父结点(该假设建立在可以逆向寻找父结点的情况下)，具体情况如下</p> <img src="https://b.1wind.cn/2025/07/f3e88401a3e7916d289c77f9d0726645.png" alt="image-20250713113306739" style="zoom:50%;"> <h4 id="总结-1">总结</h4> <table><thead><tr><th></th><th>中序</th><th>先序</th><th>后序</th></tr></thead><tbody><tr><td>找前驱</td><td>√</td><td>×</td><td>√</td></tr><tr><td>找后继的</td><td>√</td><td>√</td><td>×</td></tr></tbody></table> <p>除非用三叉链表，或者从头开始遍历寻找</p> <h1 id="树森林二叉树的转换">树、森林、二叉树的转换</h1> <h2 id="树-二叉树">树->二叉树</h2> <ol> <li>先在二叉树中，画一个根节点</li> <li>按“树的层序”依次处理每个结点</li> </ol> <p>处理一个结点的方法是：如果当前处理的结点在树中有孩子，就把所有孩子结点“用右指针串成糖葫芦”，并在二叉树中把第一个孩子挂在当前结点的左指针下方</p> <h2 id="森林-二叉树">森林->二叉树</h2> <p>注意：森林中各棵树的根节点视为平级的兄弟关系</p> <p>森林->二叉树转换技巧</p> <ol> <li>先把所有树的根节点画出来，在二叉树中用右指针串成糖葫芦</li> <li>按森林的层序依次处理每个结点</li> </ol> <p>处理一个结点的方法是：如果当前处理的结点在树中有孩子，就把所有孩子结点“用右指针串成糖葫芦”，并在二叉树中把第一个孩子挂在当前结点的左指针下方</p> <h2 id="二叉树-树">二叉树->树</h2> <p>二叉树->树 转换技巧：</p> <ol> <li>先画出树的根节点</li> <li>从树的根节点开始，按“树的层序”恢复每个结点的孩子</li> </ol> <p>如何恢复一个结点的孩子：在二叉树中，如果当前处理的结点有左孩子，就把左孩子和“一整串右指针糖葫芦”拆下来，按顺序挂在当前结点的下方</p> <h2 id="二叉树-森林">二叉树->森林</h2> <p>注意：森林中各棵树的根节点视为平级的兄弟关系</p> <p>二叉树->森林转换技巧：</p> <ol> <li>先把二叉树的根节点和“一整串右指针糖葫芦”拆下来，作为多棵树的根节点</li> <li>按“森林的层序”恢复每个结点的孩子</li> </ol> <p>如何恢复一个结点的孩子：在二叉树中，如果当前处理的结点有左孩子，就把左孩子和“一整串右指针糖葫芦”拆下来，按顺序挂在当前结点的下方</p> <h1 id="树森林的遍历">树、森林的遍历</h1> <h2 id="树的先根遍历">树的先根遍历</h2> <p>先根遍历又称深度优先遍历</p> <p>先根遍历：若树为空，先访问根结点，再依次对每棵子树进行先根遍历</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 树的先根遍历</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">PreOrder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">TreeNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">R</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">R</span><span style="--0:#256F74;--1:#89DDFF">!=NULL){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">R</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问根结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">R还有下一个子树T</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">PreOrder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //继续先根遍历下一棵子树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 树的先根遍历void PreOrder(TreeNode *R){ if(R!=NULL){ visit(R); // 访问根结点 while(R还有下一个子树T) PreOrder(T); //继续先根遍历下一棵子树 }}"><div></div></button></div></figure></div> <p>树的先根遍历序列与这棵树相应二叉树的先序序列相同</p> <h2 id="树的后根遍历">树的后根遍历</h2> <p>后根遍历又称深度优先遍历</p> <p>后根遍历。若树为空，先依次对每棵子树进行后根遍历，最后再访问根结点</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 树的后根遍历</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">PostOrder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">TreeNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">R</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">R</span><span style="--0:#256F74;--1:#89DDFF">!=NULL){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">R还有下一个子树T</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">PostOrder</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 后根遍历下一棵子树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">R</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问根结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 树的后根遍历void PostOrder(TreeNode *R){ if (R!=NULL){ while(R还有下一个子树T) PostOrder(T); // 后根遍历下一棵子树 visit(R); // 访问根结点 }}"><div></div></button></div></figure></div> <p>树的后根遍历序列与这棵树相应二叉树的中序序列相同</p> <h2 id="树的层次遍历">树的层次遍历</h2> <p>层次遍历（用队列实现）</p> <p>层次遍历又称广度优先遍历</p> <ol> <li>若树非空，则根结点入队</li> <li>若队列非空，队头元素出队并访问，同时将该元素的孩子依次入队</li> <li>重复②直到队列为空</li> </ol> <h2 id="森林的先序遍历">森林的先序遍历</h2> <p>先序遍历森林</p> <ol> <li>若森林非空，则按如下规则进行遍历</li> <li>访问森林中第一棵树的根节点</li> <li>先序遍历第一棵树中根节点的子树森林</li> <li>先序遍历除去第一棵树之后剩余的树构成的森林</li> </ol> <p>效果等同于依次对各个树进行先根遍历</p> <h2 id="森林的中序遍历">森林的中序遍历</h2> <p>中序遍历森林</p> <ol> <li>若森林非空，则按如下规则进行遍历：</li> <li>中序遍历森林中第一棵树的根结点的子树森林</li> <li>访问第一棵树的根结点</li> <li>中序遍历除去第一棵树之后剩余的树构成的森林</li> </ol> <p>效果等同于依次对二叉树进行中序遍历</p> <h1 id="哈夫曼树">哈夫曼树</h1> <h2 id="带权路径长度">带权路径长度</h2> <p>结点的权：有某种现实含义的数值（如：表示结点的重要性等）</p> <p>结点的带权路径长度：从树的根到该结点的路径长度（经过的边数）与该结点上权值的乘积</p> <p>树的带权路径长度：树中所有叶结点的带权路径长度之和（WPL，Weighted Path Length）</p> <p>计算公式如下：</p> <p><img src="https://b.1wind.cn/2025/07/65ce7e66e7760658039fc115f42e7fe7.png" alt="image-20250713195904439"></p> <p>具体示例如下，其实就是将结点的带权路径长度统一相加了而已：</p> <p><img src="https://b.1wind.cn/2025/07/07a5d98a7f63b38925aa8f9d69d2214e.png" alt="image-20250713200157841"></p> <p>在含有n个带权叶结点的二叉树中，其中带权路径长度（WPL）最小的二叉树称为哈夫曼树，也称最优二叉树</p> <h2 id="构造">构造</h2> <p>$$ 给定n个权值分别为w_1,w_2…w_n的结点，构造哈夫曼树的算法描述如下： $$</p> <ol> <li>将这n个结点分别作为n棵仅含一个结点的二叉树，构成森林F</li> <li>构造一个新结点，从F中选取两棵根结点权值最小的树作为新结点的左、右子树，并且将新结点的权值置为左、右子树上根结点的权值之和</li> <li>从F中删除刚才选出的两棵树，同时将新得到的树加入F中</li> <li>重复步骤2和3，直到F中只剩下一棵树为止</li> </ol> <p>具体示例如下</p> <p><img src="https://b.1wind.cn/2025/07/17405428ce5dd925c3895f55e872981d.png" alt="image-20250713201016603"></p> <ol> <li>每个初始结点最终都称为叶结点，且权值越小的结点到根结点的路径长度越大</li> <li>哈夫曼树的结点总数为2n-1</li> <li>哈夫曼树中不存在度为1的结点</li> <li>哈夫曼树并不唯一，但WPL必然相同且为最优</li> </ol> <h2 id="哈夫曼编码">哈夫曼编码</h2> <p>固定长度编码：每个字符用相等长度的二进制位表示</p> <p>可变长度编码：允许对不同字符用不等长的二进制位表示</p> <p>若没有一个编码是另一个编码的前缀，则称这样的编码为<strong>前缀编码</strong></p> <p>由哈夫曼树得到哈夫曼编码---字符集中的每个字符作为一个叶子结点，各个字符出现的频率作为结点的权值，根据之前介绍的方法构造哈夫曼树</p> <p>哈夫曼树不唯一，因此哈夫曼编码不唯一</p> <h1 id="并查集">并查集</h1> <h2 id="基本功能">基本功能</h2> <p>集合的两个基本操作---“并”和“查”</p> <p>Find---查操作：确定一个指定元素所属集合</p> <p>Union---并操作：将两个不相交的集合合并为一个</p> <p>注：并查集（Disjoint Set）是逻辑结构---集合的一种具体实现，只进行并和查两种基本操作</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化,刚开始所有集合都是独立的子集</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> UFSets</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">SIZE</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 集合元素数组</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 初始化并查集</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Initial</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">SIZE</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]=-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// Find "查"操作，找x所属集合(返回x所属根结点)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Find</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">]>=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 循环寻找x的根</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> x</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 根的S[]小于0</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// Union "并"操作，将两个集合合并为一个</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Union</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Root1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Roo2</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 要求Root1与Root2是不同的集合</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Root1 </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> Root2</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 将根Root2连接到另一根Root1下面</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">Root2</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#BE2F2C;--1:#F07178">Root1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 初始化,刚开始所有集合都是独立的子集int UFSets[SIZE]; // 集合元素数组// 初始化并查集void Initial(int S[]){ for(int i=0;i<SIZE;i++) S[i]=-1;}// Find &#x22;查&#x22;操作，找x所属集合(返回x所属根结点)int Find(int S[],int x){ while(S[x]>=0) x=S[x]; // 循环寻找x的根 return x; // 根的S[]小于0}// Union &#x22;并&#x22;操作，将两个集合合并为一个void Union(int S[],int Root1,int Roo2){ // 要求Root1与Root2是不同的集合 if (Root1 == Root2) return; // 将根Root2连接到另一根Root1下面 S[Root2]=Root1;}"><div></div></button></div></figure></div> <p>但是这样的查操作有时候会出现一个问题，最好的情况是O(1)，最坏的情况是O(n)，因为如果树是高的，从最下面找到最上面就相当麻烦</p> <p>优化思路：在每次Union操作构建树的时候，尽可能让树不长高</p> <ol> <li>用根结点的绝对值表示树的结点总数</li> <li>Union操作，让小树合并到大树</li> </ol> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//Union 合并操作优化</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Union</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Root1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">Root2</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Root1 </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> Root2</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">Root2</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">Root1</span><span style="--0:#256F74;--1:#89DDFF">]){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // Root2结点数更少</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">Root1</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">+=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">Root2</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 累加结点总数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">Root2</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> Root1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从小树合并到大树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">Root2</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">+=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">Root1</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 累加结点总数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">Root1</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> Root2</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //从小树合并到大树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="//Union 合并操作优化void Union(int S[],int Root1,int Root2){ if(Root1 == Root2)return; if (S[Root2] > S[Root1]){ // Root2结点数更少 S[Root1] += S[Root2]; // 累加结点总数 S[Root2] = Root1; // 从小树合并到大树 }else{ S[Root2] += S[Root1]; // 累加结点总数 S[Root1] = Root2; //从小树合并到大树 }}"><div></div></button></div></figure></div> <h2 id="优化">优化</h2> <h3 id="find优化">Find优化</h3> <p>Find操作优化(压缩路径)</p> <p>压缩路径---Find操作，先找到根结点，再将查找路径上所有结点都挂到根结点下</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// Find 查操作优化，先找到根结点，再进行压缩路径</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Find</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">S</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">x</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> root </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> x</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">root</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> root </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">root</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178">root</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 压缩路径</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> t </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // t指向x的父结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">S</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">x</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> root</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // x挂在根结点下</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">x </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> t</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> root</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// Find 查操作优化，先找到根结点，再进行压缩路径int Find(int S[],int x){ int root = x; while(S[root] >= 0) root = S[root]; while(x!=root){ // 压缩路径 int t = S[x]; // t指向x的父结点 S[x] = root; // x挂在根结点下 x = t; } return root;}"><div></div></button></div></figure></div> <h1 id="图">图</h1> <h2 id="定义-2">定义</h2> <p>$$ 图G由顶点集V和边集E组成，记为G=(V,E)，其中V(G)表示图G中顶点的有限非空集；\ E(G)表示图G中顶点之间的关系(边)集合。\ 若V={v_1,v_2,…,v_n}，则用|V|表示图G中顶点的个数，也称图G的阶，E={(u,v)|u∈V,v∈V}\ 用|E|来表示图G中边的条数。 $$</p> <p>注意：线性表可以是空表，树可以是空树，但图不可以是空，即V一定是非空集，E可以是空集，即边集可以是空集</p> <h2 id="无向图有向图">无向图、有向图</h2> <p>无向图其实就是没有指明方向的图</p> <p><img src="https://b.1wind.cn/2025/07/ab2607ffa6c8189b2c2434f0e8284cd0.png" alt="image-20250716140537985"></p> <p>有向图就是有方向的图</p> <p><img src="https://b.1wind.cn/2025/07/1138bc825f4bd71f08c3a0ba3b539ec2.png" alt="image-20250716140605291"></p> <h2 id="简单图多重图">简单图、多重图</h2> <p>简单图</p> <ol> <li>不存在重复的边</li> <li>不存在顶点到自身的边</li> </ol> <p>下面所有的图，只探讨简单图</p> <p>多重图：图G中某两个结点之间的边数多于一条，又允许顶点通过同一条边和自己关联，则G为多重图</p> <p>具体情况如下图所示：</p> <p><img src="https://b.1wind.cn/2025/07/92fd74e87a110b4e352d251626a249c9.png" alt="image-20250716141218682"></p> <h2 id="顶点的度入度出度">顶点的度、入度、出度</h2> <p>对于无向图：顶点v的度是指依附于该顶点的边的条数，记为TD(v)</p> <p>无向图的全部顶点的度之和等于边数的2倍</p> <p>对于有向图：</p> <ul> <li>入度是以顶点v为终点的有向边的数目，记为ID(v)</li> <li>出度是以顶点v为起点的有向边的数目，记为OD(v)</li> <li>顶点v的度等于其入度和出度之和，即TD(v)=ID(v)+OD(v)</li> </ul> <h2 id="顶点-顶点的关系描述">顶点->顶点的关系描述</h2> <p>$$ 路径：顶点v_p到顶点v_q之间的一条路径是指顶点序列,就是说从v_p到v_q之间需要经过的结点及内容就是一整条路径 $$</p> <p>无向图可能不存在路径</p> <p>有向图的路径也是有向的 $$ 回路：第一个顶点和最后一个顶点相同的路径称为回路或环 \ 简单路径：在路径序列中，顶点不重复出现的路径称为简单路径 \ 简单回路：除第一个顶点和最后一个顶点外，其余顶点不重复出现的回路称为简单回路 \ 路径长度：路径上边的数目 \ 点到点的距离：从顶点u出发到顶点v的最短路径若存在，则此路径的长度称为从u到v的距离。若从u到v根本不存在路径\ 则记该距离为无穷 $$ 无向图中，若顶点v到顶点w由路径存在，则称v和w是<strong>连通</strong>的</p> <p>有向图中，若从顶点v到顶点w和从顶点w到顶点v之间都有路径，则称这两个顶点是<strong>强连通</strong>的</p> <h2 id="连通图强连通图">连通图、强连通图</h2> <p>若图G中任意两个顶点都是连通的，则称图G为连通图，否则称为非连通图</p> <p>若图中任何一对顶点都是强连通的，则称此图为强连通图 $$ 对于n个顶点的无向图G，若G是连通图，则最少有n-1条边 \ 若G是非连通图，则最多可能有C^2_{n-1}条边 $$</p> <p>$$ 对于n个顶点的有向图G，若G是强连通图，则最少有n条边(形成回路) $$</p> <h2 id="子图">子图</h2> <p>有向图和无向图在子图的概念里是一致的</p> <p><img src="https://b.1wind.cn/2025/07/fdc9f9fd4eb641ee15c2bf2f488a6f1d.png" alt="image-20250716154634205"></p> <h2 id="连通分量">连通分量</h2> <p>无向图中的极大连通子图称为连通分量</p> <p>如图所示</p> <img src="https://b.1wind.cn/2025/07/ed0a5e3e004c839fbffa2a708dce5e8b.png" alt="image-20250716154842026" style="zoom:50%;"> <h2 id="强连通分量">强连通分量</h2> <p>有向图中的极大强连通子图称为有向图的强联通分量</p> <p>子图必须强连通，同时保留尽可能多的边</p> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/07/b370c915152c522078eb6f64eeecf2b0.png" alt="image-20250716155509605"></p> <h2 id="生成树">生成树</h2> <p>连通图的生成树是包含图中全部顶点的一个极小连通子图</p> <p>边要尽可能的少，但是要保持连通</p> <p>若图中顶点数为n，则它的生成树含有n-1条边。对生成树而言，若砍去它的一条边，则会变成非连通图，若加上一条边则会形成一条回路</p> <h2 id="生成森林">生成森林</h2> <p>在非连通图中，连通分量的生成树构成了非连通图的生成森林</p> <p>多个生成树构成了一个生成森林</p> <h2 id="边的权带权图网">边的权、带权图/网</h2> <p>边的权---在一个图中，每条边都可以标上具有某种含义的数值，该数值称为该边的权值</p> <p>带权图/网---边上带有权值的图称为带权图，也称网</p> <p>带权路径长度---当图是带权图时，一条路径上所有边的权值之和，称为该路径的带权路径长度</p> <h2 id="特殊的图">特殊的图</h2> <p>无向完全图与有向完全图<img src="https://b.1wind.cn/2025/07/6eefa3153e62c811a4196dcced960412.png" alt="image-20250716162902929" style="zoom:50%;"></p> <p>稀疏图和稠密图</p> <img src="https://b.1wind.cn/2025/07/739525a89a1f7284dd4d795dd224269e.png" alt="image-20250716163030398" style="zoom:50%;"> <p>树和有向树</p> <img src="https://b.1wind.cn/2025/07/d64b894c3cda8544318e9acb5fc5b62f.png" alt="image-20250716163347642" style="zoom:50%;"> <h2 id="邻接矩阵法">邻接矩阵法</h2> <p>在领接矩阵求对应的度</p> <p>无向图：第i个结点的度=第i行(或第i列)的非零元素个数</p> <p>有向图：</p> <ul> <li>第i个结点的出度=第i行的非零元素个数</li> <li>第i个结点的入度=第i列的非零元素个数</li> <li>第i个结点的度=第i行、第i列的非零元素个数之和</li> </ul> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/07/de7242db11f47ead22d72f90719debb6.png" alt="image-20250717161245211"></p> <h2 id="领接矩阵存储带权图">领接矩阵存储带权图</h2> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/07/a6cfb4945eb4e543fc41402a6d176430.png" alt="image-20250717161327024"></p> <h2 id="邻接表法">邻接表法</h2> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/07/657d3b57c5d2f8af9739b31617d59d6c.png" alt="image-20250717163620941"></p> <h2 id="十字链表邻接多重表">十字链表、邻接多重表</h2> <p>十字链表用于存储有向图，邻接多重表用于存储无向图</p> <p><strong>十字链表法存储有向图</strong></p> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/07/adf8469f9bcac521483c41f81c630d59.png" alt="image-20250718141722483"></p> <p>如何找到指定顶点的所有出边？---顺着绿色线路找</p> <p>如何找到指定顶点的所有入边？---顺着橙色线路找</p> <p>直到为空，说明找到底了</p> <p>注意：十字链表法只能存储有向图</p> <p><strong>邻接多重表存储无向图</strong></p> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/07/e8ad29c99d3e11f418212da2c25cf6da.png" alt="image-20250718142906416"></p> <p>删除边、删除节点等操作很方便</p> <p>例如删除A针对B的边只需要将A针对B的边后移一位，跳过B即可</p> <p>如果是删除结点，则需要正常移除当前结点，并对拥有该结点的指针往后一位指，如果有值，指向值，如果没值，指向空</p> <p>注意：邻接多重表只适合存储无向图</p> <h2 id="基本操作-3">基本操作</h2> <p>Adjacent(G,x,y)：判断图G是否存在边&#x3C;x,y>或(x,y)</p> <p>无向图</p> <ul> <li>以B,D为例</li> <li>使用邻接矩阵来存储，找到B和D对应的那个值是否为1即可</li> <li>使用邻接表来存储，检查B的边结点有没有D对应的索引值</li> </ul> <p>有向图与无向图是一样的</p> <p><img src="https://b.1wind.cn/2025/07/f700ecef1bb19202c64bc7ce9ee823c2.png" alt="image-20250718150656536"></p> <p>Neighbors(G,x)：列出图G中与结点x邻接的边</p> <p>无向图</p> <ul> <li>以B为例</li> <li>使用邻接矩阵来存储，找到B这一行中值为1的结点即可</li> <li>使用邻接表来存储，遍历该结点下的所有结点，都是邻接的边</li> </ul> <p>有向图</p> <ul> <li>以B为例</li> <li>使用邻接矩阵来存储，想找到入边，遍历B这一行中值为1的结点即可，出边遍历B的这一列即可</li> <li>使用邻接表来存储，遍历该结点下的所有结点，都是邻接的入边，如果找出边，就需要遍历所有结点，来找到指向B的结点</li> </ul> <p><img src="https://b.1wind.cn/2025/07/d48927debf2c56cdc3b81f819957a902.png" alt="image-20250718150909409"></p> <p>InsertVertex(G,x)：在图G中插入顶点x</p> <p>无向图</p> <ul> <li>在保存数据的位置(数组)写入一个新数值即可，邻接矩阵中不需要其他操作，因为数组初始化的值为0,</li> <li>邻接表需要在最下方插入新结点，并将它的其他连接点置为空(NULL)</li> </ul> <p>有向图也是类似的</p> <p><img src="https://b.1wind.cn/2025/07/93bdf6687821df53bb2e5e901305747e.png" alt="image-20250718162054665"></p> <p>DeleteVertex(G,x)：从图G中删除顶点x</p> <p>无向图</p> <ul> <li>邻接矩阵中只需要移除对应的元素要删除的行和列，并在数组的标志中标记为空(NULL)</li> <li>领接表中如果要删除数据，需要先删除当前需要删除的值，再删除其他结点中存在该删除的值的索引</li> </ul> <p>有向图</p> <ul> <li>邻接矩阵和无向图的一致</li> <li>邻接表如果要删除出边，只需要删除当前需要删除的索引值即可</li> <li>邻接表如果要删除入边，需要遍历其他结点，找到当前结点进行删除</li> </ul> <p><img src="https://b.1wind.cn/2025/07/93bdf6687821df53bb2e5e901305747e.png" alt="image-20250718202520385"></p> <p>AddEdge(G,x,y)：若无向边(x,y)或有向边&#x3C;x,y>不存在，则向图G中添加该边</p> <p>无向图</p> <ul> <li>邻接矩阵直接向指定位置赋值为1即可</li> <li>邻接表直接使用头插法或者尾插法将对应的索引插入到两边(<strong>是两边</strong>)对应的位置</li> </ul> <p>有向图是类似的</p> <p><img src="https://b.1wind.cn/2025/07/93bdf6687821df53bb2e5e901305747e.png" alt="image-20250718202520385"></p> <p>FirstNeighbor(G,x)：求图G中顶点x的第一个邻接点，若有则返回顶点号。若x没有领接点或图中不存在x，则返回-1</p> <p>无向图</p> <ul> <li>邻接矩阵只需要扫描对应的这一行的第一个1，若有则返回顶点号，否则-1</li> <li>邻接表只需要找到对应索引链表的根结点</li> </ul> <p>有向图</p> <ul> <li>领接矩阵找入边是列，找出边是行，找到第一个1</li> <li>邻接表找出边跟无向图是一样的，找入边需要遍历整个链表，找到第一个指向该结点的位置</li> </ul> <p><img src="https://b.1wind.cn/2025/07/93bdf6687821df53bb2e5e901305747e.png" alt="image-20250718202520385"></p> <p>NextNeighbor(G,x,y)：假设图G中顶点y是顶点x的一个领接点，返回除y之外顶点x的下一个领接点的顶点号，若y是x的最后一个领接点，则返回-1</p> <p>【说人话就是找到这个领接点的下一个领接点结点】</p> <p>无向图</p> <ul> <li>领接矩阵只需要遍历找到下一个结点</li> <li>领接表只需要对应的结点往后找一位就行了</li> </ul> <p>有向图类似</p> <p><img src="https://b.1wind.cn/2025/07/93bdf6687821df53bb2e5e901305747e.png" alt="image-20250718202520385">`</p> <p>Get_edge_value(G,x,y)：获取图G中边(x,y)或&#x3C;x,y>对应的权值</p> <p>Set_edge_value(G,x,y,v)：设置图G中边(x,y)或&#x3C;x,y>对应的权值为v</p> <h2 id="广度优先遍历">广度优先遍历</h2> <h3 id="算法-1">算法</h3> <p>图的广度优先遍历与树其实是类似的，也叫层序遍历，一层一层的访问相邻结点</p> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/07/f0d975eb427268eececb08465e4549d8.png" alt="image-20250719140643676"></p> <p>树的层序遍历就是1,2,3,4,5,6,7,8依次下去，因为相邻结点被依次的遍历了</p> <p>而图假设从2开始，那么是2,1,6,5,3,7,4,8这样，也和树极其相似</p> <p>当然它俩是有区别的</p> <p>树是不存在回路的，搜索相邻结点时，不可能搜到已经访问过的结点</p> <p>图搜索相邻顶点时，有可能搜到已经访问过的顶点</p> <p>当然，我们可以给遍历过的结点做一个标记，在回头找其他结点时，直接跳过被遍历的结点</p> <p>广度优先遍历（Breadth-First-Search，BFS）要点</p> <ol> <li>找到与一个顶点相邻的所有顶点</li> <li>标记哪些顶点被访问过</li> <li>需要一个辅助队列</li> </ol> <p>具体实现代码如下</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">MAX_VERTEX_NUM</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //访问标记数组</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 广度优先遍历</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">BFS</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Graph </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">v</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从顶点v出发，广度优先遍历图G</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问初始顶点v</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">]=TRUE;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 对v做已访问标记</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">Enqueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 顶点v入队列Q</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#4C6690;--1:#82AAFF">isEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">)){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">DeQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">FirstNeighbor</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">NextNeighbor</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">)){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 检测v所有邻接点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">]){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // w为v的尚未访问的领接顶点[根据visited数组中对应的值来判断]</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问顶点w</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">]=TRUE;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 对w做已访问标记</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">EnQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 顶点w入队列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// if</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// for</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// while</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool visited[MAX_VERTEX_NUM]; //访问标记数组// 广度优先遍历void BFS(Graph G,int v){ // 从顶点v出发，广度优先遍历图G visit(v); // 访问初始顶点v visited[v]=TRUE; // 对v做已访问标记 Enqueue(Q,v); // 顶点v入队列Q while(!isEmpty(Q)){ DeQueue(Q,v); for(w=FirstNeighbor(G,v);w>=0;w=NextNeighbor(G,v,w)){ // 检测v所有邻接点 if(!visited[w]){ // w为v的尚未访问的领接顶点[根据visited数组中对应的值来判断] visit(w); // 访问顶点w visited[w]=TRUE; // 对w做已访问标记 EnQueue(Q,w); // 顶点w入队列 }// if }// for }// while}"><div></div></button></div></figure></div> <p>访问标记数组长这样</p> <table><thead><tr><th></th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th><th>6</th><th>7</th><th>8</th></tr></thead><tbody><tr><td>visited</td><td>false</td><td>false</td><td>false</td><td>false</td><td>false</td><td>false</td><td>false</td><td>false</td></tr></tbody></table> <p>举个栗子</p> <p>以该图为例，右侧是图</p> <p>假设初始顶点v是2，那么访问2，并将visited数组对应的结点设为TRUE，将顶点v加入队列Q</p> <p>当队列Q不为空时，顶点v，也就是2出队</p> <p>循环找到顶点v的邻接点，1和6，并检查结点是否已经被访问过了，很显然都没被访问过</p> <p>访问这俩结点，并设置为已访问，进行入队</p> <p>继续for循环，找到邻接点，以1为例，判断领接点是否被访问</p> <p>1的邻接点为2和5</p> <p>2被访问过，不走2,5入队</p> <p>接着回到while,6号出队</p> <p>后面的都是类似，不再赘述了</p> <p><img src="https://b.1wind.cn/2025/07/f0d975eb427268eececb08465e4549d8.png" alt="image-20250719140643676"></p> <p>当然，这些都建立在使用邻接矩阵来存储的条件下</p> <p>邻接表是不同的</p> <img src="https://b.1wind.cn/2025/07/28e87e5091822516d32d085058fb1ce5.png" alt="image-20250719144210068" style="zoom:50%;"> <p>因为邻接表对应的链表存储的顺序可能不同，拿2来说，它对应的可以是1,6，也可以是6,1</p> <p>所以我们得到一个结论</p> <p>同一个图的邻接矩阵表示方式唯一，因此广度优先遍历序列唯一</p> <p>同一个图的邻接表表示方式不唯一，因此广度优先遍历序列不唯一</p> <img src="https://b.1wind.cn/2025/07/83aa7d9d498a8944d999012e3b2cb0d3.png" alt="image-20250719144639325" style="zoom:50%;"> <p>如果是非连通图，此时我们没法去遍历另外的结点了，因为它们并不连通</p> <p>解决该问题的方法是，去检查visited数组中是否还存在未遍历的数组值，对未遍历的值进行BFS，直到不存在未遍历的数组值即可</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">BFSTraverse</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Graph </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">G</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 对图G进行广度优先遍历</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">G</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">vexnum</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]=FALSE</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问标记数组初始化</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InitQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化辅助队列Q</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">G</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">vexnum</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从0顶点开始遍历</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">])</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 对每个连通变量都调用一次BFS</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">BFS</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 未访问过，则进行BFS</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="void BFSTraverse(Graph G){ // 对图G进行广度优先遍历 for(i=0;i<G.vexnum;++i) visited[i]=FALSE // 访问标记数组初始化 InitQueue(Q); // 初始化辅助队列Q for(i=0;i<G.vexnum;++i) // 从0顶点开始遍历 if(!visited[i]) // 对每个连通变量都调用一次BFS BFS(G,i); // 未访问过，则进行BFS}"><div></div></button></div></figure></div> <p>结论：对于无向图，调用BFS函数的次数=连通分量数</p> <h3 id="广度优先生成树">广度优先生成树</h3> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/07/84e6c9ff9f70597b12a0c8cb512a9b6e.png" alt="image-20250719150644904"></p> <h3 id="广度优先生成森林">广度优先生成森林</h3> <p>对非连通图的广度优先遍历，可得到广度优先生成森林</p> <p>其实就是将其分别遍历得到了不同的树，组成一个森林</p> <h2 id="深度优先遍历">深度优先遍历</h2> <p>图的深度优先遍历类似树的深度优先遍历</p> <p>具体代码如下</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">MAX_VERTEX_NUM</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问标记数组</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">DFS</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Graph </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">v</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从顶点v出发，深度优先遍历图G</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">visit</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 访问顶点v</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">]=TRUE;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 设置为已访问</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">FirstNeighbor</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">NextNeighor</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">))</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">]){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // w为尚未访问的邻接顶点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">DFS</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="bool visited[MAX_VERTEX_NUM]; // 访问标记数组void DFS(Graph G,int v){ // 从顶点v出发，深度优先遍历图G visit(v); // 访问顶点v visited[v]=TRUE; // 设置为已访问 for(w=FirstNeighbor(G,v);w>=0;w=NextNeighor(G,v,w)) if(!visited[w]){ // w为尚未访问的邻接顶点 DFS(G,w); }}"><div></div></button></div></figure></div> <p>在深度优先遍历算法中，也存在着与广度优先生成算法同样的问题，即非连通图无法遍历完所有结点，处理办法是一样的</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">DFSTraverse</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Graph </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">G</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">G</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">vexnum</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">]=FALSE;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> //初始化已访问标记数据</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">G</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">vexnum</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">])</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">DFS</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="void DFSTraverse(Graph G){ for(v=0;v<G.vexnum;++v) visited[v]=FALSE; //初始化已访问标记数据 for(v=0;v<G.vexnum;++v) if(!visited[v]) DFS(G,v);}"><div></div></button></div></figure></div> <p>同一个图的邻接矩阵表示方式唯一，因此深度优先遍历序列唯一</p> <p>同一个图邻接表表示方式不唯一，因此深度优先遍历序列不唯一</p> <p>深度优先生成树和深度优先生成森林是类似的，这里不再赘述了</p> <h2 id="最小生成树">最小生成树</h2> <h3 id="概念-1">概念</h3> <p>最小生成树也称最小代价树</p> <p>对于一个带权连通无向图G=(V,E)，生成树不同，每棵树的权（即树中所有边上的权值之和）也可能不同。设R为G的所有生成树的集合，若T为R中边的权值之和最小的生成树，则T称为G的最小生成树（Minimum-Spanning-Tree,MST）</p> <ul> <li>最小生成树可能有多个，但边的权值之和总是唯一且最小的</li> <li>最小生成树的边数=顶点数 - 1。砍掉一条则不连通，增加一条则会出现回路</li> <li>如果一个连通图本身就是一棵树，则其最小生成树就是它本身</li> <li>只有连通图才有生成树，非连通图只有生成森林</li> </ul> <h3 id="prim普里姆">Prim(普里姆)</h3> <p>从某一个顶点开始构建生成树；</p> <p>每次将代价最小的新顶点纳入生成树，直到所有顶点都纳入为止</p> <img src="https://b.1wind.cn/2025/07/86142fd4b56d5479293b39ff1135f012.png" alt="image-20250720134426597" style="zoom:50%;"> <h3 id="kruskal克鲁斯卡尔">Kruskal(克鲁斯卡尔)</h3> <p>每次选择一条权值最小的边，使这条边的两头连通（原本已经连通的就不选）</p> <p>直到所有结点都连通</p> <h2 id="最短路径问题">最短路径问题</h2> <h3 id="bfs">BFS</h3> <p>BFS求无权图的单源最短路径</p> <p>注：无权图可以视为一种特殊的带权图，只是每条边的权值都为1</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 求顶点u到其他顶点的最短路径</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">BFS_MIN_Distance</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Graph </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">u</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// d[i]表示从u到i结点的最短路径</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">G</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">vexnum</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">d</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#BE2F2C;--1:#F07178">∞</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化路径长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">path</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]=-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 最短路径从哪个顶点过来</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">d</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">u</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">u</span><span style="--0:#256F74;--1:#89DDFF">]=TRUE;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">EnQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">u</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#4C6690;--1:#82AAFF">isEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">)){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // BFS算法主过程</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">DeQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">u</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 队头元素u出队</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">FirstNeighbor</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">u</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">NextNeighbor</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">G</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">u</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">)){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">]){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // w为u的尚未访问的邻接顶点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">d</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">d</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">u</span><span style="--0:#256F74;--1:#89DDFF">]+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 路径长度加1</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">path</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#BE2F2C;--1:#F07178">u</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 最短路径应从u到w</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">visited</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">]=TRUE;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 设置已访问标记</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">EnQueue</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">Q</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">w</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 顶点w入队</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//if</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//for</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">//while</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 求顶点u到其他顶点的最短路径void BFS_MIN_Distance(Graph G,int u){ // d[i]表示从u到i结点的最短路径 for(i=0;i<G.vexnum;++i){ d[i]=∞; // 初始化路径长度 path[i]=-1; // 最短路径从哪个顶点过来 } d[u]=0; visited[u]=TRUE; EnQueue(Q,u); while(!isEmpty(Q)){ // BFS算法主过程 DeQueue(Q,u); // 队头元素u出队 for(w=FirstNeighbor(G,u);w>=0;w=NextNeighbor(G,u,w)){ if(!visited[w]){ // w为u的尚未访问的邻接顶点 d[w]=d[u]+1; // 路径长度加1 path[w]=u; // 最短路径应从u到w visited[w]=TRUE; // 设置已访问标记 EnQueue(Q,w); // 顶点w入队 }//if }//for }//while}"><div></div></button></div></figure></div> <p>数组d是用来记录路径长度的，path是记录前驱结点</p> <table><thead><tr><th></th><th>1</th><th>2</th><th>3</th><th>4</th><th>5</th><th>6</th><th>7</th><th>8</th></tr></thead><tbody><tr><td>d[]</td><td>∞</td><td>∞</td><td>∞</td><td>∞</td><td>∞</td><td>∞</td><td>∞</td><td>∞</td></tr><tr><td>path[]</td><td>-1</td><td>-1</td><td>-1</td><td>-1</td><td>-1</td><td>-1</td><td>-1</td><td>-1</td></tr></tbody></table> <p>当访问到某个结点后，d就会根据前一个结点在根结点的距离上+1</p> <p>而path会记录前一个结点</p> <h3 id="dijkstra">Dijkstra</h3> <p>BFS不适用于带权图</p> <p>回顾一些概念</p> <p>带权路径长度---当图是带权图时，一条路径上所有边的权值之和，称为该路径的带权路径长度</p> <p>不好说明这里的代码，理解起来跟BFS差不多，丢视频链接了：<a href="https://www.bilibili.com/video/BV1b7411N798/?p=67&#x26;spm_id_from=333.1007.top_right_bar_window_history.content.click&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974">https://www.bilibili.com/video/BV1b7411N798/?p=67&#x26;spm_id_from=333.1007.top_right_bar_window_history.content.click&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974</a></p> <p>如果存在负权值，该方法可能会失效</p> <h3 id="floyd">Floyd</h3> <p>Floyd算法：求出每一对顶点之间的最短路径</p> <p>使用动态规划思想，将问题的求解分为多个阶段对于n个顶点的图G，求任意一对顶点Vi一>Vj 之间的最短路径可分为如下几个阶段：</p> <p>#初始：不允许在其他顶点中转，最短路径是？</p> <p>#0：若允许在Vo中转，最短路径是?</p> <p>#1：若允许在Vo、V1 中转，最短路径是？</p> <p>#2：若允许在Vo、V1、V2中转，最短路径是？</p> <p>#n-1：若允许在Vo、V、V2…Vn-1 中转，最短路径是?</p> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/07/3f03c11ba4837df7ec05e7a6bb45417c.png" alt="image-20250720195535350"></p> <p>图中有两个二维数组</p> <p>A是对应顶点与其他顶点之间的路径长度，path是中转点，其实就是前面一个结点</p> <p>代码不难，但是for循环太多了，这里不写了</p> <p>简单说明一下，其实就是针对A数组进行遍历，看看是否存在无中转点和有中转点的权值比较有更好的情况，如果有中转点权值更小，就采用后者，并更新path数组的中转点以及A数组的路径长度</p> <p>如果存在多结点，也就是说，不像图中这样只有3个结点，而是七八个</p> <p>如果v0到v3没有直接路径，需要中转，那么假设从v0先到v1，此时path和A都会更新至v1的情况，从v1继续过去，如果v1无法直接到v3，需要通过v2才能到v3，那么我们还是会像之前一样遍历，但是信息存储的是v1到v2的情况，最后从v2到v3算出最短路径</p> <img src="https://b.1wind.cn/2025/07/d40b362a225352db52abefd45002c810.png" alt="image-20250720203930225" style="zoom:50%;"> <p>Floyd算法不能解决带有“负权回路”的图（有负权值的边组成的回路）。这种图有可能没有最短路径</p> <h3 id="总结-2">总结</h3> <img src="https://b.1wind.cn/2025/07/f1641e99eb68287ce3bb83ce9b1232f5.png" alt="image-20250720205754830" style="zoom:50%;"> <h2 id="有向无环图描述表达式">有向无环图描述表达式</h2> <p>有向无环图：若一个有向图中不存在环，则称为有向无环图，简称DAG图(Directed Acyclic Graph)</p> <img src="https://b.1wind.cn/2025/07/05e0e156772780b8c70c096710c4ab8e.png" alt="image-20250720210333153" style="zoom:50%;"> <p>左边这个图无法回到之前的位置,没有环路,就是有向无环图</p> <p>右边这个图可以回到之前的位置,存在环路,不是有向无环图</p> <h2 id="拓扑排序">拓扑排序</h2> <p>AOV网(Activity On Vertex NetWork，用顶点表示活动的网)：</p> <p>用DAG图(有向无环图)表示一个工程。顶点表示活动，有向边&#x3C;Vi,Vj>表示活动Vi必须先于活动Vj进行</p> <p>拓扑排序：在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序：</p> <ol> <li>每个顶点出现且只出现一次</li> <li>若顶点A在序列中排在顶点B的前面，则在图中不存在从顶点B到顶点A的路径</li> </ol> <p>或定义为：拓扑排序是对有向无环图的顶点的一种排序，它使得若存在一条从顶点A到顶点B的路径，则在排序中顶点B出现在顶点A的后面。每个AOV网都有一个或多个拓扑排序序列。</p> <p>拓扑排序：找到做事的先后顺序</p> <p>拓扑排序的实现：</p> <ol> <li>从AOV网中选择一个没有前驱(入度为0)的顶点并输出</li> <li>从网中删除该顶点和所有以它为起点的有向边</li> <li>重复①和②直到当前AOV网为空或当前网中不存在无前驱的顶点为止</li> </ol> <p>当前所有顶点入度>0，说明原图存在回路</p> <p>代码如下</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 结构</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">#define</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MaxVertexNum</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#A64930;--1:#F78C6C">100</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 图中顶点数目的最大值</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> ArcNode</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> adjvex</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 该弧指向的顶点的位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> ArcNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF"> nextarc</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 指向下一条弧的指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// InfoType info; // 网的边权值</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">}ArcNode</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> VNode</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 顶点表结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">VertexType data</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 顶点信息</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ArcNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">firstarc</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 指向第一条依附该顶点的弧的指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">VNode</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">AdjList</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">MaxVertexNum</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">AdjList vertices</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 邻接表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> vexnum</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">arcnum</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 图的顶点数和弧度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">Graph</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // Graph是以邻接表存储的图类型</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 结构#define MaxVertexNum 100 // 图中顶点数目的最大值typedef struct ArcNode{ int adjvex; // 该弧指向的顶点的位置 struct ArcNode * nextarc; // 指向下一条弧的指针 // InfoType info; // 网的边权值}ArcNode;typedef struct VNode{ // 顶点表结点 VertexType data; // 顶点信息 ArcNode *firstarc; // 指向第一条依附该顶点的弧的指针}VNode,AdjList[MaxVertexNum];typedef struct{ AdjList vertices; // 邻接表 int vexnum,arcnum; // 图的顶点数和弧度}Graph; // Graph是以邻接表存储的图类型"><div></div></button></div></figure></div> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 算法</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">TopologicalSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">Graph </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">G</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">InitStack</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化栈，存储入度为0的顶点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">G</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">vexnum</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">indegree</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]==</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">Push</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将所有入度为0的顶点进栈</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> count </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 计数，记录当前已经输出的顶点数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#4C6690;--1:#82AAFF">IsEmpty</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">)){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 栈不空，则存在入度为0的顶点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">Pop</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 栈顶元素出栈</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">print</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">count</span><span style="--0:#256F74;--1:#89DDFF">++]=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 输出顶点i</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">G</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">vertices</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">firstarc</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">nextarc</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 将所有i指向的顶点的入度减1，并且将入度减为0的顶点压入栈S</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">adjvex</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(!(--</span><span style="--0:#5A676D;--1:#EEFFFF">indegree</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">]))</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 如果不存在入度，则会入栈排序</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">Push</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">S</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">v</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 入度为0，则入栈</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">count</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">G</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">vexnum</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // vexnum是顶点个数,count是排序个数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 如果排序个数小于顶点个数，说明存在回路</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 排序失败，有向图存在回路</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 算法bool TopologicalSort(Graph G){ InitStack(S); // 初始化栈，存储入度为0的顶点 for(int i=0;i<G.vexnum;i++) if(indegree[i]==0) Push(S,i); // 将所有入度为0的顶点进栈 int count = 0; // 计数，记录当前已经输出的顶点数 while(!IsEmpty(S)){ // 栈不空，则存在入度为0的顶点 Pop(S,i); // 栈顶元素出栈 print[count++]=i; // 输出顶点i for(p=G.vertices.firstarc;p;p=p->p->nextarc){ // 将所有i指向的顶点的入度减1，并且将入度减为0的顶点压入栈S v=p->adjvex; if(!(--indegree[v])) // 如果不存在入度，则会入栈排序 Push(S,v); // 入度为0，则入栈 } } if(count->G.vexnum) // vexnum是顶点个数,count是排序个数 // 如果排序个数小于顶点个数，说明存在回路 return false; // 排序失败，有向图存在回路 else return true;}"><div></div></button></div></figure></div> <p>indegree存储对应顶点的入度，print数组存储拓扑序列排序的每个位置，最后会输出print数组</p> <p><strong>逆拓扑排序</strong></p> <p>对一个AOV网逆拓扑排序：</p> <ol> <li>从AOV网中选择一个没有后继(出度为0)的顶点并输出</li> <li>从网中删除该顶点和所有以它为终点的有向边</li> <li>重复①和②直到当前AOV网为空</li> </ol> <h2 id="关键路径">关键路径</h2> <p>在带权有向图中，以顶点表示事件，以有向边表示活动，以边上的权值表示完成该活动的开销（如完成活动所需的时间），称之为用边表示活动的网络，简称AOE网(Activity On Edge NetWork)</p> <p>AOE网具有以下两个性质：</p> <ol> <li>只有在某顶点所代表的事件发生后，从该顶点出发的各有向边所代表的活动才能开始</li> <li>只有在进入某顶点的各有向边所代表的活动都已结束时，该顶点所代表的事件才能发生</li> </ol> <p>另外，有些活动是可以并行进行的</p> <p>在AOE网中仅有一个入度为0的顶点，称为<strong>开始顶点(源点)</strong>，它表示整个工程的开始；</p> <p>也仅有一个出度为0的顶点，称为<strong>结束顶点(汇点)</strong>，它表示整个工程的结束</p> <p>从源点到汇点的有向路径可能有多条，所有路径中，具有最大路径长度的路径称为关键路径，而把关键路径上的活动称为关键活动</p> <p>活动ai的最早开始时间e(i)---指该活动弧的起点所表示的事件的最早发生时间</p> <p>活动ai的最迟开始时间l(i)---它是指该活动弧的终点所表示事件的最迟发生时间与该活动所需时间之差</p> <p>活动ai的时间余量d(i)=l(i)-e(i),表示在不增加完成整个工程所需总时间的情况下，活动ai可以拖延的时间</p> <p>若一个活动的时间余量为零，则说明该活动必须要如期完成，d(i)=0即l(i)=e(i)的活动ai是关键活动</p> <p>由关键活动组成的路径是关键路径</p> <ol> <li>求所有事件的最早发生时间 <ul> <li>按拓扑排序序列，依次求各个顶点的ve(k);</li> <li>ve(源点)=0</li> <li>ve(k)=Max{ve(j)+Weight(vj,vk)}，vj为vk的任意前驱</li> </ul> </li> <li>求所有事件的最迟发生时间vl <ul> <li>按逆拓扑排序序列，依次求各个顶点的vl(k)</li> <li>vl(汇点)=ve(汇点)</li> <li>vl(k)=Min{vl(j)-Weight(vk,vj)}，vj为vk的任意后继</li> </ul> </li> <li>求所有活动的最早发生时间e() <ul> <li>若边&#x3C;vk,vj>表示活动ai，则有e(i)=ve(k)</li> </ul> </li> <li>求所有活动的最迟发生时间 <ul> <li>若边&#x3C;vk,vj>表示活动ai，则有l(i)=vl(j)-Weight(vk,vj)</li> </ul> </li> </ol> <h1 id="查找-2">查找</h1> <h2 id="概念-2">概念</h2> <p>查找---在数据集合中寻找满足某种条件的数据元素的过程称为查找</p> <p>查找表(查找结构)---用于查找的数据集合称为查找表，它由同一类型的数据元素(或记录)组成</p> <p>关键字---数据元素中唯一标识该元素的某个某个数据项的值，使用基于关键字的查找，查找结果应该是唯一的</p> <ul> <li>仅关注查找速度：静态查找表</li> <li>除了查找速度，也要关注插/删操作是否方便实现</li> </ul> <p>查找长度---在查找运算中，需要对比关键字的次数称为查找长度</p> <p>平均查找长度---所有查找过程中进行关键字的比较次数的平均值</p> <h2 id="顺序查找">顺序查找</h2> <p>顺序查找，又叫线性查找，通常用于线性表</p> <p>其实很简单，就是挨个找</p> <p>直接上代码吧，其实并不复杂</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 查找表的数据结构(顺序表)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">elem</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 动态数组基址</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> TableLen</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 表的长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">SSTable</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 顺序查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Search_Seq</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SSTable </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">ST</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">key</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">ST</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">TableLen</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">ST</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">elem</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> key</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> i </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">ST</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">TableLen</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">?</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">:</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct{ // 查找表的数据结构(顺序表) ElemType *elem; // 动态数组基址 int TableLen; // 表的长度}SSTable;// 顺序查找int Search_Seq(SSTable ST,ElemType key){ int i; for(i = 0;i<ST.TableLen &#x26;&#x26; ST.elem[i] != key;++i); return i == ST.TableLen ? -1 : i;}"><div></div></button></div></figure></div> <p><strong>顺序查找---哨兵</strong></p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 顺序查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Search_Seq</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SSTable </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">ST</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">key</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">ST</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">elem</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#BE2F2C;--1:#F07178">key</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">ST</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">TableLen</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--1:#EEFFFF">ST</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">elem</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]!=</span><span style="--0:#BE2F2C;--1:#F07178">key</span><span style="--0:#256F74;--1:#89DDFF">;--</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从后往前找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 查找成功,则返回元素下标；查找失败，则返回0</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 顺序查找int Search_Seq(SSTable ST,ElemType key){ ST.elem[0]=key; int i; for(i=ST.TableLen;ST.elem[i]!=key;--i); // 从后往前找 return i; // 查找成功,则返回元素下标；查找失败，则返回0}"><div></div></button></div></figure></div> <p>还有另一种方式，通过二叉树，将小值放在右边，大值放在左边，也可以方便的查找，但是这个有前提，需要有序</p> <h2 id="折半查找">折半查找</h2> <p>折半查找，又称“二分查找”，仅适用于有序的顺序表</p> <p>其实就是找该顺序表的中间，然后比较与要查找的数字的大小，大了说明在右边，小了说明在左边</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 查找表的数据结构(顺序表)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">elem</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 动态数组的基址</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> TableLen</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 表的长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 折半查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Binary_Search</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">SSTable </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">L</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">ElemType </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">key</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> low</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">TableLen</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">low </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178"> high</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">)/</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 取中间位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">elem</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">]==</span><span style="--0:#BE2F2C;--1:#F07178">key</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> mid</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 查找成功则返回所在位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">L</span><span style="--0:#256F74;--1:#89DDFF">.</span><span style="--0:#5A676D;--1:#EEFFFF">elem</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">]></span><span style="--0:#BE2F2C;--1:#F07178">key</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从前半部分继续查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从后半部分继续查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="typedef struct{ // 查找表的数据结构(顺序表) ElemType *elem; // 动态数组的基址 int TableLen; // 表的长度}// 折半查找int Binary_Search(SSTable L,ElemType key){ int low=0,high=L.TableLen-1,mid; while(low <= high){ mid=(low+high)/2; // 取中间位置 if(L.elem[mid]==key) return mid; // 查找成功则返回所在位置 else if(L.elem[mid]>key) high=mid-1; // 从前半部分继续查找 else low=mid+1; // 从后半部分继续查找 } return -1;}"><div></div></button></div></figure></div> <p>当然，这里的查找算法并不通用，需要根据情况来编写，比如升序、降序的情况</p> <p>如果当前low和high之间有奇数个元素，则mid分隔后，左右两部分元素个数相等</p> <p>如果当前low和high之间有偶数个元素，则mid分隔后，左半部分比右半部分少一个元素</p> <h2 id="分块查找">分块查找</h2> <p>分块查找会将一个一个表内的元素，分成一块一块的内容，索引表中会保存每个分块的最大关键字和分块的存储区间</p> <p>特点：块内无序、块间有序</p> <p><img src="https://b.1wind.cn/2025/08/386d909a6e032a967ebf7d4d14d0daa1.png" alt="image-20250801112719516"></p> <p>如上图所示</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 索引表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#A64930;--1:#F78C6C">typedef</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">ElemType maxValue</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#5A676D;--1:#EEFFFF">Index</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 顺序表存储实际元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">ElemType List</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">100</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 索引表typedef struct{ ElemType maxValue; int low,high;}Index;// 顺序表存储实际元素ElemType List[100];"><div></div></button></div></figure></div> <p>先从索引表找到对应的分块区域，再从区域里查找</p> <p>分块查找，又称索引顺序查找，算法过程如下：</p> <ol> <li>在索引表确定待查记录所属的分块（可顺序、可折半）</li> <li>在块内顺序查找</li> </ol> <p>若索引表中不包含目标关键字，这折半查找索引表最终停在low>high，要在low所指分块中查找</p> <p>原因：最终low左边一定小于目标关键字，high右边一定大于目标关键字。而分块存储的索引表中保存的是各个分块的最大关键字</p> <h1 id="二叉排序树bst">二叉排序树(BST)</h1> <p>二叉排序树，又称二叉查找树(BST,Binary Search Tree)</p> <p>一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树：</p> <ul> <li>左子树上所有结点的关键字均小于根结点的关键字</li> <li>右子树上所有结点的关键字均大于根结点的关键字</li> <li>左子树和右子树各自是一棵二叉排序树</li> </ul> <h2 id="查找-3">查找</h2> <p>若树为空，目标值与根结点的值比较：</p> <ul> <li>若相等，则查找成功；</li> <li>若小于根结点，则在左子树上查找，否则在右子树上查找</li> </ul> <p>查找成功，返回结点指针；查找失败返回NULL</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在二叉排序树中查找值为key的结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">BSTNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#4C6690;--1:#82AAFF">BST_Search</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">BSTree </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">key</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">!=NULL</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> key</span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 若树空或等于根结点值，则结束</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">key </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> T</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 小于，则在左子树上查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> T</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 大于，则在右子树上查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> T</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在二叉排序树中查找值为key的结点(递归实现)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span style="--0:#5A676D;--1:#EEFFFF">BSTNode </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#4C6690;--1:#82AAFF">BSTSearch</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">BSTree </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">key</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">==NULL)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 查找失败</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">key</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> T</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 查找成功</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">key </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">BSTSearch</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">key</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 左子树查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">BSTSearch</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">key</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 右子树查找</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 在二叉排序树中查找值为key的结点BSTNode *BST_Search(BSTree T,int key){ while(T!=NULL &#x26;&#x26; key!=T->key){ // 若树空或等于根结点值，则结束 if(key < T->key) T=T->lchild; // 小于，则在左子树上查找 else T=T->rchild; // 大于，则在右子树上查找 } return T;}// 在二叉排序树中查找值为key的结点(递归实现)BSTNode *BSTSearch(BSTree T,int key){ if (T==NULL) return NULL; // 查找失败 if (key==T->key) return T; // 查找成功 else if(key < T->key) return BSTSearch(T->lchild,key); // 左子树查找 else return BSTSearch(T->rchild,key); // 右子树查找}"><div></div></button></div></figure></div> <h2 id="插入-4">插入</h2> <p>若原二叉排序树为空，则直接插入结点；否则，若关键字k小于根结点，则插入到左子树，若关键字k大于结点只，则插入到右子树</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在二叉排序树插入关键字为k的新结点(递归实现)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">BST_Insert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">BSTree </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">k</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">==NULL){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 原树为空，新插入的结点为根结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#BE2F2C;--1:#F07178">BSTree</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">BSTNode</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 树中存在相同关键字结点,插入失败</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 插入到T的左子树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">BST_Insert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 插入到T的右子树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">BST_Insert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 在二叉排序树插入关键字为k的新结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">BST_Insert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">BSTree </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">key</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">BSTree p </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> T</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 拷贝结点，目的是不影响原结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">BSTree parent </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 父结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">p</span><span style="--0:#256F74;--1:#89DDFF">!=NULL){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 循环遍历，直到树的尽头</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">key</span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#5A676D;--1:#EEFFFF">p</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 结点相同插入失败</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">parent </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> p</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 记录父结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">key </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> T</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">26</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> T</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">T</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">27</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">28</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">BSTree new_node </span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#BE2F2C;--1:#F07178">BSTree</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(sizeof(</span><span style="--0:#BE2F2C;--1:#F07178">BSTNode</span><span style="--0:#256F74;--1:#89DDFF">));</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">29</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">new_node</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">30</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">new_node</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">new_node</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">31</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">parent </span><span style="--0:#256F74;--1:#89DDFF">==</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">NULL){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">32</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 如果parent为NULL，说明原树为NULL</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">33</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">T </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> new_node</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">34</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">35</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">key </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">parent</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">key</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">36</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 当前key小于父结点左子树的key</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">37</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">parent</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">lchild</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> new_node</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">38</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">39</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">parent</span><span style="--0:#256F74;--1:#89DDFF">-></span><span style="--0:#5A676D;--1:#EEFFFF">rchild</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> new_node</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">40</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">41</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 在二叉排序树插入关键字为k的新结点(递归实现)int BST_Insert(BSTree &#x26;T,int k){ if (T==NULL){ // 原树为空，新插入的结点为根结点 T=(BSTree)malloc(sizeof(BSTNode)); T->key=k; T->lchild=T->rchild=NULL; return 1; } else if(k==T->key) // 树中存在相同关键字结点,插入失败 return 0; else if(k<T->key) // 插入到T的左子树 return BST_Insert(T->lchild,k); else // 插入到T的右子树 return BST_Insert(T->rchild,k);}// 在二叉排序树插入关键字为k的新结点int BST_Insert(BSTree &#x26;T,int key){ BSTree p = T; // 拷贝结点，目的是不影响原结点 BSTree parent = NULL; // 父结点 while (p!=NULL){ // 循环遍历，直到树的尽头 if (key==p->key) // 结点相同插入失败 return 0; parent = p; // 记录父结点 if (key < T->key) T=T->lchild; else T=T->rchild; } BSTree new_node =(BSTree)malloc(sizeof(BSTNode)); new_node->key=k; new_node->lchild=new_node->rchild=NULL; if (parent == NULL){ // 如果parent为NULL，说明原树为NULL T = new_node; } else if (key < parent->key){ // 当前key小于父结点左子树的key parent->lchild = new_node }else parent->rchild = new_node; return 1;}"><div></div></button></div></figure></div> <h2 id="构造-1">构造</h2> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Creat_BST</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">BSTree </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">T</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">str</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">n</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">=NULL;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始时T为空树</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 依次将每个关键字插入到二叉排序树中</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">BST_Insert</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">T</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">str</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="void Creat_BST(BSTree &#x26;T,int str[],int n){ T=NULL; // 初始时T为空树 int i=0; while(i<n){ // 依次将每个关键字插入到二叉排序树中 BST_Insert(T,str[i]); i++; }}"><div></div></button></div></figure></div> <h2 id="删除-4">删除</h2> <p>先搜索找到目标结点：</p> <ol> <li>若被删除结点z是叶结点，则直接删除，不会破坏二叉排序树的性质</li> <li>若结点z只有一棵左子树或右子树，则让z的子树称为z父结点的子树，替代z的位置(因为z被删除了，子树前移)</li> <li>若结点z有左、右两棵子树，则令z的直接后继(或直接前驱)代替z，然后从二叉排序树中删去这个直接后继(或直接前驱)，这样就转换成了第一或第二种情况</li> </ol> <h1 id="平衡二叉树-1">平衡二叉树</h1> <p>平衡二叉树(Balanced Binary Tree)，简称平衡树(AVL树)---树上任一结点的左子树和右子树的高度之差不超过1</p> <p>结点的平衡因子=左子树高-右子树高</p> <p>只要有任一结点的平衡因子绝对值大于1，就不是平衡二叉树</p> <p>在二叉排序树上插入结点后，查找路径上的所有结点都可能受到影响，从插入点往回找到第一个不平衡结点，调整以该结点为根的子树</p> <p>每次调整的都是最小不平衡子树</p> <p>在插入操作中，只要将最小不平衡子树调整平衡，则其他祖先结点都会恢复平衡</p> <h2 id="调整最小不平衡子树">调整最小不平衡子树</h2> <h3 id="ll">LL</h3> <p>在A的左孩子的左子树中插入导致不平衡</p> <p>LL平衡旋转(右单旋转)。由于在结点A的左孩子(L)的左子树上插入了新结点，A的平衡因子由1增至2，导致以A为根的子树失去平衡，需要一次向右旋转的操作。将A的左孩子B向右上旋转代替A成为根结点，将A结点向右下旋转成B的左子树的根结点，而B的原右子树，则作为A结点的左子树</p> <p><img src="https://b.1wind.cn/2025/08/6b6fed7c069f13f580b16ae8c3834ebd.png" alt="image-20250801190832878"></p> <p>具体如图所示，其实就是将B作为了根结点，A变为了它的右子树，剩下的结点根据大小顺序来进行排列即可</p> <h3 id="rr">RR</h3> <p>在A的右孩子的右子树中插入导致不平衡</p> <p>和LL几乎一样，只是换了个方向</p> <p><img src="https://b.1wind.cn/2025/08/83603483e1e84a8e03f0eb2fd12bf5e2.png" alt="image-20250801191745572"></p> <h3 id="代码思路">代码思路</h3> <p>包含LL及RR</p> <p><img src="https://b.1wind.cn/2025/08/db9e70084725284ce0c63cb6c08a28fa.png" alt="image-20250802095559022"></p> <h3 id="lr">LR</h3> <p>在A的左孩子的右子树中插入导致不平衡</p> <p><img src="https://b.1wind.cn/2025/08/125f1a5e2bbe167af5a65a969f420588.png" alt="image-20250802100052549"></p> <p>如上图所示，我们向左孩子的右结点插入了相应的新结点，会破坏原父结点的平衡因子</p> <p>接着我们将BR看作C，那么CL是左孩子，CR是右孩子</p> <h3 id="rl">RL</h3> <p>在A的右孩子的左子树中插入导致不平衡</p> <p>LR和RL是类似的</p> <p><img src="https://b.1wind.cn/2025/08/0c9b62d2bfb2bd9e56d762f7c51602db.png" alt="image-20250802100529454"></p> <h3 id="插入删除">插入&#x26;删除</h3> <p>平衡二叉树的插入操作：</p> <ul> <li>插入新结点后，要保持二叉排序树的特性不变(左&#x3C;中&#x3C;右)</li> <li>若插入新结点导致不平衡，则需要调整平衡(LL、RR、LR、RL)</li> </ul> <p>平衡二叉树的删除操作也是如此</p> <p>具体步骤如下：</p> <ol> <li>删除结点(方法同“二叉排序树”) <ul> <li>若删除的结点是叶子，直接删</li> <li>若删除的结点只有一个子树，用子树顶替删除位置</li> <li>若删除的结点有两棵子树，用前驱(或后继)结点顶替，并转回为对前驱(后继)结点的删除</li> </ul> </li> <li>一路向北找到最小不平衡子树，找不到就完结撒花</li> <li>找最小不平衡子树下，“个头”最高的儿子、孙子</li> <li>根据孙子的位置，调整平衡 <ul> <li>孙子在LL：儿子右单旋</li> <li>孙子在RR：儿子左单旋</li> <li>孙子在LR：孙子先左旋，再右旋</li> <li>孙子在RL：孙子先右旋，再左旋</li> </ul> </li> <li>如果不平衡继续向上传导，继续② <ul> <li>对最小不平衡子树的旋转可能导致树变矮，从而导致上层祖先不平衡(不平衡向上传递)</li> </ul> </li> </ol> <h1 id="红黑树">红黑树</h1> <h2 id="概念-3">概念</h2> <p>平衡二叉树AVL：插入/删除 很容易破坏“平衡”特性，需要频繁调整树的形态。</p> <p>如插入操作导致不平衡，则需要先计算平衡因子，找到最小的不平衡子树，再进行LL/RR/LR/RL 调整</p> <p>红黑树RBT：插入/删除 很多时候不会破坏“红黑”特性，无需频繁调整树的形态。即便需要调整，一般都可以在常数级时间内完成</p> <p>平衡二叉树：适用于以查为主、很少插入/删除的场景</p> <p>红黑树：适用于频繁插入、删除的场景，实用性更强</p> <p>红黑树是二叉排序树：左子树结点值&#x3C;=根结点值&#x3C;=右子树结点值</p> <p>特点</p> <ol> <li>每个结点是红色的，或是黑色的</li> <li>根结点是黑色的</li> <li>叶结点(外部结点、NULL结点、失败结点)均是黑色的</li> <li>不存在两个相邻的红结点（即红结点的父节点和孩子结点均是黑色）</li> <li>对每个结点，从该节点到任一叶结点的简单路径上，所含黑结点的数目相同</li> </ol> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">struct</span><span style="--0:#5A676D;--1:#EEFFFF"> RBnode</span><span style="--0:#256F74;--1:#89DDFF">{</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 红黑树的结点定义</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> key</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 关键字值</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">RBnode</span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178"> parent</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 父节点指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">RBnode</span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178"> lChild</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 左孩子指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">RBnode</span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178"> rChild</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 右孩子指针</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> color</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 结点颜色，如：可用0/1 表示 黑/红，也可使用枚举型enum表示颜色</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="struct RBnode{ // 红黑树的结点定义 int key; // 关键字值 RBnode* parent; // 父节点指针 RBnode* lChild; // 左孩子指针 RBnode* rChild; // 右孩子指针 int color; // 结点颜色，如：可用0/1 表示 黑/红，也可使用枚举型enum表示颜色}"><div></div></button></div></figure></div> <p>结点的黑高（bh）---从某结点触发(不含该结点)到达任一空叶结点的路径上黑结点总数</p> <h2 id="插入-5">插入</h2> <ul> <li>先查找，确定插入位置(原理同二叉排序树)，插入新结点</li> <li>新结点是根---黑色</li> <li>新结点非根---红色 <ul> <li>若插入新结点后依然满足红黑树定义，则插入结束</li> <li>若插入新结点后不满足红黑树定义，需要调整，使其重新满足红黑树定义 <ul> <li>如何调整：看新结点叔叔的颜色</li> <li>黑叔：旋转+染色 <ul> <li>LL型：右单旋，父换爷+染色</li> <li>RR型：左单旋，父换爷+染色</li> <li>LR型：左、右双旋，儿换爷+染色</li> <li>RL型：右、左双旋，儿换爷+染色</li> </ul> </li> <li>红叔：染色+变新 <ul> <li>叔父爷染色，爷变新结点</li> </ul> </li> </ul> </li> </ul> </li> </ul> <h2 id="删除-5">删除</h2> <p>重要考点</p> <p><img src="https://b.1wind.cn/2025/08/06424ad396f86ecee13dc3b4f082fbff.png" alt="image-20250802205551303"></p> <h1 id="b树">B树</h1> <h2 id="概念-4">概念</h2> <p>策略：m叉查找树中，规定除了根节点外，任何结点至少有[m/2]个分叉，即至少含有[m/2]-1个关键字</p> <p>若每个结点内关键字太少，导致树变高，要查找更多层结点，效率低</p> <p>查找规则是：在一层数组内查找，如果没找到就根据key是大还是小，往下面的树继续查找，小是左子树，大是右子树，如此循环，并且，如果整个树只有1个元素，那么根节点只有两个分叉</p> <p>B树示例图如下</p> <p><img src="https://b.1wind.cn/2025/08/16b38cfe9e1bb81128dbb3358521eefc.png" alt="image-20250803105554588"></p> <p>B树，又称多路平衡查找树，B树中所有结点的孩子个数的最大值称为B树的阶，通常用m表示。一棵m阶B树或为空树，或为满足如下特性的m叉树：</p> <ol> <li>树中每个结点至多有m棵子树，即至多含义m-1个关键字</li> <li>若根结点不是终端结点，则至少有两棵子树</li> <li>除根结点外的所有非叶结点至少有[m/2]棵子树，即至少含义[m/2]-1个关键字</li> <li>所有叶结点都出现在同一层次上，并且不带信息（可以视为外部结点或类似于折半查找判定树的查找失败结点，实际上这些结点不存在，指向这些结点的指针为空）</li> </ol> <p>失败结点通常称为叶子结点，含义实际数据的被称为终端结点</p> <p>比如五叉查找树，相当于五阶B树，根据最大分叉来定</p> <p>问题：含n个关键字的m阶B树，最小高度、最大高度是多少？</p> <p>算B树的高度一般不包括叶子结点</p> <p>最小高度---让每个结点尽可能的满，有m-1个关键字，m个分叉</p> <p>最大高度就需要让各层分叉尽可能的少</p> <h2 id="插入删除-1">插入&#x26;删除</h2> <p>没超过上限就正常插入</p> <p>在插入key后，若导致原结点关键字数超过上限，则从中间位置[m/2]将其中的关键字分为两部分，左部分包含的关键字放在原结点中，右部分包含的关键字放在新结点中，中间位置[m/2]的结点插入原结点的父结点</p> <p>其实就是进行一个分裂操作</p> <p>若被删除关键字在非终端节点，则用直接前驱或直接后继来替代被删除的关键字</p> <p>直接前驱：当前关键字左侧指针所指子树中“最右下”的元素</p> <p>直接后继：当前关键字右侧指针所指子树中“最左下”的元素</p> <p>兄弟够借。若被删除关键字所在结点删除前的关键字个数低于下限，且与此结点右(或左)兄弟结点的关键字个数还很宽裕，则需要调整该结点、左(右)兄弟结点及其双亲结点(父子换位法)</p> <p>兄弟不够借。若被删除关键字所在结点删除前的关键字个数低于下限，且此时与该结点相邻的左、右兄弟结点的关键字个数均=[m/2]-1，则将关键字删除后与左(右)兄弟结点及双亲结点中的关键字进行合并</p> <p>在合并过程中，双亲结点中的关键字个数会减1。若其双亲结点是根结点且关键字个数减少至0（根结点关键字个数为1时，有2棵子树），则直接将根结点删除，合并后的新结点称为根；若双亲结点不是根结点，且关键字个数减少到[m/2]-2，则又要与它自己的兄弟结点进行调整或合并操作，并重复上述步骤，直至符合B树的要求为止</p> <h1 id="b树-1">B+树</h1> <p>如图所示</p> <p><img src="https://b.1wind.cn/2025/08/fffbbe1e3d13a3ab0b16bdb4ef507a1b.png" alt="image-20250803154235662"></p> <p>一棵m阶的B+树需要满足下列条件：</p> <ol> <li>每个分支结点最多有m棵子树(孩子结点)</li> <li>非叶根结点至少有两棵子树，其他每个分支结点至少有[m/2]棵子树</li> <li>结点的子树个数与关键字个数相同</li> <li>所有叶结点包含全部关键字及指向相应记录的指针，叶结点中将关键字按大小顺序排列，并且相邻叶结点按大小顺序相互链接起来</li> <li>所有分支结点中仅包含它的各个子结点中关键字的最大值及指向其子结点的指针</li> </ol> <p>我们一般将最下面的结点称为叶子结点</p> <p>非叶根结点：如果一个B+树，只有一个根结点，那么它是根结点也是叶子结点，如果它不止一个根结点，就说明它是非叶根结点</p> <p>B+树中，无论查找成功与否，最终一定都要走到最下面一层结点，因为上面的分支结点只是一个指针，并不能代表叶子结点所对应的记录</p> <p>m阶B树和B+树的区别</p> <p>B树</p> <ul> <li>结点中的n个关键字对应n+1棵子树</li> <li>根结点的关键字数n∈[1,m-1]</li> <li>其他结点的关键字数n∈[&#x3C;m/2是向上取整的>[m/2]-1,m-1]</li> <li>在B树中，各结点中包含的关键字是不重复的</li> <li>B树的结点中都包含了关键字对应的记录的存储地址</li> </ul> <p>B+树</p> <ul> <li>根结点的关键字数n∈[1,m]</li> <li>其他结点的关键字数n∈[&#x3C;m/2是向上取整的>[m/2],m]</li> <li>在B+树中，叶结点包含全部关键字，非叶结点中出现过的关键字也会出现在叶结点中</li> <li>叶结点包含信息，所有非叶结点仅起索引作用，非叶结点中的每个索引项只含有对应子树的最大关键字和指向该子树的指针，不含有该关键字对应记录的存储地址</li> <li>在B+树中，非叶结点不含有该关键字对应记录的存储地址。可以使一个磁盘块可以包含更多个关键字，使得B+树的阶更大，树高跟矮，读磁盘次数更少，查找更快</li> </ul> <h1 id="散列表">散列表</h1> <h2 id="概念-5">概念</h2> <p>散列表(哈希表，Hash Table)：是一种数据结构。特点是：可以根据数据元素的关键字计算出它在散列表中的存储地址</p> <p>散列函数(哈希函数)：Addr=H(key)建立了“关键字”->“存储地址”的映射关系</p> <p>冲突(碰撞)：在散列表中插入一个数据元素时，需要根据关键字的值确定其存储地址，若该地址已经存储了其他元素，则称这种情况为“冲突(碰撞)”</p> <p>同义词：若不同的关键字通过散列函数映射到同一个存储地址，则称它们为“同义词”</p> <p>如何减少冲突？</p> <ul> <li>构造更适合的散列函数，让各个关键字尽可能地映射到不同的存储位置，从而减少冲突</li> </ul> <p>如何处理冲突</p> <ul> <li>拉链法（又称链接法、链地址法）：把所有“同义词”存储在一个链表中</li> </ul> <img src="https://b.1wind.cn/2025/08/97ed9b0e6ba3b630c65dcb5e5aca5a83.png" alt="image-20250803182333044" style="zoom:50%;"> <ul> <li>开放定址法：如果发生冲突，就给新元素找另一个空闲位置</li> </ul> <img src="https://b.1wind.cn/2025/08/d935ac69491d5866a89fec5ef56b157f.png" alt="image-20250803182433964" style="zoom:50%;"> <h2 id="构造散列函数">构造散列函数</h2> <h3 id="注意点">注意点</h3> <p>设计散列函数时应该注意什么？</p> <ol> <li>定义域必须涵盖所有可能出现的关键字。</li> <li>值域不能超出散列表的地址范围</li> <li>尽可能减少冲突。散列函数计算出来的地址应尽可能均匀分布在整个地址空间</li> <li>散列函数应尽量简单，能够快速计算出任意一个关键字对应的散列地址</li> </ol> <p>对应反例如下</p> <img src="https://b.1wind.cn/2025/08/e49edc88252d5c880a97a1787133b011.png" alt="image-20250803203607801" style="zoom:50%;"> <h3 id="除留余数法">除留余数法</h3> <p>H(key) = key % p</p> <p>散列表表长为m，取一个不大于m但最接近或等于m的质数p</p> <p>注：质数又称素数。指除了1和此整数自身外，不能被其他自然数整除的数，和素数相对的是合数</p> <p>适用场景：较为通用，只要关键字是整数即可</p> <p>原因：对质数取余，可以分布更均匀，从而减少冲突</p> <ul> <li>对合数取余，散列地址分布不均匀，易发生冲突</li> <li>对质数取余，散列地址分布均匀，不易发生冲突</li> </ul> <h3 id="直接定址法">直接定址法</h3> <p>H(key) = key or H(key) = a*key + b</p> <p>其中，a和b是常数。这种方法计算最简单，且不会产生冲突。若关键字分布不连续，空位较多，则会造成存储空间的浪费</p> <p>适用场景：关键字分布基本连续</p> <h3 id="数字分析法">数字分析法</h3> <p>选取数码分布较为均匀的若干位作为散列地址</p> <p>设关键字是r进制数(如十进制数)，而r个数码在各位上出现的频率不一定相同，可能在某些位上分布均匀一些，每种数码出现的机会均等；而在某些位上分布不均匀，只有某几种数码经常出现，此时可选取数码分布较为均匀的若干位作为散列地址</p> <p>适用场景：关键字集合已知，且关键字的某几个数码位分布均匀</p> <h3 id="平方取中法">平方取中法</h3> <p>取关键字的平方值的中间几位作为散列地址</p> <p>具体取多少位要视实际情况而定。这种方法得到的散列地址与关键字的每位都有关系，因此使得散列地址分布比较均匀</p> <p>适用场景：关键字的每位取值都不够均匀</p> <h2 id="拉链法">拉链法</h2> <p>拉链法（又称链接法、链地址法）：把所有同义词存储在一个链表中</p> <p>如何在散列表（拉链法解决冲突）中插入一个新元素？</p> <ol> <li>结合散列函数计算新元素的散列地址</li> <li>将新元素插入散列地址对应的链表（可用头插法，也可用尾插法）</li> </ol> <p>查找长度---在查找运算中，需要对比关键字的次数称为查找长度</p> <h2 id="开放定址法">开放定址法</h2> <h3 id="概念-6">概念</h3> <p>开放定址法：如果发生冲突，就给新元素找另一个空闲位置</p> <p>为什么叫“开放定址”？---一个散列地址，既对同义词开放，也对非同义词开放</p> <p>思路：需确定一个“探测的顺序”，从初始散列地址出发，去寻找下一个空闲位置</p> <p>eg：d0=0，d1=1，d2=-1，d3=2，d4=-2，…</p> <p>注：di表示第i次发生冲突时，下一个探测地址与初始散列地址的相对偏移量</p> <p>那么我们如何找到下一个空闲位置</p> <p>Hi=(H(key) + di) % m</p> <ul> <li>Hi：发生第i次冲突时的散列地址</li> <li>H(key)：初始散列地址</li> <li>di：偏移量</li> <li>m：散列表表长</li> </ul> <p><strong>注意：采用“开放定址法”时，删除元素不能简单地将被删元素的空间置为空，否则将截断在它之后的探测路径，可以做一个“已删除”标记，进行逻辑删除</strong></p> <p>带来的问题：查找效率低下，散列表看起来很满，实则很空</p> <h3 id="线性探测法">线性探测法</h3> <p>di=0,1,2,3,…，m-1</p> <p>带入上述公式->Hi=(H(key) + di) % m</p> <p>依次向后推断，插入，直到不冲突</p> <p>而查找也是类似的，带入公式依次向后找</p> <h3 id="平方探测法">平方探测法</h3> <p>$$ d_i=0^2,1^2,-1^2,2^2,-2^2,…,k^2,-k^2 \ 其中k&#x3C;=m/2 \ m：散列表表长 $$</p> <p>查找依然是类似的</p> <p>带入公式即可</p> <h3 id="双散列法">双散列法</h3> <p>$$ d_i=i×hash_2(key) \ 第i次发生冲突 \ hash_2(key)：第二个散列函数，由题目假设 $$</p> <h3 id="伪随机序列法">伪随机序列法</h3> <p>di是一个伪随机序列，由题目可知di=0,5,3,11,…</p> <p>这里的随机序列是人为设计的</p> <h1 id="排序">排序</h1> <h2 id="概念-7">概念</h2> <p>排序，字面意思，将各元素按关键字递增/或递减顺序重新排列</p> <p>稳定性：关键字相同的元素经过排序后相对顺序是否会改变</p> <p>排序分为内部排序和外部排序</p> <ul> <li>内部排序：数据都在内存中</li> <li>外部排序：数据太多，无法全部放入内存</li> </ul> <h2 id="插入排序">插入排序</h2> <p>算法思想：每次将一个待排序的记录按其关键字大小插入到前面已排好序的子序列中，直到全部记录插入完成</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 直接插入排序</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InsertSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">n</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">temp</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将各元素插入已排好序的序列中</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 如果A[i]关键字小于前驱</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">temp</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 暂存A[i]</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]></span><span style="--0:#BE2F2C;--1:#F07178">temp</span><span style="--0:#256F74;--1:#89DDFF">;--</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 检查所有前面已排好序的元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 所有大于temp的元素都向后挪位</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#BE2F2C;--1:#F07178">temp</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 直接插入排序void InsertSort(int A[],int n){ int i,j,temp; for(i=1;i<n;i++){ // 将各元素插入已排好序的序列中 if(A[i] < A[i-1]){ // 如果A[i]关键字小于前驱 temp=A[i]; // 暂存A[i] for(j=i-1;j>=0 &#x26;&#x26; A[j]>temp;--j){ // 检查所有前面已排好序的元素 A[j+1]=A[j]; // 所有大于temp的元素都向后挪位 } A[j+1]=temp; } }}"><div></div></button></div></figure></div> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 直接插入排序(带哨兵)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">InsertSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">n</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 依次将A[2]~A[n]插入到前面已排序序列</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 若A[i]关键码小于前驱，将A[i]插入有序表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 复制为哨兵，A[0]不存放元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">]&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];--</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从后往前查找待插入位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 向后挪位</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 复制到插入位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 直接插入排序(带哨兵)void InsertSort(int A[],int n){ int i,j; for(i=2;i<=n;i++){ // 依次将A[2]~A[n]插入到前面已排序序列 if(A[i]<A[i-1]){ // 若A[i]关键码小于前驱，将A[i]插入有序表 A[0]=A[i]; // 复制为哨兵，A[0]不存放元素 for(j=i-1;A[0]<A[j];--j){ // 从后往前查找待插入位置 A[j+1]=A[j]; // 向后挪位 } A[j+1]=A[0]; // 复制到插入位置 } }}"><div></div></button></div></figure></div> <p>想优化这个算法比较简单</p> <p>因为前面的序列都是排好序的，所以可以通过折半查找进行更高效的查找</p> <p>当low>high时，应将[low,i-1]内的元素全部右移，接着将哨兵处A[0]复制到low所指位置</p> <p>其实就是后移，将内容迁入即可</p> <p>当A[mid]=A[0]时，为了保证算法的“稳定性”，应继续在mid所指位置右边寻找插入位置</p> <h2 id="希尔排序">希尔排序</h2> <p>希尔排序：先追求表中元素部分有序，再逐渐逼近全局有序</p> <p>先将待排序表分割成若干形如L[i,i+d,i+2d,…,i+kd]的“特殊子表”，对各个子表分别进行直接插入排序。缩小增量d，重复上述过程，直到d=1为止</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">ShellSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">n</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> d</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// A[0]只是暂存单元，不是哨兵，当j&#x3C;=0时，插入位置已到</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">/</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">/</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 步长变化</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">;++</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">]){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 需要将A[i]插入有序增量子表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">]&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">-=</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 记录后移，查找插入位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178">d</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 插入</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="void ShellSort(int A[],int n){ int d,i,j; // A[0]只是暂存单元，不是哨兵，当j<=0时，插入位置已到 for(d=n/2;d>=1;d=d/2){ // 步长变化 for(i=d+1;i<=n;++i){ if(A[i]<A[i-d]){ // 需要将A[i]插入有序增量子表 A[0]=A[i]; for(j=i-d;j>0 &#x26;&#x26; A[0]<A[j];j-=d){ A[j+d]=A[j]; // 记录后移，查找插入位置 } A[j+d]=A[0]; // 插入 } } }}"><div></div></button></div></figure></div> <h2 id="冒泡排序">冒泡排序</h2> <p>基于“交换”的排序：根据序列中两个元素关键字的比较结果来对换这两个记录在序列中的位置</p> <p>从后往前（或从前往后）两两比较相邻元素的值，若为逆序(即A[i-1]>A[i])，则交换它们，直到序列比较完。称这样过程为“一趟”冒泡排序</p> <p>若某一趟排序没有发生“交换”，说明此时已经整体有序</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 交换</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">swap</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">a</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">&#x26;</span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">b</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> temp </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> a</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">a </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> b</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">b </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> temp</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 冒泡排序</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">BubbleSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">n</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">bool</span><span style="--0:#BE2F2C;--1:#F07178"> flag </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">false;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">--){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]></span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">swap</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">],</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">flag</span><span style="--0:#256F74;--1:#89DDFF">=true;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(!</span><span style="--0:#BE2F2C;--1:#F07178">flag</span><span style="--0:#256F74;--1:#89DDFF">)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 交换void swap(int &#x26;a,int &#x26;b){ int temp = a; a = b; b = temp;}// 冒泡排序void BubbleSort(int A[],int n){ for(int i = 0;i<n-1;i++){ bool flag = false; for(int j=n-1;j>i;j--){ if(A[j-1]>A[j]){ swap(A[j-1],A[j]); flag=true; } } if(!flag) return; }}"><div></div></button></div></figure></div> <h2 id="快速排序">快速排序</h2> <p>算法思想：在待排序表L[1…n]中任取一个元素pivot作为枢轴（或基准，通常取首元素），通过一趟排序将待排序表划分为独立的两部分L[1…k-1]和L[k+1…n]，使得L[1…k-1]中所有元素小于pivot，L[k+1…n]中的所有元素大于等于pivot，则pivot放在了其最终位置L(k)上，这个过程称为一次“划分”。然后分别递归地对两个子表重复上述过程，直至每部分只有一个元素或空为止，即所有元素放在了其最终位置上</p> <p>简单来说，就是将比pivot小的元素放到pivot左边，而比pivot大的元素放到pivot的右边</p> <p>当然，这是有规律的，如果检测到比pivot小的元素，先放到对应的low指针位置，让low指针右移</p> <p>直到找到更大的元素，先放到对应的high指针位置，再转为high指针，让high左移，继续判断</p> <p>如果本身就是在high指针并且元素比pivot更大，就不用移动，如果是在low指针且比pivot更小，那么也不用移动</p> <p>相当于high和low互相切换，直到low=high</p> <p>此时pivot找到了最终的位置，接着就对左右子表继续进行操作即可</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 用第一个元素将待排序序列划分为左右两个部分</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Partition</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">high</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> pivot</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 第一个元素作为枢轴</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">low </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> high</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 用low、high搜索枢轴的最终位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">high </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#BE2F2C;--1:#F07178"> pivot</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">--</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 比枢轴小的元素移动到左端</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">hight </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178"> pivot</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">++</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 比枢轴大的元素移动到右端</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#BE2F2C;--1:#F07178">pivot</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 枢轴元素存放到最终位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">return</span><span style="--0:#BE2F2C;--1:#F07178"> low</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 返回枢轴最终位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 快速排序</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">QuickSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">high</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 递归跳出的条件</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> pivotpos</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#4C6690;--1:#82AAFF">Partition</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">A</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 划分</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">QuickSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">A</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">privotpos</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 左子表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">QuickSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">A</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">privotpos</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 右子表</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 用第一个元素将待排序序列划分为左右两个部分int Partition(int A[],int low,int high){ int pivot=A[low]; // 第一个元素作为枢轴 while(low < high){ // 用low、high搜索枢轴的最终位置 while(low<high &#x26;&#x26; A[high] >= pivot) --high; A[low]=A[high]; // 比枢轴小的元素移动到左端 while(low<hight &#x26;&#x26; A[low] <= pivot) ++low; A[high]=A[low]; // 比枢轴大的元素移动到右端 } A[low]=pivot; // 枢轴元素存放到最终位置 return low; // 返回枢轴最终位置}// 快速排序void QuickSort(int A[],int low,int high){ if(low<high){ // 递归跳出的条件 int pivotpos=Partition(A,low,high); // 划分 QuickSort(A,low,privotpos-1); // 左子表 QuickSort(A,privotpos+1,high); // 右子表 }}"><div></div></button></div></figure></div> <h2 id="简单选择排序">简单选择排序</h2> <p>每一趟在待排序元素中选取关键字最小的元素加入有序子序列</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 简单选择排序</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">SelectSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">n</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 一共进行n-1趟</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> min</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 记录最小元素位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">++)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 在A[i...n-1]中选择最小的元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">]&#x3C;</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">min</span><span style="--0:#256F74;--1:#89DDFF">])</span><span style="--0:#BE2F2C;--1:#F07178"> min </span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 更新最小元素位置</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">min </span><span style="--0:#256F74;--1:#89DDFF">!=</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#4C6690;--1:#82AAFF">swap</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">],</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">min</span><span style="--0:#256F74;--1:#89DDFF">]);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 移动元素</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 简单选择排序void SelectSort(int A[],int n){ for(int i=0;i<n-1;i++){ // 一共进行n-1趟 int min=i; // 记录最小元素位置 for(int j=i+1;j<n;j++) // 在A[i...n-1]中选择最小的元素 if(A[j]<A[min]) min = j; // 更新最小元素位置 if(min != i) swap(A[i],A[min]); // 移动元素 }}"><div></div></button></div></figure></div> <h2 id="堆排序">堆排序</h2> <h3 id="概念-8">概念</h3> <p>若n个关键字序列[1…n]满足下面某一条性质，则称为堆(Heap)：</p> <ol> <li>若满足：L(i)>=L(2i)且L(i)>=L(2i+1) (1&#x3C;=i&#x3C;=n/2) --- 大根堆(大顶堆)</li> <li>若满足：L(i)&#x3C;=L(2i)且L(i)&#x3C;=L(2i+1) (1&#x3C;=i&#x3C;=n/2) --- 小根堆(小顶堆)</li> </ol> <p>可能直接理解不是很明白，直接看图</p> <p><img src="https://b.1wind.cn/2025/08/3cf9b04491f38cd1e2adbaa9b0f2fdc0.png" alt="image-20250805092408807"></p> <p>逻辑层面上相当于是二叉树的形式，左子树是L(2i)，右子树是L(2i+1)</p> <p>大根堆：完全二叉树中，根>=左、右</p> <p>小根堆就是反过来了</p> <h3 id="建立大根堆">建立大根堆</h3> <p>思路：把所有非终端结点都检查一遍，是否满足大根堆的要求，如果不满足，则进行调整</p> <p>检查<strong>当前结点是否满足根>=左、右</strong></p> <p>若不满足，将<strong>当前结点与更大的一个孩子互换</strong></p> <ul> <li>i的左孩子 --- 2i</li> <li>i的右孩子 --- 2i+1</li> <li>i的父节点 --- i/2(向上取整)</li> </ul> <p>若元素互换破坏了下一级的堆，则采用相同的方式继续往下调整(小元素不断“下坠”)</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 建立大根堆</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">BuildMaxHeap</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">len</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">len</span><span style="--0:#256F74;--1:#89DDFF">/</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">--)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从后往前调整非终端结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">HeadAdjust</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">A</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">len</span><span style="--0:#256F74;--1:#89DDFF">);</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 将以k为根的子树调整为大根堆</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">HeadAdjust</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">k</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">len</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // A[0]暂存子树的根结点</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178">len</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">*=</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 沿key较大的子结点向下筛选,2*k是指向左孩子</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">len </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">])</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // i&#x3C;len保证当前结点是存在右兄弟的</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 取key较大的子结点下标</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">])</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">break</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span><span style="--0:#256F74;--1:#89DDFF">{</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将A[i]调整到双亲结点上</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"><span style="--0:#BE2F2C;--1:#F07178"> </span></span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 修改k值，以便向下筛选</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 堆排序的完整逻辑</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">HeapSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">len</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">BuildMaxHeap</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">A</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">len</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始建堆</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">len</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">></span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">--){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // n-1趟的交换和建堆过程</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">26</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">swap</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">],</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">]);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 堆顶元素和堆底元素互换</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">27</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">HeadAdjust</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">A</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 把剩余的待排序元素整理成堆</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">28</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">29</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// 建立大根堆void BuildMaxHeap(int A[],int len){ for(int i=len/2;i>0;i--) // 从后往前调整非终端结点 HeadAdjust(A,i,len);}// 将以k为根的子树调整为大根堆void HeadAdjust(int A[],int k,int len){ A[0]=A[k]; // A[0]暂存子树的根结点 for(int i=2*k;i<=len;i*=2){ // 沿key较大的子结点向下筛选,2*k是指向左孩子 if(i<len &#x26;&#x26; A[i] < A[i+1]) // i<len保证当前结点是存在右兄弟的 i++; // 取key较大的子结点下标 if(A[0] >= A[i]) break; else{ A[k]=A[i]; // 将A[i]调整到双亲结点上 k=i; // 修改k值，以便向下筛选 } } A[k]=A[0];}// 堆排序的完整逻辑void HeapSort(int A[],int len){ BuildMaxHeap(A,len); // 初始建堆 for(int i=len;i>1;i--){ // n-1趟的交换和建堆过程 swap(A[i],A[1]); // 堆顶元素和堆底元素互换 HeadAdjust(A,1,i-1); // 把剩余的待排序元素整理成堆 }}"><div></div></button></div></figure></div> <h3 id="插入删除-2">插入删除</h3> <p>对于<strong>小根堆</strong>，新元素放到表尾，与父节点对比，若新元素比父节点更小，则二者互换。新元素就这样一路上升，直到无法继续上升为止</p> <p>被删除的元素用堆底元素替代，然后让该元素不断“下坠”，直到无法下坠为止</p> <h2 id="归并排序">归并排序</h2> <p>归并：把两个或多个已经有序的序列合并成一个</p> <p>将i和j指向对应的数组所指元素位置初始位置->0，选择更小的一个放入k所指位置，并让其指针后移</p> <p>当指针超出后，说明一侧数组已经全部存放完毕，直接将另一侧数组的结果存入剩下的空间内</p> <p>k是由两个数组大小合并新建的一个数组的初始位置</p> <p>两个数组合并叫2路归并，四个数组合并叫4鲁归并</p> <p>4路归并 --- 每选出一个小元素注意需要对比关键字3次</p> <p>结论：m路归并，每选出一个元素需要对比关键字m-1次</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">*</span><span style="--0:#5A676D;--1:#EEFFFF">B</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#256F74;--1:#89DDFF">*)</span><span style="--0:#4C6690;--1:#82AAFF">malloc</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">n</span><span style="--0:#256F74;--1:#89DDFF">*sizeof(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#256F74;--1:#89DDFF">));</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 辅助数组B</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// A[low...mid]和A[mid+1...high]各自有序，将两个部分归并</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">Merge</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">mid</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">high</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">++)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">B</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将A中所有元素复制到B中</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178">mid </span><span style="--0:#256F74;--1:#89DDFF">&#x26;&#x26;</span><span style="--0:#BE2F2C;--1:#F07178"> j</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">++){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#5A676D;--1:#EEFFFF">B</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">B</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">])</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">B</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将极小值复制到A中</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">else</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">B</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">++];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">++]=</span><span style="--0:#5A676D;--1:#EEFFFF">B</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">while</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;=</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">)</span><span style="--0:#BE2F2C;--1:#F07178"> </span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">++]=</span><span style="--0:#5A676D;--1:#EEFFFF">B</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">j</span><span style="--0:#256F74;--1:#89DDFF">++];</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">MergeSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">high</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">if</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">low </span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178"> high</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">20</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> mid</span><span style="--0:#256F74;--1:#89DDFF">=(</span><span style="--0:#BE2F2C;--1:#F07178">low </span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#BE2F2C;--1:#F07178"> high</span><span style="--0:#256F74;--1:#89DDFF">)/</span><span style="--0:#A64930;--1:#F78C6C">2</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 从中间划分</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">21</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">MergeSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">A</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 左半部分归并排序</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">22</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">MergeSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">A</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">+</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 右半部分归并排序</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">23</div></div><div class="code"><span class="indent"> </span><span style="--0:#4C6690;--1:#82AAFF">Merge</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">A</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">low</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">mid</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#BE2F2C;--1:#F07178">high</span><span style="--0:#256F74;--1:#89DDFF">);</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 归并</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">24</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">25</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="int *B=(int *)malloc(n*sizeof(int)); // 辅助数组B// A[low...mid]和A[mid+1...high]各自有序，将两个部分归并void Merge(int A[],int low,int mid,int high){ int i,j,k; for(k=low;k<=high;k++) B[k]=A[k]; // 将A中所有元素复制到B中 for(i=low,j=mid+1,k=i;i<=mid &#x26;&#x26; j<=high;k++){ if(B[i] <= B[j]) A[k]=B[i++]; // 将极小值复制到A中 else A[k]=B[j++]; } while(i<=mid) A[k++]=B[i++]; while(j<=high) A[k++]=B[j++];}void MergeSort(int A[],int low,int high){ if(low < high){ int mid=(low + high)/2; // 从中间划分 MergeSort(A,low,mid); // 左半部分归并排序 MergeSort(A,mid+1,high); // 右半部分归并排序 Merge(A,low,mid,high); // 归并 }}"><div></div></button></div></figure></div> <p>归并排序会递归的将内部的相邻子元素一一排序，使其成为有序序列，最后对有序序列排序</p> <h2 id="基数排序">基数排序</h2> <p>基数排序其实很简单</p> <p>先构造一个辅助数组，存储0~9的数字</p> <p>然后根据个、十、百位来依次进行比对，最终得到结果 $$ 基数排序得到递减序列的过程如下 \ 初始化：设置r个空队列，Q_{r-1}，Q_{r-2}，…，Q_0 按照各个关键字位 权重递增的次序(个、十、百)\ 对d个关键字位分别做“分配”和“收集”\ 分配：顺序扫描各个元素，若当前处理的关键字位=x，则将元素插入Q_x队尾\ 收集：把Q_{r-1}、Q_{r-2}，…，Q_0各个队列中的结点依次出队并链接 $$ 基数排序说起来比较抽象和麻烦，建议直接看视频简单点：<a href="https://www.bilibili.com/video/BV1b7411N798?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=99(%E5%9F%BA%E6%95%B0%E6%8E%92%E5%BA%8F)">https://www.bilibili.com/video/BV1b7411N798?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=99(基数排序)</a></p> <h2 id="计数排序">计数排序</h2> <h3 id="实现">实现</h3> <p><img src="https://b.1wind.cn/2025/08/16e2a9cedfeaf1d94938eb8549b012a9.png" alt="image-20250805164630223"></p> <p>上图说明了计数排序元素根据辅助数组计算元素出现次数及通过C[i]比对前置元素计算对应情况的累积元素</p> <p>而基于上述数据进行的排序其实非常巧妙</p> <p>我们会再声明一个B数组，用于存储最终的结果，B数组大小和A数组一样，可以看做是空的A数组</p> <p>基于A数组从后往前进行排序，保证计数排序算法的稳定性</p> <p>简单推理部分算法情况</p> <p>首先找到A[7]，也就是3,3在C中是7，也就是说它属于第7个元素，那么它应该存放在B[6]的位置，B[6]相当于第7个位置</p> <p>我们可以让B[—i]，也就是7自减后，存到B[6]的位置</p> <p>接着A[6]，也就是0,0在C中是2，也就是说继续进行这样的操作，B[—i]，也就是2自减后，存到B[1]的位置</p> <p>以此类推，后面不再赘述</p> <div class="expressive-code"><figure class="frame"><figcaption class="header"></figcaption><pre data-language="c"><code><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">1</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// A是输入数组(待排序数组)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">2</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// B是输出数组</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">3</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// n是A[]的长度</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">4</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// k是反映A[]的取值范围</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">5</div></div><div class="code"> </div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">6</div></div><div class="code"><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic">// 计数排序</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">7</div></div><div class="code"><span style="--0:#9039C9;--1:#C792EA">void</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#4C6690;--1:#82AAFF">CountSort</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">A</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">B</span><span style="--0:#9039C9;--1:#C792EA">[]</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">n</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#5A676D;--1:#EEFFFF"> </span><span style="--0:#5A676D;--0fs:italic;--1:#EEFFFF;--1fs:italic">k</span><span style="--0:#256F74;--1:#89DDFF">){</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">8</div></div><div class="code"><span class="indent"> </span><span style="--0:#9039C9;--1:#C792EA">int</span><span style="--0:#BE2F2C;--1:#F07178"> i</span><span style="--0:#256F74;--1:#89DDFF">,</span><span style="--0:#5A676D;--1:#EEFFFF">C</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 辅助数组C的长度取决于待排序元素取值范围[0,k)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">9</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 初始化计数数组</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">10</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">C</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">11</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 遍历待排序数组，统计每个关键字的出现次数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">12</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">C</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]]++;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">13</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">&#x3C;</span><span style="--0:#BE2F2C;--1:#F07178">k</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">++)</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 再次处理辅助数组，统计不大于i的元素个数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">14</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">C</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]=</span><span style="--0:#5A676D;--1:#EEFFFF">C</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]+</span><span style="--0:#5A676D;--1:#EEFFFF">C</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // C[i]保存的是小于或等于i个元素个数</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">15</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--0fs:italic;--1:#89DDFF;--1fs:italic">for</span><span style="--0:#256F74;--1:#89DDFF">(</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">=</span><span style="--0:#BE2F2C;--1:#F07178">n</span><span style="--0:#256F74;--1:#89DDFF">-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">>=</span><span style="--0:#A64930;--1:#F78C6C">0</span><span style="--0:#256F74;--1:#89DDFF">;</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">--){</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 利用辅助数组C实现计数排序(从后往前处理)</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">16</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">C</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]]=</span><span style="--0:#5A676D;--1:#EEFFFF">C</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]]-</span><span style="--0:#A64930;--1:#F78C6C">1</span><span style="--0:#256F74;--1:#89DDFF">;</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">17</div></div><div class="code"><span class="indent"> </span><span style="--0:#5A676D;--1:#EEFFFF">B</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">C</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">]]]=</span><span style="--0:#5A676D;--1:#EEFFFF">A</span><span style="--0:#256F74;--1:#89DDFF">[</span><span style="--0:#BE2F2C;--1:#F07178">i</span><span style="--0:#256F74;--1:#89DDFF">];</span><span style="--0:#5A676D;--0fs:italic;--1:#979797;--1fs:italic"> // 将元素A放在输出数组B[]的正确位置上</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">18</div></div><div class="code"><span class="indent"> </span><span style="--0:#256F74;--1:#89DDFF">}</span></div></div><div class="ec-line"><div class="gutter"><div class="ln" aria-hidden="true">19</div></div><div class="code"><span style="--0:#256F74;--1:#89DDFF">}</span></div></div></code></pre><div class="copy"><button title="Copy to clipboard" data-copied="Copied!" data-code="// A是输入数组(待排序数组)// B是输出数组// n是A[]的长度// k是反映A[]的取值范围// 计数排序void CountSort(int A[],int B[],int n,int k){ int i,C[k]; // 辅助数组C的长度取决于待排序元素取值范围[0,k) for(i=0;i<k;i++) // 初始化计数数组 C[i]=0; for(i=0;i<n;i++) // 遍历待排序数组，统计每个关键字的出现次数 C[A[i]]++; for(i=1;i<k;i++) // 再次处理辅助数组，统计不大于i的元素个数 C[i]=C[i]+C[i-1]; // C[i]保存的是小于或等于i个元素个数 for(i=n-1;i>=0;i--){ // 利用辅助数组C实现计数排序(从后往前处理) C[A[i]]=C[A[i]]-1; B[C[A[i]]]=A[i]; // 将元素A放在输出数组B[]的正确位置上 }}"><div></div></button></div></figure></div> <h2 id="外部排序">外部排序</h2> <p>外部排序：数据元素太多，无法一次全部读入内存进行排序</p> <p>具体看视频吧，有点抽象</p> <p><a href="%E5%A4%96%E9%83%A8%E6%8E%92%E5%BA%8F">https://www.bilibili.com/video/BV1b7411N798?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=101</a></p> <h2 id="败者树">败者树</h2> <p>优化归并问题</p> <p>败者树---可视为一棵完全二叉树(多了一个头头)</p> <p>k个叶结点分别是当前参加比较的元素，非叶子结点用来记忆左右子树中的“失败者”，而让胜者往上继续进行比较，一直到根结点</p> <p><a href="https://www.bilibili.com/video/BV1b7411N798?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=102">https://www.bilibili.com/video/BV1b7411N798?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=102</a></p> <h2 id="置换-选择排序">置换-选择排序</h2> <p>晕倒：<a href="https://www.bilibili.com/video/BV1b7411N798?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=103">https://www.bilibili.com/video/BV1b7411N798?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=103</a></p> <h2 id="最佳归并树">最佳归并树</h2> <p>最后一节了，不记了：<a href="https://www.bilibili.com/video/BV1b7411N798?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=104">https://www.bilibili.com/video/BV1b7411N798?spm_id_from=333.788.player.switch&#x26;vd_source=b39debcbe1026bb04f6c19f233bab974&#x26;p=104</a></p> <h1 id="总结-3">总结</h1> <p>很有精神的课，学起来很累，麻蛋，算法真他娘的不是人学的，拜拜了您嘞！</p>