摘要
排序操作在程序设计中是非常基础和常见的,也是算法的基础部分,我对几种常见的比较排序算法进行了整理。
暴力排序(violence sort)
思想:遍历数组,每次遍历都在未排序的部分找到最小元素的下标,在此次遍历结束后将最小元素放到遍历开始的位置。
性能:时间复杂度为O(n2),算法比较次数与初始序列状态无关,性能在所有排序算法中最差。
void Violence_Sort(int* A, int len){ for(int i=0;i<len;i++) { int k = i; for(int j=i;j<len;j++) if(A[j]<A[k]) k = j; if(k != i){ int t = A[i]; A[i] = A[k]; A[k] = t; } } }
插入排序(insert sort)
思想: 将当前元素与它前面已排好序的元素依次进行比较,最后放置在合适的位置,初始时可从第二个元素开始,认为第一个元素已排好序。
性能:算法时间复杂度为O(n2),在序列规模较小时,性能比较好,且元素比较次数与初始序列杂乱程度相关,最优复杂度为O(n)。
void Insert_Sort(int* A, int len){ for(int i=1;i<len;i++) { int key = A[i]; int j = i - 1; while(j >= 0 && key < A[j]){ A[j+1] = A[j]; j--; } A[j+1] = key; } }
冒泡排序(bubble sort)
思想:从左往右遍历,比较相邻两个元素的大小,将大的一个放在后面,每遍历一趟,可找到一个最大值放置在最后,经过n-1趟遍历即可。
性能:时间复杂度为O(n2),元素比较次数与初始状态无关,性能略低于插入排序。
void Bubble_Sort(int* A,int len){ for(int i=1;i<len;i++) for(int j=0;j<len-i;j++) { if(A[j]>A[j+1]){ int t = A[j+1]; A[j+1] = A[j]; A[j] = t; } } }
归并排序(merge sort)
思想:使用分治思想,将原始序列分为两部分分别排序,然后合并,重点在于合并过程。
性能:时间复杂度为O(nlgn),不过合并过程会使用额外的存储空间,占用内存。
void Merge(int* A, int low, int mid, int high){ int left[mid-low+1],right[high-mid]; int sentry = A[mid]>A[high]?(A[mid]+1):(A[high]+1); int l = 0; int r = 0; int i; for(i=0;i<mid-low+1;i++) left[i] = A[low+i]; left[i] = sentry;//添加哨兵 for(i=0;i<high-mid;i++) right[i] = A[mid+1+i]; right[i] = sentry;//添加哨兵 for(int i=low;i<=high;i++) if(left[l] <= right[r]) A[i] = left[l++]; else A[i] = right[r++]; } void Merge_Sort(int* A, int low, int high){ if(high > low){ int mid = (low+high)/2; Merge_Sort(A, low, mid); Merge_Sort(A, mid+1, high); Merge(A, low, mid, high); } }
快速排序(quick sort)
思想:与归并排序类似,也使用分治思想,选择一个元素值(一般选择最后一个元素),将比它小的放在左边部分,比它大的放在右边,然后对两部分分别进行上述操作知道递归结束,关键步骤在于元素的分类,且只占用O(1)的额外存储空间。
性能:时间复杂度为O(nlgn),与归并排序不同,该算法占用常数级额外存储,在大规模序列排序应用中性能较好。
int Partition(int* A, int low, int high){ int key = A[high]; int i = low; for(int j=low;j<high;j++) if(A[j]<=key){ int t = A[j]; A[j] = A[i]; A[i] = t; i++; } A[high] = A[i]; A[i] = key; return i; }//对数组元素进行移位分类,key的左边都<=key,右边都>key。返回key的下标。
void Quick_Sort(int* A, int low, int high){ if(low >= high) return; int k = Partition(A, low, high); Quick_Sort(A, low, k-1); Quick_Sort(A, k+1, high); }
堆排序(heap sort)
思想:使用堆数据结构进行排序,堆是一种用数组存储的二叉树,根据父节点和子节点的大小关系分为最大堆和最小堆,这里使用最大堆进行排序。
性能:时间复杂度为O(nlgn),在实际使用中,堆排序的排序性能通常逊与快速排序。
void Max_Heapify(int* A, int i,int size){ int l = 2*i; int r = 2*i + 1; int large = i; if(l <= size && A[l] > A[i]) large = l; else large = i; if(r <= size && A[r] > A[large]) large = r; if(large != i){ int t = A[large]; A[large] = A[i]; A[i] = t; Max_Heapify(A, large, size); } } void Build_Max_Heap(int* A, int size){ for(int i=size/2;i>0;i--) Max_Heapify(A,i,size); } void Heap_Sort(int* A, int len){ Build_Max_Heap(A, len); while(len-1){ int t = A[1]; A[1] = A[i]; A[i] = t; len--; Max_Heapify(A,1,len); } }