【数据结构知识点总结】七、排序

排序算法的稳定性不能衡量一个算法的优劣，主要是对算法的性质进行描述。

插入排序

若序列基本有序，插入排序简单有效

直接插入排序

依次将元素插入已排好序的序列中

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(lo{g}_{2}n)$
时间复杂度平均情况下$O(nlo{g}_{2}n)$，是所有内部排序算法中平均性能最优的排序算法
快速排序是一种不稳定的排序方法。每趟排序后会将一个元素放到其最终位置上。

(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(nlo{g}_{2}n)$
堆排序是一种不稳定的排序方法

归并排序

将两个或两个以上的有序表组合成一个新的有序表

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(nlo{g}_{2}n)$
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(nlo{g}_{2}n)$：堆排序、快速排序、归并排序。快速排序最坏情况下时间复杂度$O(n^2)$
• 希尔排序对较大规模的排序都可以达到很高的效率，但未得出精确的渐进时间

空间复杂度：

• $O(1)$：简单选择排序、插入排序、冒泡排序、希尔排序、堆排序
• $O(lo{g}_{2}n)$：快速排序，最坏情况下$O(n)$
• $O(n)$：2路归并排序

稳定性：

• 插入排序、冒泡排序、归并排序、基数排序是稳定的排序方法
• 简单选择排序、快速排序、希尔排序、堆排序是不稳定的排序方法