排序算法的稳定性不能衡量一个算法的优劣,主要是对算法的性质进行描述。
插入排序
若序列基本有序,插入排序简单有效
直接插入排序
依次将元素插入已排好序的序列中
void InsertSort(ElemType A[],int n){
int i,j;
for(i=2;i<=n;i++){
if(A[i].key<A[i-1].key){
A[0]=A[i]; //A[0]为哨兵
for(j=i-1;A[0].key<A[j].key;--j){
A[j+1]=A[j];
}
A[j+1]=A[0];
}
}
}
空间复杂度O(1)
时间复杂度O(n²)
直接排序算法是一个稳定的排序算法,适用于顺序存储和链式存储的线性表。
折半插入排序
void InsertSort(ElemType A[],int n){
int i,j,low,high,mid;
for(i=2;i<=n;i++){
low=1;
high=i-1;
while(low<=high){
mid=(low+high)/2;
if(A[mid].key>A[0].key){
high=mid-1;
}
else{
low=mid+1;
}
}
for(j=i-1lj>=high+1;--j){
A[j+1]=A[j];
}
A[high+1]=A[0];
}
}
折半插入排序减少了比较元素的次数,是一种稳定的排序算法
时间复杂度O(n²)
希尔排序
又称缩小增量排序
将排序表分割成形如L[i,i+d,i+2d…i+kd]的子表,分别进行直接插入排序,当整个表中的元素已呈“基本有序”时,再对全体记录进行一次直接插入排序。
void ShellSort(ElemType A[],int n){
for(dk=n/2;dk>=1;dk=dk/2){
for(i=dk+1;i<=n;++i){
if(A[i].key<A[i-dk].key){
A[0]=A[i]; //暂存于A[0]
for(j=i-dk;j>0&&A[0].key<A[j].key;j-=dk){
A[j+dk]=A[j]; //记录后移,查找插入的位置
}
A[j+dk]=A[0];
}
}
}
}
空间复杂度O(1)
时间复杂度不固定
希尔排序是一种不稳定的排序方法,仅适用于线性表顺序存储的情况
交换排序
冒泡排序
从后往前两两比较相邻元素的值,若为逆序则交换它们,直到序列比较完,称为一趟冒泡排序。最多做n-1趟冒泡。
void BubbleSort(ElemType A[],int n){
for(i=0;i<n-1;i++){
flag=false; //本趟冒泡排序是否发生交换
for(j=n-1;j>1;j--){
if(A[j-1].key>A[j].key){
swap(A[j-1],A[j]);
flag=true;
}
}
if(flag==false){
return;
}
}
}
空间复杂度O(1)
时间复杂度O(n²)
冒泡排序是一种稳定的排序方法,每趟排序都会将一个元素放置到其最终的位置上
快速排序
基于分治法。从待排序列中任取一个元素作为基准,通过一趟排序使得基准左边的元素小于基准,右边的元素大于等于基准,而后递归对两个子表重复上述过程,直到每部分内只有一个元素或为空。
//一趟排序过程
int Paetition(ElemType A[],int low,int high){
ElemType pivot=A[low]; //将表中第一个元素作为基准
while(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(ElemType 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
(
l
o
g
2
n
)
O(log_2n)
O(log2n)
时间复杂度平均情况下
O
(
n
l
o
g
2
n
)
O(nlog_2n)
O(nlog2n),是所有内部排序算法中平均性能最优的排序算法
快速排序是一种不稳定的排序方法。每趟排序后会将一个元素放到其最终位置上。
(1)利用快速排序的思想,将最小的n/2个元素放在A1,其余放在A2。
设基准位置为i,若i=n/2,分组完成;若i<n/2,则基准及之前元素均属于A1,继续对i之后的元素进行划分;若i>n/2,则基准及之后的元素均属于A2,继续对i之前的元素进行划分。
(2)
int Partition(int A[],int n){
int pivot,low=0,low0=0,high=n-1,high0=n-1,flag=1,k=n/2,i;
int s1=0,s2=0;
while(flag){
pivot=A[low];
while(low<high){
while(low<high&&A[high]>=povit){--high;}
A[low]=A[high];
while(low<high&&A[low]<=povit){++low;}
A[high]=A[low];
}
A[low]=pivot;
if(low==k-1){ //划分成功
flag=0;
}
else{
if(low<k-1){
low0=++low;
high=high0;
}
else{
high0=--high;
low=low0;
}
}
}
for(i=0;i<k;i++){s1+=A[1];}
for(i=k;i<n;i++){s2+=A[i];}
return s2-s1;
}
(3)时间复杂度O(n),空间复杂度O(1)
选择排序
简单选择排序
第i趟排序从L[i,…n]中选择关键字最小的元素与L(i)交换,每趟排序可以确定一个元素的最终位置
void SelectSort(ElemType A[],int n){
for(int i=0;i<n-1;i++){
min=i; //记录最小元素的位置
for(j=i+1;j<n;j++){
if(A[j]<A[min]){
min=j;
}
if(min!=i){
swap(A[i],A[min]);
}
}
}
}
空间复杂度O(1)
时间复杂度O(n²)
简单选择排序是一种不稳定的排序方法
堆排序
堆排序是一种树形选择排序方法。关键是构造初始堆,对有n个结点的二叉树,依次从第n/2个结点开始筛选(对大根堆,若根结点关键字小于左右孩子的较大者则交换)
//建立大根堆
void BuildMaxHeap(ElemType A[],int len){
for(int i=len/2;i>0;i--){
AdjustDown(A,i,len);
}
}
void AdjustDown(ElemType A[],int k,int len){
A[0]=A[k];
for(i=2*k;i<=len;i*=2){
if(i<len&&A[i]<A[i+1]){ //得到较大子结点的下标
i++;
}
if(A[0]>=A[i]){
break;
}
else{
A[k]=A[i];
k=i;
}
}
A[k]=A[0];
}
时间复杂度为O(n)
堆排序算法:
void HeapSort(ElemType A[],int len){
BuildMaxHeap(A,len);
for(i=len;i>1;i--){
Swap(A[i],A[1]); //和堆底元素交换 输出堆顶元素
AdjustDown(A,1,i-1);
}
}
空间复杂度
O
(
1
)
O(1)
O(1)
时间复杂度
O
(
n
l
o
g
2
n
)
O(nlog_2n)
O(nlog2n)
堆排序是一种不稳定的排序方法
归并排序
将两个或两个以上的有序表组合成一个新的有序表
ElemType *B=(ElemType *)malloc(n+1)*sizeof(ElemType); //辅助数组
void Merge(ElemType A[],int low,int mid,int high){
for(int k=low;k<=high;k++){
B[k]=A[k];
}
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++];
}
}
while(i<=mid){
A[k++]=B[i++];
}
while(j<=high){
A[k++]=B[j++];
}
}
void MergeSort(ElemType 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);
}
}
空间复杂度
O
(
n
)
O(n)
O(n)
时间复杂度
O
(
n
l
o
g
2
n
)
O(nlog_2n)
O(nlog2n)
2路归并排序是一种稳定的排序方法
基数排序
多关键字排序思想
空间复杂度O®
时间复杂度O(d(n+r)),与序列的初始状态无关。
外部排序
外部排序指待排序文件较大,内存一次性放不下,需存放在外部介质中。在排序过程中需要多次进行内存和外存之间的交换。
外部排序通常采用归并排序法。根据内存缓冲区的大小,将外存上含n个记录的文件分成若干长度为h的子文件,依次读入内存并利用有效的内部排序方法对它们进行排序,并将排序后的有序子文件(归并段)重新写回外存,然后对这些归并段进行逐趟归并,直到得到整个有序文件为止。
要提高外部排序的速度,应着力减少I/O次数
多路平衡归并与败者树
增加归并路数m可以减少归并趟数S,进而减少访问内存的次数(I/O次数)。但增加归并路数内部归并的时间将增加。
为了使内部归并不受m增大的影响,引入败者树,可视为一棵完全二叉树。叶结点存放各归并段在归并过程中当前参加比较的记录,内部结点用来记忆左右子树中的“失败者”,胜者继续向上比较,一直到根结点。
置换-选择排序(生成初始归并段)
减少初始归并段个数r也可以减少归并趟数S
最佳归并树
文件经过置换-选择排序后得到长度不等的初始归并段。
m路归并排序可用一棵m叉树描述,利用哈夫曼树的思想,在归并树中,记录数少的初始归并段最先归并,记录数多的归并段最晚归并,就可以建立总的I/O次数达到最少的最佳归并树。
总结
时间复杂度:
- O ( n 2 ) O(n²) O(n2):简单选择排序、直接插入排序、冒泡排序。实现过程简单,直接插入排序和冒泡排序最好情况下时间复杂度 O ( n ) O(n) O(n),简单选择排序与序列的初始状态无关
- O ( n l o g 2 n ) O(nlog_2n) O(nlog2n):堆排序、快速排序、归并排序。快速排序最坏情况下时间复杂度 O ( n 2 ) O(n²) O(n2)
- 希尔排序对较大规模的排序都可以达到很高的效率,但未得出精确的渐进时间
空间复杂度:
- O ( 1 ) O(1) O(1):简单选择排序、插入排序、冒泡排序、希尔排序、堆排序
- O ( l o g 2 n ) O(log_2n) O(log2n):快速排序,最坏情况下 O ( n ) O(n) O(n)
- O ( n ) O(n) O(n):2路归并排序
稳定性:
- 插入排序、冒泡排序、归并排序、基数排序是稳定的排序方法
- 简单选择排序、快速排序、希尔排序、堆排序是不稳定的排序方法