十大经典排序算法C语言Word文档下载推荐.docx
《十大经典排序算法C语言Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《十大经典排序算法C语言Word文档下载推荐.docx（14页珍藏版）》请在冰豆网上搜索。
j<
len-1-i;
j++）{
if（arr[j]>
arr[j+1]）{//相邻元素两两对比
vartemp=arr[j+1];
//元素交换
arr[j+1]=arr[j];
arr[j]=temp;
}
returnarr;
选择排序（Selection-sort）是一种简单直观的排序算法。
它的工作原理：
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
2.1算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。
具体算法描述如下：
▪初始状态：
无序区为R[1..n]，有序区为空；
▪第i趟排序（i=1,2,3…n-1）开始时，当前有序区和无序区分别为R[1..i-1]和R（i..n）。
该趟排序从当前无序区中-选出关键字最小的记录R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n）分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
▪n-1趟结束，数组有序化了。
2.2动图演示
2.3代码实现
functionselectionSort（arr）{
varminIndex,temp;
minIndex=i;
for（varj=i+1;
len;
if（arr[j]<
arr[minIndex]）{//寻找最小的数
minIndex=j;
//将最小数的索引保存
temp=arr[i];
arr[i]=arr[minIndex];
arr[minIndex]=temp;
2.4算法分析
表现最稳定的排序算法之一，因为无论什么数据进去都是O（n2）的时间复杂度，所以用到它的时候，数据规模越小越好。
唯一的好处可能就是不占用额外的内存空间了吧。
理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
3.1算法描述
一般来说，插入排序都采用in-place在数组上实现。
▪从第一个元素开始，该元素可以认为已经被排序；
▪取出下一个元素，在已经排序的元素序列中从后向前扫描；
▪如果该元素（已排序）大于新元素，将该元素移到下一位置；
▪重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
▪将新元素插入到该位置后；
▪重复步骤2~5。
3.2动图演示
3.2代码实现
functioninsertionSort（arr）{
varpreIndex,current;
for（vari=1;
preIndex=i-1;
current=arr[i];
while（preIndex>
=0&
&
arr[preIndex]>
current）{
arr[preIndex+1]=arr[preIndex];
preIndex--;
arr[preIndex+1]=current;
3.4算法分析
插入排序在实现上，通常采用in-place排序（即只需用到O
（1）的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
1959年Shell发明，第一个突破O（n2）的排序算法，是简单插入排序的改进版。
它与插入排序的不同之处在于，它会优先比较距离较远的元素。
希尔排序又叫缩小增量排序。
4.1算法描述
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
▪选择一个增量序列t1，t2，…，tk，其中ti>
tj，tk=1；
▪按增量序列个数k，对序列进行k趟排序；
▪每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对各子表进行直接插入排序。
仅增量因子为1时，整个序列作为一个表来处理，表长度即为整个序列的长度。
4.2动图演示
4.3代码实现
functionshellSort（arr）{
varlen=arr.length,
temp,
gap=1;
while（gap<
len/3）{//动态定义间隔序列
gap=gap*3+1;
for（gap;
gap>
0;
gap=Math.floor（gap/3））{
for（vari=gap;
for（varj=i-gap;
j>
0&
arr[j]>
temp;
j-=gap）{
arr[j+gap]=arr[j];
arr[j+gap]=temp;
4.4算法分析
希尔排序的核心在于间隔序列的设定。
既可以提前设定好间隔序列，也可以动态的定义间隔序列。
动态定义间隔序列的算法是《算法（第4版）》的合著者RobertSedgewick提出的。
归并排序是建立在归并操作上的一种有效的排序算法。
该算法是采用分治法（DivideandConquer）的一个非常典型的应用。
将已有序的子序列合并，得到完全有序的序列；
即先使每个子序列有序，再使子序列段间有序。
若将两个有序表合并成一个有序表，称为2-路归并。
5.1算法描述
▪把长度为n的输入序列分成两个长度为n/2的子序列；
▪对这两个子序列分别采用归并排序；
▪将两个排序好的子序列合并成一个最终的排序序列。
5.2动图演示
5.3代码实现
functionmergeSort（arr）{//采用自上而下的递归方法
if（len<
2）{
varmiddle=Math.floor（len/2）,
left=arr.slice（0,middle）,
right=arr.slice（middle）;
returnmerge（mergeSort（left）,mergeSort（right））;
functionmerge（left,right）{
varresult=[];
while（left.length>
0&
right.length>
0）{
if（left[0]<
=right[0]）="
"
{<
="
span="
>
result.push（left.shift（））;
}else{
result.push（right.shift（））;
while（left.length）
while（right.length）
returnresult;
5.4算法分析
归并排序是一种稳定的排序方法。
和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O（nlogn）的时间复杂度。
代价是需要额外的内存空间。
快速排序的基本思想：
通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
6.1算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。
▪从数列中挑出一个元素，称为“基准”（pivot）；
▪重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
在这个分区退出之后，该基准就处于数列的中间位置。
这个称为分区（partition）操作；
▪递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
6.2动图演示
6.3代码实现
functionquickSort（arr,left,right）{
partitionIndex,
left=typeofleft!
='
number'
?
0:
left,
right=typeofright!
len-1:
right;
if（left<
right）{
partitionIndex=partition（arr,left,right）;
quickSort（arr,left,partitionIndex-1）;
quickSort（arr,partitionIndex+1,right）;
functionpartition（arr,left,right）{//分区操作
varpivot=left,//设定基准值（pivot）
index=pivot+1;
for（vari=index;
=right;
i++）="
if（arr[i]<
arr[pivot]）{
swap（arr,i,index）;
index++;
swap（arr,pivot,index-1）;
returnindex-1;
functionswap（arr,i,j）{
vartemp=arr[i];
arr[i]=arr[j];
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。
堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：
即子结点的键值或索引总是小于（或者大于）它的父节点。
7.1算法描述
▪将初始待排序关键字序列（R1,R2….Rn）构建成大顶堆，此堆为初始的无序区；
▪将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区（R1,R2,……Rn-1）和新的有序区（Rn）,且满足R[1,2…n-1]<
=r[n]；
<
/=r[n]；
▪由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区（R1,R2,……Rn-1）调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区（R1,R2….Rn-2）和新的有序区（Rn-1,Rn）。
不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
7.2动图演示
7.3代码实现
varlen;
//因为声明的多个函数都需要数据长度，所以把len设置成为全局变量
functionbuildMaxHeap（arr）{//建立大顶堆
len=arr.length;
for（vari=Math.floor（len/2）;
i>
=0;
i--）{
heapify（arr,i）;
functionheapify（arr,i）{//堆调整
varleft=2*i+1,
right=2*i+2,
largest=i;
len&
arr[left]>
arr[largest]）{
largest=left;
if（right<
arr[right]>
largest=right;
if（largest!
=i）{
swap（arr,i,largest）;
heapify（arr,largest）;
functionheapSort（arr）{
buildMaxHeap（arr）;
for（vari=arr.length-1;
swap（arr,0,i）;
len--;
heapify（arr,0）;
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。
作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
8.1算法描述
▪找出待排序的数组中最大和最小的元素；
▪统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
▪对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
▪反向填充目标数组：
将每个元素i放在新数组的第C（i）项，每放一个元素就将C（i）减去1。
8.2动图演示
8.3代码实现
functioncountingSort（arr,maxValue）{
varbucket=newArray（maxValue+1）,
sortedIndex=0;
arrLen=arr.length,
bucketLen=maxValue+1;
arrLen;
if（!
bucket[arr[i]]）{
bucket[arr[i]]=0;
bucket[arr[i]]++;
bucketLen;
while（bucket[j]>
0）{
arr[sortedIndex++]=j;
bucket[j]--;
8.4算法分析
计数排序是一个稳定的排序算法。
当输入的元素是n个0到k之间的整数时，时间复杂度是O（n+k），空间复杂度也是O（n+k），其排序速度快于任何比较排序算法。
当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。
桶排序是计数排序的升级版。
它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
桶排序（Bucketsort）的工作的原理：
假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
9.1算法描述
▪设置一个定量的数组当作空桶；
▪遍历输入数据，并且把数据一个一个放到对应的桶里去；
▪对每个不是空的桶进行排序；
▪从不是空的桶里把排好序的数据拼接起来。
9.2图片演示
9.3代码实现
functionbucketSort（arr,bucketSize）{
if（arr.length===0）{
vari;
varminValue=arr[0];
varmaxValue=arr[0];
for（i=1;
arr.length;
minValue）{
minValue=arr[i];
//输入数据的最小值
}elseif（arr[i]>
maxValue）{
maxValue=arr[i];
//输入数据的最大值
//桶的初始化
varDEFAULT_BUCKET_SIZE=5;
//设置桶的默认数量为5
bucketSize=bucketSize||DEFAULT_BUCKET_SIZE;
varbucketCount=Math.floor（（maxValue-minValue）/bucketSize）+1;
varbuckets=newArray（bucketCount）;
for（i=0;
buckets.length;
buckets[i]=[];
//利用映射函数将数据分配到各个桶中
buckets[Math.floor（（arr[i]-minValue）/bucketSize）].push（arr[i]）;
arr.length=0;
insertionSort（buckets[i]）;
//对每个桶进行排序，这里使用了插入排序
buckets[i].length;
arr.push（buckets[i][j]）;
9.4算法分析
桶排序最好情况下使用线性时间O（n），桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O（n）。
很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。
但相应的空间消耗就会增大。
10、基数排序（RadixSort）
基数排序是按照低位先排序，然后收集；
再按照高位排序，然后再收集；
依次类推，直到最高位。
有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。
最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
10.1算法描述
▪取得数组中的最大数，并取得位数；
▪arr为原始数组，从最低位开始取每个位组成radix数组；
▪对radix进行计数排序（利用计数排序适用于小范围数的特点）；
10.2动图演示
10.3代码实现
//LSDRadixSort
varcounter=[];
functionradixSort（arr,maxDigit）{
varmod=10;
vardev=1;
maxDigit;
i++,dev*=10,mod*=10）{
for（varj=0;
varbucket=parseInt（（arr[j]%mod）/dev）;
if（counter[bucket]==null）{
counter[bucket]=[];
counter[bucket].push（arr[j]）;
varpos=0;
counter.length;
varvalue=null;
if（counter[j]!
=null）{
while（（value=counter[j].shift（））!
=null）{
arr[pos++]=value;
10.4算法分析
基数排序基于分别排序，分别收集，所以是稳定的。
但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O（n）的时间复杂度，而且分配之后得到新的关键字序列又需要O（n）的时间复杂度。
假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O（d*2n），当然d要远远小于n，因此基本上还是线性级别的。
基数排序的空间复杂度为O（n+k），其中k为桶的数量。
一般来说n>
k，因此额外空间需要大概n个左右。
升级会员 