八个常见的排序算法

排序算法

全篇采用的数据结构：

typedef int ElemType;
typedef struct{
	ElemType *elem;   //线性表头位置 
	int length;      //所存数据长度 
	int listsize;    //可存空间 
}SqList;
SqList L; 

冒泡排序

重复走完数组的所有元素，通过打擂台的方式两个两个比较，将最大/小的元素放到后面

int ListPopSort(SqList &L){
	int i,j,change;
	for(i=0;i<L.length-1;i++){
		for(j=0;j<L.length-i-1;j++){
			if(L.elem[j]>L.elem[j+1]){
				change=L.elem[j];
				L.elem[j]=L.elem[j+1];
				L.elem[j+1]=change;
			}
		}
	}
	return OK;
}

快速排序

以一个位置作为中枢，分别将大于/小于它的数放在一边，继续递归中枢左右的元素，直到递归的元素个数为0
时间复杂度：
最好情况：当每次中枢的位置都居中，则只需要O(nlogn)。
最坏情况：当元素正序/逆序时，选择第一个元素作为哨兵，所有元素都划分在一个序列中，需要O(n^2)。
改进：随机选取起始的哨兵。
空间复杂度：
因为递归使用栈，最好情况下进行logn次递归，为O(logn)
最坏情况：进行n-1次递归，为O(n)

int ListQuickSort(SqList &L,int low,int high){     
	L.length++;   //增加一位作为哨兵 
	int i,j;
	for(i=L.length-1;i>0;i--){ //依次后移将0空给哨兵 
		L.elem[i]=L.elem[i-1];
	}  
	L.elem[0]=L.elem[low];  //第一个元素为哨兵
	while(low<high){
		while(high>low && L.elem[0]<=L.elem[high]){  //从high开始，找到第一个比他小的元素，赋给low 
			high--;
		}
		L.elem[low]=L.elem[high];
		while(low<high && L.elem[0]>=L.elem[low]){   //从low开始，找到第一个比他大的元素，赋给high 
			low++;
		}
		L.elem[high]=L.elem[low];
	} 
	L.elem[low]=L.elem[0];   //最终low为分界线(中枢) 
	for(i=0;i<L.length-1;i++){  //删除哨兵 
		L.elem[i]=L.elem[i+1];
	}
	L.length--;
	return low;     
}  //获取中枢 
int QuickSort(SqList &L,int low,int high){ 
	int mid;//中枢 
	if(low<high){
		mid=ListQuickSortDesc(L,low,high);
		QuickSort(L,low,mid-1);//对前半部分排序 
		QuickSort(L,mid+1,high);//对后半部分排序 
	}
	return OK;
}  //递归函数，不停划分两个部分，直到low=high

插入排序

a[0]为哨兵。从头到尾比较，若a[i-1]>a[i]，则a[0]=a[i]，a[i]=a[i-1]，从i-1往前找到适当的位置将a[0]插入进去，后面的元素依次往后移。

int ListSort(SqList &L){
	L.length++;   //增加一位作为哨兵 
	int i,j;
	for(i=L.length-1;i>0;i--){ //依次后移将0空给哨兵 
		L.elem[i]=L.elem[i-1];
	}  
	for(i=2;i<L.length;i++){
		if(L.elem[i-1]>L.elem[i]){
			L.elem[0]=L.elem[i]; //将后面那个放入哨兵
			L.elem[i]=L.elem[i-1];  
			for(j=i-1;L.elem[0]<L.elem[j];j--){ // 从当前位置一直往前移，将小的数放到比它小的数后面 
				L.elem[j]=L.elem[j-1];  
			} 
			L.elem[j+1]=L.elem[0];  //插入 
		}
	} 
	for(i=0;i<L.length-1;i++){  //删除哨兵 
		L.elem[i]=L.elem[i+1];
	}
	L.length--;
	return OK;
} 

希尔排序

插入排序的改进，不再是每次只插入一个，而是以gap作为间隔，将原本数组划分为gap个序列(序列中的元素像个gap)。每个序列中再使用插入排序。不断折半gap，直到gap为0(序列中元素个数为1)。

int ShellSort(SqList &L) {
	int gap = L.length/2;   // 将数组分为多少个序列 
	int i,j,k,temp;
	while(gap>0) {
		for(i=0;i<gap;i++) {   // 遍历每一个序列
			for(j=gap+i;j<L.length;j+=gap) {  // 遍历序列中的元素，使用插入排序 
				if(L.elem[j]<L.elem[j-gap]) {  // 若当前元素比该序列的上一个元素小 
					temp = L.elem[j]; 
					k = j-gap;
					while(k>=0 && L.elem[k]>temp) {   // 将当前元素插入到前面的适当位置 
						L.elem[k+gap] = L.elem[k];
						k-=gap;
					}
					L.elem[k+gap] = temp;
				}
			} 
		}
		print(L);
		gap/=2;
	}
	return OK;
}

选择排序

循环列表，每次选择当前最小的元素，与最前面/最后面元素交换。

int SelectSort(SqList &L) {
	int i,j,low,low_index;
	for(i=0;i<L.length-1;i++) {
		low = L.elem[i];
		low_index = i;
		for(j=i+1;j<L.length;j++) {
			if(low>L.elem[j]) {
				low = L.elem[j];
				low_index = j;
			}
		}
		if(low_index != i) {
			L.elem[low_index] = L.elem[i];
			L.elem[i] = low;	
		}
	}
	return OK;
}

堆排序

堆排序是针对完全二叉树
每个结点都大于其左右子树的结点——大顶堆
每个结点都小于其左右子树的结点——小顶堆
堆排序的基本思想：将远程序列建立成堆，输出堆顶元素，调整剩余元素使之成堆，直到所有元素成堆
堆排序的操作：

• 堆化Heapify
  对于高度为2的一棵树，使之成为大顶堆/小顶堆
• 创建堆BuildHeap
  从树的倒数第二层(最底层的树)开始，一直往上做堆化操作
• 堆排序
  将序列建立成堆，输出根结点，将根结点和最后一个结点交换(相当于删除根结点)，重新堆化，重复，直到没有结点

ElemType heap[INIT_SIZE];   // 堆数组，因为堆是完全二叉树，所以可以用顺序存储 
int Heapify(ElemType heap[], int n, int i) {
	int max = i;
	int c1 = 2 * i + 1;   // 左子树下标(因为树的下标是从0开始存储)
	int c2 = 2 * i + 2;   // 右子树下标
	if(c1 < n && heap[c1] > heap[max]) {
		max = c1;
	} 
	if(c2 < n && heap[c2] > heap[max]) {
		max = c2;
	}
	if(max != i) {
		swap(heap, max, i);
		Heapify(heap, n, max);  // 递归堆化交换了结点的子树 
	}
} // 堆化(大顶堆)
int BuildHeap(ElemType heap[], int n) {
	int i, parent;
	// 从最后一个节点开始，不断堆化该结点父节点作为根的树 
	for(i = n - 1; i >= 0; i--) {
		parent = (i - 1) / 2;   // 父节点的下标 
		Heapify(heap, n, parent); 
	}
} // 创建堆 
int HeapSort(ElemType heap[], int n) {
	BuildHeap(heap, n);
	int i;
	printf("堆排序：\n");
	for(i = n - 1; i > 0; i--) {
		swap(heap, i, 0);     // 交换顶点与树的最后一个元素 
		Heapify(heap, i, 0);  // 树的元素个数为i 
	}
}

归并排序

不断将列表划分为一半，再不断合并，在合并的过程中排序。

void MergeTwoList(SqList &L,int left,int mid,int right) {
	int i=left,j=mid+1,k=0;
	ElemType temp[L.length] = {0};
	while(i<=mid && j<=right) {
		if(L.elem[i]<=L.elem[j]) {
			temp[k++] = L.elem[i++];
		} else {
			temp[k++] = L.elem[j++];
		}
	}
	//若某个序列还没有加完
	while(i<=mid) {
		temp[k++] = L.elem[i++];
	} 
	while(j<=right) {
		temp[k++] = L.elem[j++];
	}
	// 将temp中的元素放入L中
	for(i=0;i<k;i++) {
		L.elem[i+left] = temp[i];
	} 
	print(L);
} // 合并排序L[left..mid]和L[mid,right]
void Merge(SqList &L,int left,int right) {
	if(left<right) {
		int mid = (left+right)/2;
		Merge(L,left,mid);
		Merge(L,mid+1,right);
		MergeTwoList(L,left,mid,right);
	} 
} // 使用递归合并排序整个数组 
int MergeSort(SqList &L) {
	Merge(L,0,L.length-1);
	return OK;
}

基数排序

借助多关键字排序的思想对单逻辑关键字进行排序的方法
基本思想：分配、收集
也称为桶排序或箱排序：设置若干个箱子，将关键字为k的记录放入第k个箱子，然后在按序号将非空的连接
时间复杂度：O(d(r+n))，其中d为关键字个数个数(即需要分配收集的次数)、r为关键字的取值范围(即每一次需要多少个桶，需要收集的次数)，n为需要排序对象的个数(收集的次数)
空间复杂度：O(rd+n)，n用于存储排序的对象，d为关键字个数(桶的个数)，r为关键字取值范围(桶的大小)

int GetNumInPos(int num,int pos) {
	int temp = 1;
	for (int i = 0; i < pos - 1; i++)
		temp *= 10;
	return (num / temp) % 10;
} // 找到num的从低到高的第pos位的数据
void RadixSort(SqList &L, int n){
	int *radixArrays[RADIX_10];    //分别为0~9的序列空间
	for (int i = 0; i < 10; i++) {
		radixArrays[i] = (int *)malloc(sizeof(int) * (n + 1));
		radixArrays[i][0] = 0;    //index为0处记录这组数据的个数(这列桶中装的数据个数) 
	}
	for (int pos = 1; pos <= KEYNUM; pos++) {   //从个位开始到最高位数
		for (int i = 0; i < n; i++) {   //分配过程
			int num = GetNumInPos(L.elem[i], pos);
			int index = ++radixArrays[num][0];
			radixArrays[num][index] = L.elem[i];
		}
		for (int i = 0, j =0; i < RADIX_10; i++) {    //收集
			for (int k = 1; k <= radixArrays[i][0]; k++)
				L.elem[j++] = radixArrays[i][k];
			radixArrays[i][0] = 0;    //复位
		}
	}
} 

各算法之间的比较

时空复杂度

算法思路总结

排序方法	排序思想(以升序为例)
直接插入	a[0]为哨兵。从头到尾比较，若a[i-1]>a[i]，则a[0]=a[i],a[i]=a[i-1]，从i-1往前找到适当的位置将a[0]插入进去，后面的元素依次往后移。当数据本身有序则为最好情况。但是插入排序一次只能操作一个元素，改进：希尔排序。
希尔排序	将元素分为gap个序列，序列中元素之间相隔gap。初始gap一般为n/2，每个序列内使用插入排序。排序完后，gap/2，重新分序列并排序，直到gap为0(一个元素为一个序列)则结束。
直接选择	不断选择小的元素放到前面。循环列表元素，将每次循环的第一个元素作为哨兵，比较后面的元素，找到小于哨兵的最小元素与哨兵交换。即使序列有序，时间复杂度也是O(n^2)
推排序	将数组构建成大顶堆(完全二叉树用数组存储)，将堆顶元素与最小元素交换，重新堆化，循环操作n次后即有序。堆化操作：比较左右子树结点元素和根结点元素，若最大元素不再根处，则交换，继续递归堆化交换了的那个子树。
冒泡选择	一共进行n轮。每一轮从头到尾不断比较，将大的数放到最后。当数据原本就有序则为最好情况。改进：不一定进行n轮，当某一轮中没有数据改变，则说明已经排序完毕。
快速排序	确定中枢，从两边往中间比较，将小的元素放到前面，大的元素放到后面。记录中枢位置，中枢以前都小于中枢，中枢以后都大于中枢。然后分别递归快排中枢前面和后面的元素。直到最终快排元素个数为0。
归并排序	不断将数组划分为子数组，直到最终一个元素为一个数组。然后再两两合并，合并的过程中排序，直到最终合并为一个数组。
基数排序	将排序的对象划分为多个关键字，根据不同关键字，将对象分配到对应的桶中，然后再根据桶重新收集到数组中。直到对所有的关键字进行一次分配收集。