各种排序算法,数据结构中的排序算法
掌握数据结构的关键技巧

掌握数据结构的关键技巧数据结构是计算机科学中非常重要的基础知识,它是指数据元素之间的关系,以及对这些数据元素进行操作的方法。
掌握数据结构的关键技巧对于编程能力的提升至关重要。
下面将介绍几个帮助你掌握数据结构的关键技巧。
一、深入理解基本数据结构1. 数组(Array):数组是最基本的数据结构之一,它是一组连续的内存空间,用于存储相同类型的数据。
掌握数组的基本操作,如插入、删除、查找等,是学习数据结构的第一步。
2. 链表(Linked List):链表是由节点组成的数据结构,每个节点包含数据和指向下一个节点的指针。
理解链表的特点和操作方式,能够帮助你更好地理解指针和内存管理。
3. 栈(Stack)和队列(Queue):栈和队列是两种常用的数据结构,它们分别遵循“先进后出”和“先进先出”的原则。
掌握它们的基本操作和应用场景,有助于解决实际编程中的问题。
二、熟练掌握常见算法1. 排序算法:排序算法是数据结构中的重要内容,包括冒泡排序、快速排序、归并排序等。
熟练掌握各种排序算法的原理和实现方式,能够提高程序的效率和性能。
2. 查找算法:查找算法用于在数据集中查找特定元素,包括线性查找、二分查找等。
了解不同查找算法的特点和适用场景,能够帮助你快速定位和处理数据。
3. 图算法:图是一种复杂的数据结构,图算法包括深度优先搜索(DFS)、广度优先搜索(BFS)等。
掌握图算法可以解决网络分析、路径规划等实际问题。
三、多练习、多实践1. 刷题:通过刷LeetCode、牛客网等在线编程平台的题目,可以帮助你熟练掌握数据结构和算法的应用。
不断挑战自己,解决各种难题,提高编程能力。
2. 实际项目:将所学的数据结构和算法运用到实际项目中,通过实践来加深理解和掌握。
参与开源项目、编程比赛等活动,锻炼自己的编程技能。
四、不断学习、持续改进1. 学习资料:阅读相关的书籍、博客、论文等,了解数据结构和算法的最新发展和应用。
保持学习的热情,不断充实自己的知识库。
C语言常用算法概述

C语言常用算法概述C语言作为一种通用的高级编程语言,广泛应用于计算机科学领域,特别是在算法和数据结构方面。
C语言提供了许多常用算法,这些算法能够解决各种计算问题,并提供了高效的解决方案。
本文将概述C语言中常用的算法,包括排序算法、查找算法和图算法。
一、排序算法排序算法是将一组元素按照特定的顺序排列的算法。
C语言提供多种排序算法,下面将介绍几种常用的排序算法。
1. 冒泡排序冒泡排序是一种简单的排序算法,它通过多次遍历数组,每次比较相邻的两个元素,将较大的元素向后移动。
通过多次遍历,最大的元素会逐渐“冒泡”到数组的末尾。
2. 插入排序插入排序是一种稳定的排序算法,它通过将数组分为已排序和未排序两部分,将未排序的元素逐个插入已排序的部分,使得整个数组逐渐有序。
3. 快速排序快速排序是一种高效的排序算法,它通过选择一个基准元素,将数组分成两个子数组,其中一个子数组中的元素都小于基准,另一个子数组中的元素都大于基准。
然后递归地对两个子数组进行排序。
4. 归并排序归并排序是一种稳定的排序算法,它通过将数组划分为多个子数组,然后将这些子数组逐个合并,最终得到有序的数组。
归并排序使用了分治的思想,对子数组进行递归排序。
二、查找算法查找算法用于在一个集合中寻找特定元素的算法。
C语言提供了多种查找算法,下面将介绍两种常用的查找算法。
1. 顺序查找顺序查找是一种简单的查找算法,它通过逐个比较集合中的元素,直到找到需要查找的元素或者遍历完整个集合。
2. 二分查找二分查找是一种高效的查找算法,它要求集合必须有序。
它通过将集合分成两半,然后比较需要查找的元素与中间元素的大小关系,从而确定下一步查找的范围。
三、图算法图算法用于解决图结构相关的计算问题。
C语言提供了多种图算法,下面将介绍两种常用的图算法。
1. 深度优先搜索深度优先搜索是一种用于遍历或搜索图的算法,它通过从一个顶点出发,依次访问与该顶点相邻的未访问过的顶点。
当无法再继续访问时,回退到上一个顶点继续搜索。
cspj初赛知识点汇总

cspj初赛知识点汇总计算机科学程序设计竞赛(CSPJ)是一个旨在测试参赛者在计算机科学和程序设计方面知识与技能的比赛。
初赛是CSPJ的第一轮选拔,要求参赛者掌握一系列的知识点。
本文将对CSPJ初赛的知识点进行汇总,以帮助参赛者更好地备战。
一、算法与数据结构1. 排序算法:常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等。
2. 查找算法:包括二分查找、线性查找等。
3. 图论算法:涉及最短路径、最小生成树、拓扑排序等。
4. 树与图的遍历:深度优先搜索(DFS)和广度优先搜索(BFS)。
5. 栈、队列和链表:了解它们的特性和应用场景。
二、编程语言与语法1. C++语言:CSPJ初赛通常使用C++作为编程语言,需掌握C++的基本语法、输入输出、条件语句、循环结构等。
2. 数据类型:熟悉各种数据类型的定义和使用方法。
3. 函数和类:了解函数的定义与调用、类的属性与方法的实现。
4. 指针和引用:理解指针和引用的概念及其在程序设计中的应用。
5. STL标准模板库:熟悉STL库中的容器(vector、set、map等)和算法(find、sort、reverse等)的使用。
三、数学与思维能力1. 数论:了解质数、约数、最大公约数、最小公倍数等基本概念和性质。
2. 排列组合与概率:掌握排列组合的计算方法,理解概率与事件的关系。
3. 递归与递推:理解递归和递推的概念,能够利用递归和递推解决问题。
4. 动态规划:了解动态规划的基本思想和常用解题方法。
四、代码调试与错误分析1. 代码调试:掌握常见的调试技巧,如使用断点、日志输出、打印变量值等。
2. 错误分析:能够分析代码中的错误类型,如语法错误、逻辑错误和运行时错误。
了解常见错误的原因及解决方法。
五、编程思路与优化1. 分析问题:能够准确理解题目要求,分析问题的输入、输出和约束条件。
2. 寻找解法:灵活运用先进的算法和数据结构解决问题,善于寻找规律和优化方案。
java常用算法和数据结构

java常用算法和数据结构Java是一种面向对象的编程语言,它具有丰富的算法库和数据结构库,为开发人员提供了许多常用的算法和数据结构。
下面将介绍一些Java常用的算法和数据结构。
1.排序算法-冒泡排序(Bubble Sort):比较相邻的两个元素,如果顺序错误则交换位置,重复该过程直到整个序列有序。
-插入排序(Insertion Sort):将数组分为已排序和未排序两部分,每次从未排序部分取出一个元素,插入到已排序部分合适的位置。
-选择排序(Selection Sort):每次从未排序部分选择最小(或最大)的元素,放到已排序部分的末尾。
-快速排序(Quick Sort):选择一个基准元素,将数组分为两部分,小于基准的放左边,大于基准的放右边,递归地对左右两部分进行快速排序。
-归并排序(Merge Sort):将数组分为两部分,分别对每个子数组进行排序,然后合并两个有序子数组。
2.搜索算法-二分查找(Binary Search):对有序数组进行查找,每次将查找范围缩小一半。
-广度优先搜索(BFS):以树或图的形式搜索,从根节点开始,逐层扩展搜索范围,直到找到目标节点。
-深度优先搜索(DFS):以树或图的形式搜索,从根节点开始,逐个访问节点的所有邻居节点,直到找到目标节点或搜索完所有节点。
3.数据结构-数组(Array):一组按顺序存储的相同类型元素的集合,通过索引访问元素,可以快速访问元素,但插入和删除元素较慢。
-链表(Linked List):一组通过指针连接的节点存储的元素的集合,支持灵活的插入和删除操作,但访问元素较慢。
-栈(Stack):一种特殊的线性数据结构,遵循先进后出(LIFO)原则,只能在栈顶进行插入和删除操作。
-队列(Queue):一种特殊的线性数据结构,遵循先进先出(FIFO)原则,在队尾插入元素,队头删除元素。
-堆(Heap):一种特殊的树形数据结构,可以快速找到最小(或最大)元素,常用于实现优先队列。
数据结构课程设计—内部排序算法比较

数据结构课程设计—内部排序算法比较在计算机科学领域中,数据的排序是一项非常基础且重要的操作。
内部排序算法作为其中的关键部分,对于提高程序的运行效率和数据处理能力起着至关重要的作用。
本次课程设计将对几种常见的内部排序算法进行比较和分析,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
冒泡排序是一种简单直观的排序算法。
它通过重复地走访要排序的数列,一次比较两个数据元素,如果顺序不对则进行交换,并一直重复这样的走访操作,直到没有要交换的数据元素为止。
这种算法的优点是易于理解和实现,但其效率较低,在处理大规模数据时性能不佳。
因为它在最坏情况下的时间复杂度为 O(n²),平均时间复杂度也为O(n²)。
插入排序的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入,直到整个序列有序。
插入排序在数据量较小时表现较好,其平均时间复杂度和最坏情况时间复杂度也都是 O(n²),但在某些情况下,它的性能可能会优于冒泡排序。
选择排序则是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(或最大)元素,然后放到已排序序列的末尾。
以此类推,直到全部待排序的数据元素排完。
选择排序的时间复杂度同样为O(n²),但它在某些情况下的交换操作次数可能会少于冒泡排序和插入排序。
快速排序是一种分治的排序算法。
它首先选择一个基准元素,将数列分成两部分,一部分的元素都比基准小,另一部分的元素都比基准大,然后对这两部分分别进行快速排序。
快速排序在平均情况下的时间复杂度为 O(nlogn),最坏情况下的时间复杂度为 O(n²)。
然而,在实际应用中,快速排序通常表现出色,是一种非常高效的排序算法。
归并排序也是一种分治算法,它将待排序序列分成若干个子序列,每个子序列有序,然后将子序列合并成一个有序序列。
计算机的基本算法

计算机的基本算法在计算机科学领域,算法是一组用于解决特定问题的指令和规则。
它们是计算机系统实现各种功能和任务的基础。
本文介绍和探讨了计算机的基本算法,包括排序算法、搜索算法和图算法。
一、排序算法排序算法是计算机科学中最基本和常用的算法之一。
它们的作用是将一组无序的数据按照升序或降序进行排列。
以下介绍几种常见的排序算法:1. 冒泡排序冒泡排序是一种通过多次比较和交换来实现排序的算法。
它的基本思想是从第一个元素开始,依次比较相邻的两个元素,如果它们的顺序不对则进行交换,直到达到整体有序的状态。
2. 插入排序插入排序是一种在已排序序列中插入新元素的排序算法。
它的基本思想是将待排序的数据分为已排序和未排序两部分,每次从未排序中取出一个元素,在已排序序列中找到合适的位置插入,保证每次插入后已排序序列仍然有序。
3. 快速排序快速排序是一种高效的排序算法,它采用分治的思想。
它的基本思想是选择一个基准元素,通过一趟排序将原数据划分为两部分,左边部分的元素都小于基准元素,右边部分的元素都大于基准元素,然后递归地对左右两部分进行排序。
二、搜索算法搜索算法是在给定数据集中查找特定元素或信息的算法。
以下介绍几种常见的搜索算法:1. 顺序搜索顺序搜索是一种逐个遍历数据元素进行匹配的搜索算法。
它的基本思想是从数据的第一个元素开始,依次和目标元素进行比较,直到找到匹配的元素或者遍历完整个数据集。
2. 二分搜索二分搜索是一种在有序数据集中查找目标元素的算法。
它的基本思想是将数据集分为两部分,判断目标元素可能在哪一部分,然后递归地在相应的部分中进行搜索,缩小搜索范围直至找到目标元素或确定不存在。
三、图算法图算法是用于解决图结构相关问题的算法。
图是由节点和边组成的数据结构,常用于表示多个对象之间的关系。
以下介绍几种常见的图算法:1. 广度优先搜索广度优先搜索是一种遍历图的算法,它从指定的起始节点开始,逐层扩展搜索到的节点,直到没有未搜索的节点为止。
数据结构实验报告-排序

数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现,并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法:冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序,并记录其性能指标,包括排序时间和所占用的内存空间。
三、实验步骤1. 数据的生成在实验开始前,首先生成一组随机数据作为排序的输入。
定义一个具有大数据量的数组,并随机生成一组在指定范围内的整数,用于后续排序算法的比较。
2. 冒泡排序冒泡排序是一种简单直观的排序算法。
其基本思想是从待排序的数据序列中逐个比较相邻元素的大小,并依次交换,从而将最大(或最小)的元素冒泡到序列的末尾。
重复该过程直到所有数据排序完成。
3. 快速排序快速排序是一种分治策略的排序算法,效率较高。
它将待排序的序列划分成两个子序列,其中一个子序列的所有元素都小于等于另一个子序列的所有元素。
然后对两个子序列分别递归地进行快速排序。
4. 归并排序归并排序是一种稳定的排序算法,使用分治策略将序列拆分成较小的子序列,然后递归地对子序列进行排序,最后再将子序列合并成有序的输出序列。
归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。
四、实验结果经过多次实验,我们得到了以下结果:1. 冒泡排序在数据量较小时,冒泡排序表现良好,但随着数据规模的增大,其性能明显下降。
排序时间随数据量的增长呈平方级别增加。
2. 快速排序相比冒泡排序,快速排序在大数据量下的表现更佳。
它的排序时间线性增长,且具有较低的内存占用。
3. 归并排序归并排序在各种数据规模下都有较好的表现。
它的排序时间与数据量呈对数级别增长,且对内存的使用相对较高。
五、实验分析根据实验结果,我们可以得出以下结论:1. 冒泡排序适用于数据较小的排序任务,但面对大数据量时表现较差,不推荐用于处理大规模数据。
2. 快速排序是一种高效的排序算法,适用于各种数据规模。
数据结构课程设报告—各种排序算法的比较

数据结构课程设计报告几种排序算法的演示1、需求分析:运行环境:Microsoft Visual Studio 20052、程序实现功能:3、通过用户键入的数据, 经过程序进行排序, 最后给予数据由小到大的输出。
排序的方式包含教材中所介绍的几种常用的排序方式:直接插入排序、折半插入排序、冒泡排序、快速排序、选择排序、堆排序、归并排序。
每种排序过程中均显示每一趟排序的细节。
程序的输入:输入所需排序方式的序号。
输入排序的数据的个数。
输入具体的数据元素。
程序的输出:输出排序每一趟的结果, 及最后排序结果1、设计说明:算法设计思想:a交换排序(冒泡排序、快速排序)交换排序的基本思想是: 对排序表中的数据元素按关键字进行两两比较, 如果发生逆序(即排列顺序与排序后的次序正好相反), 则两者交换位置, 直到所有数据元素都排好序为止。
b插入排序(直接插入排序、折半插入排序)插入排序的基本思想是: 每一次设法把一个数据元素插入到已经排序的部分序列的合适位置, 使得插入后的序列仍然是有序的。
开始时建立一个初始的有序序列, 它只包含一个数据元素。
然后, 从这个初始序列出发不断插入数据元素, 直到最后一个数据元素插到有序序列后, 整个排序工作就完成了。
c选择排序(简单选择排序、堆排序)选择排序的基本思想是: 第一趟在有n个数据元素的排序表中选出关键字最小的数据元素, 然后在剩下的n-1个数据元素中再选出关键字最小(整个数据表中次小)的数据元素, 依次重复, 每一趟(例如第i趟, i=1, …, n-1)总是在当前剩下的n-i+1个待排序数据元素中选出关键字最小的数据元素, 作为有序数据元素序列的第i个数据元素。
等到第n-1趟选择结束, 待排序数据元素仅剩下一个时就不用再选了, 按选出的先后次序所得到的数据元素序列即为有序序列, 排序即告完成。
d归并排序(两路归并排序)1、两路归并排序的基本思想是: 假设初始排序表有n个数据元素, 首先把它看成是长度为1的首尾相接的n个有序子表(以后称它们为归并项), 先做两两归并, 得n/2上取整个长度为2的归并项(如果n为奇数, 则最后一个归并项的长度为1);再做两两归并, ……, 如此重复, 最后得到一个长度为n的有序序列。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1.直接插入排序//InsertSort.cpp//This function is to sort SqList# include <iostream.h># include <conio.h># define MAXSIZE 20# define MAX_LENGTH 100typedef int RedType;typedef struct //define structure SqList{ RedType r[MAXSIZE+1];int length;}SqList;void InsertSort(SqList &L) //InsertSort() sub-function{ int i,j;for(i=2;i<=L.length;++i)if(L.r[i]<L.r[i-1]){ L.r[0]=L.r[i];for(j=i-1;L.r[0]<L.r[j];--j)L.r[j+1]=L.r[j];L.r[j+1]=L.r[0];}}void main() //main() function{ int i;SqList L;cout<<endl<<endl<<"InsertSort.cpp";cout<<endl<<"==============";cout<<endl<<"Please input the length of SqList (eg,5): "<<endl<<endl; cin>>L.length;for(i=1;i<=L.length;++i){ cout<<"Please input the "<<i<<"th integer (eg,58): ";cin>>L.r[i];}cout<<endl<<"The disordered : ";for(i=1;i<=L.length;i++)cout<<L.r[i]<<" ";InsertSort(L); //call InsertSort()cout<<endl<<"The ordered : ";for(i=1;i<=L.length;i++)cout<<L.r[i]<<" ";cout<<endl<<endl<<"...OK!...";getch();} //main() end2.希尔排序//Shellinert.cpp//This function is Shell sort# include <iostream.h># include <conio.h># define MAXSIZE 20# define OK 1# define ERROR 0typedef int RedType;typedef struct //structure SqList{ RedType r[MAXSIZE+1];int length;}SqList;void Shellinsert(SqList&L,int dk) //Shellinsert() sub-function { int i,j;for(i=dk+1;i<=L.length;++i)if(L.r[i]<L.r[i-dk]){ L.r[0]=L.r[i];for(j=i-dk;j>0&&(L.r[0]<L.r[j]);j-=dk)L.r[j+dk]=L.r[j];L.r[j+dk]=L.r[0];}}void main() //main() function{ int i,dk=5;SqList L={{0,49,38,65,97,76,13,27,49,55,4},10};cout<<endl<<endl<<"Shellinsert.cpp";cout<<endl<<"==============="<<endl;cout<<endl<<endl<<"The disordered : ";for(i=1;i<=L.length;i++)cout<<L.r[i]<<" ";Shellinsert(L,dk); //call Shellinsert()cout<<endl<<"The once ShellSorted sorted: ";for(i=1;i<=L.length;i++)cout<<L.r[i]<<" ";cout<<endl<<endl<<"...OK!...";getch();} //main() end3.冒泡排序//BubbleSort.cpp//This function is to sort SqList# include <iostream.h># include <conio.h># define MAXSIZE 20# define MAX_LENGTH 100typedef int RedType;typedef struct //define structure SqList{ RedType r[MAXSIZE+1];int length;}SqList;void BubbleSort(SqList &L){ int i,j,temp;for(i=0;i<=L.length;++i)for(j=L.length-2;j>i;--j)if(L.r[j+1]<L.r[j]){ temp=L.r[j+1];L.r[j+1]=L.r[j];L.r[j]=temp;}}void main() //main() function{ int i;SqList L;cout<<endl<<endl<<"BubbleSort.cpp";cout<<endl<<"=============="<<endl;cout<<endl<<"Please input the length of SqList (eg,5): ";cin>>L.length;L.length++; //the last is aided spacefor(i=1;i<L.length;++i){ cout<<"Please input the "<<i<<"th element of SqList (eg,58): "; cin>>L.r[i];}cout<<endl<<"The disordered : ";for(i=1;i<L.length;i++)cout<<L.r[i]<<" ";BubbleSort(L); //call BubbleSort()cout<<endl<<"The ordered : ";for(i=1;i<L.length;i++)cout<<L.r[i]<<" ";cout<<endl<<endl<<"...OK!...";getch();} //main() end4.快速排序//QuickSort.cpp//This function is to quick-sort SqList# include <iostream.h># include <conio.h># define MAXSIZE 20typedef int RedType;typedef struct //define SqList structure{ RedType r[MAXSIZE+1];int length;}SqList;int Partition(SqList &L,int low,int high) //Partition() sub-function { int pivotkey;L.r[0]=L.r[low];pivotkey=L.r[low];while(low<high){ while(low<high&&L.r[high]>=pivotkey)--high;L.r[low]=L.r[high];while(low<high&&L.r[low]<=pivotkey)++low;L.r[high]=L.r[low];}L.r[low]=L.r[0];return (low);} //Partition() endvoid Qsort(SqList &L,int low,int high) //Qsort() sub-function { int pivotloc;if(low<high){ pivotloc=Partition(L,low,high);Qsort(L,low,pivotloc-1);Qsort(L,pivotloc+1,high);}}void QuickSort(SqList &L) //QuickSort() sub-function { Qsort(L,1,L.length); //call Qsort()}void main() //main() function{ int i;SqList L={{0,49,38,65,97,76,13,27,49},8};cout<<endl<<endl<<"QuickSort.cpp";cout<<endl<<"============="<<endl;cout<<endl<<"The disordered : ";for(i=1;i<=L.length;i++)cout<<L.r[i]<<" ";QuickSort(L); //call QuickSort()cout<<endl<<"The sorted : ";for(i=1;i<=L.length;i++)cout<<L.r[i]<<" ";cout<<endl<<endl<<"...OK!...";getch();} //main() end5.直接选择排序//SelectSort.cpp//This function is to SelectSort SqList# include <iostream.h># include <conio.h># define MAXSIZE 20typedef int RedType;typedef struct //define structure SqList{ RedType r[MAXSIZE+1];int length;}SqList;void SelectSort(SqList &L) //SelectSort() sub-function{ int i,j,k,temp;for(i=0;i<L.length;++i){ k=i;for(j=i+1;j<L.length;++j)if(L.r[j]<L.r[k])k=j;if(i!=k){ temp=L.r[i];L.r[i]=L.r[k];L.r[k]=temp;}}}//SelectSort() endvoid main() //main() function{ int i;SqList L={{49,38,65,97,76,13,27,49,},8};cout<<endl<<endl<<"SelectSort.cpp";cout<<endl<<"=============="<<endl;cout<<endl<<"The disordered : ";for(i=0;i<L.length;i++)cout<<L.r[i]<<" ";SelectSort(L); //call SelectSort()cout<<endl<<"The sorted : ";for(i=0;i<L.length;i++)cout<<L.r[i]<<" ";cout<<endl<<endl<<"...OK!...";getch();} //main() end6.堆栈排序//HeapSort.cpp//This function is to HeapSort SqList# include <iostream.h># include <conio.h># define MAXSIZE 20typedef int RedType;typedef struct //define structure SqList{ RedType r[MAXSIZE+1];int length;}SqList;typedef SqList HeapType;void HeapAdjust(HeapType &H,int s,int m) //HeapAdjust() sub-function { int temp,j;temp=H.r[s];for(j=2*s;j<=m;j*=2){ if(j<m&&(H.r[j]<H.r[j+1]))++j;if(!(temp<H.r[j]))break;H.r[s]=H.r[j];s=j;}H.r[s]=temp;} //HeapAdjust() endvoid HeapSort(HeapType &H) //HeapSort() sub-function{ int i,temp;for(i=H.length/2;i>0;--i)HeapAdjust(H,i,H.length);for(i=H.length;i>1;--i){ temp=H.r[1];H.r[1]=H.r[i];H.r[i]=temp;HeapAdjust(H,1,i-1);}} //HeapSort() endvoid main() //main() function{ int i;HeapType H={{0,49,38,65,97,76,13,27,49},8};cout<<endl<<endl<<"HeapSort.cpp";cout<<endl<<"============"<<endl;cout<<endl<<"The disordered : ";for(i=1;i<=H.length;i++)cout<<H.r[i]<<" ";HeapSort(H); //call HeapSort()cout<<endl<<"The sorted : ";for(i=1;i<=H.length;i++)cout<<H.r[i]<<" ";cout<<endl<<endl<<"...OK!...";getch();} //main() end7.归并排序//MergeSort.cpp#include <iostream.h>#include <conio.h>#define MAXSIZE 20#define LENGTH 7typedef int RedType;typedef struct //SqList structure{ RedType r[MAXSIZE+1]; //Records Typeint length;}SqList;typedef SqList RcdType;void Merge(RcdType SR,RcdType &TR,int i,int m,int n) //Merge() function { int j,k;for(j=m+1,k=i;i<=m&&j<=n;++k){ if(SR.r[i]<=SR.r[j])TR.r[k]=SR.r[i++];elseTR.r[k]=SR.r[j++];}while(i<=m)TR.r[k++]=SR.r[i++];while(j<=n)TR.r[k++]=SR.r[j++];}//end of Merge() functionvoid MSort(RcdType SR,RcdType &TR1,int s, int t) //MSort() function { int m;RcdType TR2;//[LENGTH];if(s==t)TR1.r[s]=SR.r[t];else{ m=(s+t)/2;MSort(SR,TR2,s,m);MSort(SR,TR2,m+1,t);Merge(TR2,TR1,s,m,t);}//end of else}//end of MSort() functionvoid MergeSort(SqList &L) //MergeSort() function{MSort(L,L,1,L.length);}//end of MergeSort() functionvoid main() //main function{ int i;SqList L;//={{0,49,38,65,97,76,13,27,},LENGTH};cout<<"MergeSort.cpp"<<endl<<"============="<<endl<<endl;cout<<"Please input the length of SqList L: <eg. 7> ";cin>>L.length;cout<<"Please input the disordered array L.r: <eg.{49,38,65,97,76,13,27,...}>"<<endl;for(i=1;i<=L.length;i++)cin>>L.r[i];MergeSort(L);cout<<endl<<"The sorted array L.r: ";for(i=1;i<=L.length;i++)cout<<L.r[i]<<" ";cout<<endl;cout<<"...OK!..."<<endl;getch();}//end of main() function8.基数排序//Radixsort.cpp# include <iostream.h># include <stdio.h># include <conio.h># define MAX_NUM_OF_KEY 8# define RD 10# define MAX_SPACE 10000# define ERROR -1typedef int KeyType;typedef int InfoType;typedef int ArrType[RD];typedef struct SLCell{ KeyType keys[MAX_NUM_OF_KEY];InfoType otheritems;int next;}SLCell;typedef struct SLList{ SLCell r[MAX_SPACE];int keynum;int recnum;}SLList;int Succ(int j) //Succ() function{//To get the next functionj++;return (j);}//end of Succ() functionint Ord(int KeyBit) //Ord() function{int j;for(j=0;j<=RD-1&&j!=KeyBit;j++);if(j!=KeyBit) return(ERROR); //KeyBit OVERFLOW THEN ERROR else return(j);}//end of Ord() functionvoid OutExample(SLList L,int i) //OutExample() function{//////////////////// Output ////////////////int temp,k;printf("\nThe %d Collect result is: ",i);// temp=L.r[0].otheritems;// printf("%d -> ",temp);temp=L.r[0].next;printf("%d -> ",L.r[temp].otheritems);for(k=0;k<L.recnum-2;k++){ temp=L.r[temp].next;printf("%d -> ",L.r[temp].otheritems);}printf("%d",L.r[L.r[temp].next].otheritems);printf("\n");//////////////////////////////////////////////}//end of OutExample() functionvoid Distribute(SLList &L,int i,ArrType &f,ArrType &e) //Distribute() function { int j,p;for(j=0;j<RD;j++)f[j]=0;for(p=L.r[0].next;p;p=L.r[p].next){ j=Ord(L.r[p].keys[i]); //call Ord()if(!f[j])f[j]=p;elseL.r[e[j]].next=p;e[j]=p;}//end of for}//end of Distrubute() functionvoid Collect(SLList &L,int i,ArrType f,ArrType e) //Collect() function { int j,t;for(j=0;!f[j];j=Succ(j)); //Succ()L.r[0].next=f[j];t=e[j];while(j<RD-1){ for(j=Succ(j);j<RD-1&&!f[j];j=Succ(j));if(f[j]){ L.r[t].next=f[j];t=e[j];}//end of if}//end of whileL.r[t].next=0;OutExample(L,i); //Add Output Example function here}//end of Collect() functionvoid RadixSort(SLList &L){ int i;ArrType f,e;for(i=0;i<L.recnum;i++)L.r[i].next=i+1;L.r[L.recnum].next=0;for(i=0;i<L.keynum;i++){ Distribute(L,i,f,e);Collect(L,i,f,e);}//end of for}//end of RadixSort() functionvoid InitExample(SLList &L){//Take SLList L for exampleL.keynum=3; //total key number is 3L.recnum=7; //total current node is 10L.r[1].otheritems=278;L.r[2].otheritems=109;L.r[3].otheritems=163;L.r[4].otheritems=930;L.r[5].otheritems=580;L.r[6].otheritems=184;L.r[7].otheritems=505;//L.r[7].otheritems=0;cout<<"The InitExample SLList L is:"<<"278->109->163->930->580->184->505"<<endl;L.r[1].keys[0]=8;L.r[1].keys[1]=7;L.r[1].keys[2]=2;L.r[2].keys[0]=9;L.r[2].keys[1]=0;L.r[2].keys[2]=1;L.r[3].keys[0]=3;L.r[3].keys[1]=6;L.r[3].keys[2]=1;L.r[4].keys[0]=0;L.r[4].keys[1]=3;L.r[4].keys[2]=9;L.r[5].keys[0]=0;L.r[5].keys[1]=8;L.r[5].keys[2]=5;L.r[6].keys[0]=4;L.r[6].keys[1]=8;L.r[6].keys[2]=1;L.r[7].keys[0]=5;L.r[7].keys[1]=0;L.r[7].keys[2]=5;}void main() //main function{SLList L;cout<<"RadixSort.cpp"<<endl<<"============="<<endl<<endl;InitExample(L); //For exampleRadixSort(L); //RadixSortcout<<endl;getch();}。