本文深入讲解了各种排序算法，包括插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序、归并排序及基数排序等。详细分析了各种算法的时间和空间复杂度，并提供了算法代码实现。
前言
本章主要详解了排序的常规算法总结，以及相关排序算法的时间和空间复杂度分析。其中包括插入排序及其与优化算法，希尔排序、交换排序（冒泡排序、快速排序）、选择排序（简单选择排序、堆排序）、归并排序和基数排序，外部排序及其优化算法（引入败者树和最佳归并树）等详细的排序算法代码实现等内容。
文章目录
插入排序
算法思想:每次将一个待排序的记录按其关键字大小插入到前面已排好序的子序列中,直到全部记录插入完成。
//直接插入排序
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]; //用temp暂存A[i]
for(j=i-1;j>=0 && A[j]>temp;--j) //检查所有前面已排好序的元素
A[j+1]=A[j]; //所有大于temp的元素都向后挪位
A[j+1]=temp; //复制到插入位置
}
}
空间复杂度: 0(1)
最好时间复杂度(全部有序) : O(n)
最坏时间复杂度(全部逆序) : O(n2)
平均时间复杂度: O(n2)
算法：稳定
优化—折半插入排序
思路:先用折半查找找到应该插入的位置,再移动元素。
当low>high时折半查找停止,应将[low, i-1]内的元素全部右移,并将A[0]复制到low所指位置。
//折半插入排序(使用哨兵模式，A[0]为哨兵位置)
void InsertSort(int A[],int n){
int i,j, low,high,mid;
for(i=2;i<=n; i++){ //依次将A[2]~A[n]插入前面的巳排序序列
A[0]=A[i]; //将A[i}暂存到A[0]
Low=1; high=i-1; //设置折半直找的范围
while(low<=high){ //折半查找(默认递增有序)
mid=(low+high)/2; //取中间点
if (A[mid]>A[0])
high=mid-1; //查找左半子表
else
low=mid+1; //查找右半子表
}
for(j=i-1;j>=high+1;--j)
A[j+1]=A[j]; //统一后移元素,空出插入位置
A[low]=A[0]; //插入操作
}
}
平均时间复杂度: O(n2)
希尔排序
希尔排序：先将待排序表分割成若干形如L[i, i+d, i+2d…i+kd]的"特殊”子表,对各个子表分别进行直接插入排序。缩小增量d,重复上述过程,直到d=1为止。
//希尔排序
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]){ //需将A1i]插入有序增量子表
A[0]=A[i];//暂存在A[0]
for(j= i-d; j>0 && A[0]<A[j]; j-=d)
A[j+d]=A[j];//记录后移,查找插入的位置
A[j+d]=A[0];//插入
}//if
}
希尔排序仅适用于顺序表。
平均时间复杂度: 在一定情况下，可以达到O(n1.3) ~ O(n2)
交换排序
基于“交换”的排序:根据序列中两个元素关键字的比较结果来对换这两个记录在序列中的位置。
冒泡排序
从后往前(或从前往后)两两比较相邻元素的值,若为逆序(即A[i-1]>A[i]) ,则交换它们,直到序列比较完。称这样过程为“一趟"冒泡排序。
//交换
void swap(int &a, int sb){
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==false)
return;//本趟遍历后没有发生交换，说明表已经有序
}
}
平均时间复杂度: O(n2)
快速排序
算法思想:在街排序表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]上,这个过程称为一次“划分”。然后分别递归地对两个子表重复上述过程,直至每部分内只有一个元素或空为止,即所有元素放在了其最终位置上。
int Partition (int A[],int low,int high){
int pivot=A[low];//第一个元素作为枢轴
while(low<high){//用low,high搜索枢轴的最终位置
while(low<high&&A[high]>=pivot)--high;
A[Low]=A[high];//比枢轴小的元素移动到左端
while( low<high&&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, pivotpos-1); //划分左子表
QuickSort(A, pivotpos+1,high); //划分右子表
}
}
最好时间复杂度=O(nlog2n)
最坏时间复杂度=O(n2)
选择排序
选择排序:每一趟在待排序元素中选取关键字最小(或最大)的元素加入有序子序列。
简单选择排序
每一趟在待排序元素中选取关键字最小的元素加入有序子序列。
//交换
void swap(int &a, int &b){
int temp =a;
a = b;
b = temp;
}
//简单选择排序
void SelectSort (int Al],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..-]中选择最小的元素
if (A[j] <A[min]) //更新最小元素位置
min=j;
if (min!=i) //封装的swap()函数共移动元素3次
swap(A[i],A[min]);
}
}
空间复杂度: 0(1)
时间复杂度:O(n2)
稳定性：不稳定
堆排序
若n个关键字序列L[1…n]满足下面某一条性质,则称为堆(Heap) :
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jNofkes1-1601025830923)(F:\考研专用\数据结构与算法\数据结构笔记\129.PNG)]
①若满足: L(i)≥L(2i)且L(i)≥L(2i+1) (1≤i≤n/2)–大根堆(大顶堆)
②若满足: L(i)≤L(2i)且L(i)≤L(2i+1) (1≤i≤n/2)–小根堆(小顶堆)
建立大根堆：
大根堆:根>左、右思路:把所有非终端结点都检查一遍,是否满足大根堆的要求,如果不满足,则进行调整。
检查当前结点是否满足根≥左、右若不满足,将当前结点与更大的一个孩子互换。
•i的左孩子 --2i
•i的右孩子 --2i+1
•i的父节点 --[i/2]
//建立大根堆
void BuildMaxHeap(int Al],int len){
for(int i=len/2;i>0;1--) //从后往前调整所有非终端结点
HeadAdjust(A, i, len);
}
//将以k为根的子树调整为大根堆
void HeadAdjust(int A[],int k,int len){
A[0]=A(k];//A0暂存子树的根结点
for(int i=2*k; i<=len; i*=2){ //沿key较大的子结点向下筛选
if(i<len&&A[i]<A[i+1])
i++;
if (A[0]>=A[i]) break; //筛选结束//取key较大的子结点的下标
else{
A[K]=A[i];//将A[ij调整到双亲结点上
k=i;//修改k值，以便继续向下筛选
}
}
A[k]=A[0];//被筛选结点的值放入最终位置
}
//堆排序的完整逻辑
void HeapSort(int All,int len){
BuildMaxHeap (A, len);//初始建堆
for (int i=len; ix1; i--){ //n-1和建过程
swap(A[i],A[1]);//堆顶元素和堆底元素交换
HeadAdjust (A, 1, i-1); //把剩余的a排序元素整理成堆
}
}
【注意】：下方有两个孩子,则"下坠"1一层,需对比关键字2次；下方只有一个孩子,则"下坠"一层,只需对比关键字1次。
建堆时间复杂度=O(n)
排序时间复杂度=O(nlog2n)
总时间复杂度=O(nlog2n)
稳定性：堆排序是不稳定的。
在小根堆中插入新元素：
•i的左孩子 --2i
•i的右孩子 --2i+1
•i的父节点 --[i/2]
对于小根堆,新元素放到表尾,与父节点对比,若新元素比父节点更小,则将二者互换。新元素就这样一路“上升",直到无法继续上升为止。
在大根堆中插入新元素：
被删除的元素用堆底元素替代,然后让该元素不断“下坠",直到无法下坠为止。
归并排序
归并:把两个或多个已经有序的序列合并成一个。
int *B=(int *)malloc(n*sizeof (int)); //辅助数组B
//A[low.midj和A [mid+1..high)各自有序,将两个部分归并
void Merge(int Al],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&&j<=high; k++){
if (B[i]<=B[j])
A[k]=B[i++];//将较小值复制到A中
else
A[k]=B[j++];
}//for
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); //归并
}//if
}
结论:n个元素进行2路归并排序,归井趟数=[log2n],每趟归并时间复杂度为0(n),则算法时间复杂度为O(n log2n)，空间复杂度为O(n)。
基数排序
基数排序的算法
基数排序得到递减序列的过程如下,
初始化：设置r个空队列, Q r-1, Q r-2…, Q o
按照各个关键字位权重递增的次序(个、十、百) ,对d个关键字位分别做“分配”和"收集”
分配:顺序扫描各个元素,若当前处理的关键字位=x,则将元素插入Q x队尾
收集:把Q r-1, Q r-2., Q 0各个队列中的结点依次出队并链接
以下为示例：
基数排序,时间复杂度=O(d(n+r))，稳定性：稳定。
基数排序擅长解决的问题:
①数据元素的关键字可以方便地拆分为d组,且d较小
②每组关键字的取值范围不大,即r较小
③数据元素个数n较大
外部排序
败者树
多路平衡归并带来的问题：
外部排序时间开销=读写外存的时间+内部排序所需时间+内部归并所需时间
归并趙数S=[log k r],归井路数k增加,归并趟数S减小,读写磁盘总次数减少。
使用k路平街归并策略,选出一个最小元素需要对比关键字(k-1)次,导致内部归并所需时间增加。
败者树的构造：
败者树在多路平衡归并中的应用：
置换选择排序
置换选择排序的目的：按照该方法生成初始归并段,进一步减少初始归并段数量。（原初始化方法：若共N个记录,内存工作区可以容纳L个记录,则初始归并段数量r=[N/L]）。
置换选择排序的算法：
设初始待排文件为FI,初始归并段输出文件为FO,内存工作区为WA, FO和WA的初始状态为空, WA可容纳w个记录。置换选择算法的步骤如下:
1)从FI输入w个记录到工作区WA.
2)从WA中选出其中关键字取最小值的记录,记为MINIMAX记录。
3)将MINIMAX记录输出到FO中去。
4)若F不空,则从FI输入下一个记录到WA中。
5)从WA中所有关键字比MINIMAX记录的关键字大的记录中选出最小关键字记录,作为新的MINIMAX记录。
6)重复3) ~5) ,直至在WA中选不出新的MINIMAX记录为止,由此得到一个初始归并段,输出一个归并段的结束标志到FO中去。
7)重复2) ~6) ,直至WA为空。由此得到全部初始归并段。
最佳归并树
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
