1、冒泡排序
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//冒泡排序 void bubbleSort(int A[], int n) { bool flag = false; for (int i = n - 1; i > 0; i--) { //注意i,j的终止条件 for (int j = 0; j < i; j++) { if (A[j]>A[j + 1])swap(A[j], A[j + 1]); flag = true; } if (flag == false)return; } }
(上面代码有误,交换和改变flag值应有大括号)
最差时间复杂度 O(n²) 记录是反序的,需要n-1次扫描,每趟扫描进行n-i次比较,每次比较都要移动3次
最优时间复杂度 O(n) 记录是正序的,一趟扫描即可完成,比较n-1次
平均时间复杂度 O(n²)
虽然冒泡排序不一定进行n-1趟,但记录移动次数多,故平均时间性能比直接插入排序差
最差空间复杂度 O(1)
优点:稳定;
缺点:慢,每次只能移动相邻两个数据
2、插入排序
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//插入排序 void insertSort(int A[], int n) { for (int i = 1; i < n; i++) { //注意j从i-1开始 for (int j = i - 1; j >= 0;j--) if (A[i] < A[j]) swap(A[i], A[j]); } }
最差时间复杂度 O(n²)最优时间复杂度 O(n)平均时间复杂度 O(n²)最差空间复杂度 O(n) total, O(1) auxiliary
3、希尔排序
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//希尔排序 void shellSort(int A[], int n) { int incrment = n; do{ incrment = n / 3 + 1; shellPass(A, n, incrment); } while (n >= 1); } void shellPass(int A[], int n, int d) { for (int i = d; i < n;i++) for (int j = i - d; j >= 0 && A[j]>A[i]; j -= d)//注意j每次自减d,A[j]>A[i]放在判断条件效率更高 { swap(A[i], A[j]); } }
希尔排序实际上是一种插入排序, 它的时间复杂度和数组初始排序有关。
平均时间复杂度:O(nlogn)
空间复杂度:O(1)
优点:快,数据移动少;
缺点:不稳定,d的取值是多少,应取多少个不同的值,都无法确切知道,只能凭经验来取。
4、选择排序
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//选择排序 void selectSort(int A[], int n) { for (int i = 0; i < n - 1;i++) for (int j = i + 1; j < n; j++) { if (A[i]>A[j]) swap(A[i], A[j]); } }
和冒泡排序的思想类似。
最差时间复杂度 О(n²)最优时间复杂度 О(n²)平均时间复杂度 О(n²)最差空间复杂度 О(n) total, O(1) auxiliary
5、归并排序
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//归并排序 void merge(int A[], int first, int mid, int last, int temp[]) { int i = first, j = mid + 1; int m = mid, int n = last; int k = 0; while (i <= m&&j <= n) { if (A[i] < A[j]) temp[k++] = A[i++]; else temp[k++] = A[j++]; } while (i <= m) temp[k++] = A[i++]; while (j <= n) temp[k++] = A[j++]; for (i = 0; i < k; i++)//注意起始位置 A[first + i] = temp[k++]; } void mSort(int A[], int first, int last, int temp[]) { int mid = (first + last) / 2; mSort(A, first, mid, temp); mSort(A, mid + 1, last, temp); merge(A, first, mid, last, temp); } bool mergeSort(int A[], int n) { //统一接口,只在开始声明数组,提高效率 int *p = new int[n]; if (p == nullptr)return false; mSort(A, 0, n - 1, p); delete[] p; return true; }
平均时间复杂度:O(nlogn),效率较高
6、堆排序
堆排序包含两个过程:
(1)初建堆
(2)调整堆
初建堆:从非终端结点开始一直到根结点,执行调整堆的过程。这样,就会建立一个大顶堆。
调整堆:对于第二个过程,描述如下,第一次,取出堆顶元素与R[n]进行交换,然后从根结点开始调整堆,根结点与左右孩子中较大者交换,这样,
左右子树的堆会被破坏,继续进行上述操作,直到叶子结点为止。第二次,取出堆顶元素与R[n-1]交换,然后调整堆。
如果排序过程中,是按照从小到大正序,那么建立一个大顶堆。如果是逆序就建立一个小顶堆。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//堆排序 void adjustHeap(int A[], int i, int n) { //调整为最大堆 int temp = A[i]; for (int j = 2 * i + 1; j < n; j=2*j+1) { //在子结点中找最大的 if (j + 1 < n&&A[j + 1] > A[j]) j++; //如果已经是最大,无需调整 if (temp >= A[j])break; //把较大值往上移 A[i] = A[j]; i = j;//调整i } A[i] = temp; } void heapSort(int A[], int n) { //建最大堆 //从最后一个非叶子结点开始调整,分别调整成最大堆 for (int i = (n - 1) / 2; i >= 0; i--) adjustHeap(A, i, n); //排序 for (int i = n - 1; i >= 0; i--) { swap(A[0], A[n - 1]); //对剩下n-1个结点进行调整 adjustHeap(A, 0, n - 1); } }
7、快速排序
它采用了分治的思想:先保证列表的前半部分都小于后半部分,然后分别对前半部分和后半部分排序,这样整个列表就有序了。快速排序的基本算法是:
1. 从数列中挑出一个元素,称为 "基准"(pivot),
2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,该基准是它的最后位置。这个称为分割(partition)操作。
3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。递回的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递回下去,但是这个算法总会结束,
因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。
具体做法:
(1)初始化,设置两个指针ij,初值为区间的上下界,即i=low, j=high;选择无序区的第一个记录R[i]作为基准记录,并将它保存在变量pivot中。
(2)另j从high起向左扫描,直到找到第1个关键字小于pivot.key的记录R[j].将R[j]与基准R[i]交换,是关键字小于pivot.key的记录都移到基准的左边,交换后R[j]中是pivot;然后,令i自i+1位置开始向右扫描,
直到找到第1个关键字大于pivot.key的记录R[i],将R[i]与R[j]交换,交换后,R[i]中存的是pivot,将关键字大于pivot.key的都移动到基准的右边;接着继续扫描,两端往中间靠拢,直到i=j,i就为pivot最终位置。
快速排序的时间复杂度是O(nlogn),
最坏情况下时间复杂度是O(n²)。
平均时间复杂度 Θ(nlogn)
最好的情况是枢纽元选取得当,每次都能均匀的划分序列。 时间复杂度O(nlogn)
最坏情况是枢纽元为最大或者最小数字,那么所有数都划分到一个序列去了,即为有序的情况 时间复杂度为O(n^2)
就空间复杂度来说,主要是递归造成的栈空间的使用,最好情况,递归树的深度为log2n,其空间复杂度也就为O(logn),最坏情况,需要进行n‐1递归调用,其空间复杂度为O(n),平均情况,空间复杂度也为O(logn)。
优点: 快速,数据移动少
缺点:不稳定
快速排序被认为是目前基于比较的内部排序中较好的方法,当待排序的关键字随机分布时,快速排序的平均时间最短。
堆排序所需的辅助空间少于快速排序,并且不会出现快速排序可能出现的最坏情况,但这两种排序都是不稳定的,归并排序是稳定的。
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
//快速排序 int median3(int A[], int left, int right) { //取主元:取首个,中间,最后元素的中位数 int mid = (left + right) / 2; if (A[left] > A[mid])swap(&A[left], &A[mid]); if (A[left] > A[right-1])swap(&A[left], &A[right-1]); if (A[mid] > A[right-1])swap(&A[mid], &A[right-1]); //同时将主元藏在倒数第二个位置上,只需考虑个[left+1,right-3]; swap(&A[mid], &A[right - 2]); return A[right - 2]; } void quick_sort(int A[], int left, int right) { int pivot = median3(A, left, right); int i = left, j = right - 2; for (;;) { while (A[++i] < pivot); while (A[--j] > pivot); if (i < j)swap(&A[i], &A[j]); else break; } swap(&A[i], &A[right - 2]);//将pivot交换至正确位置 quick_sort(A, left, i - 1); quick_sort(A, i + 1, right); } void quickSort(int A[], int n) { quick_sort(A, 0, n); }
void quick_sort(vector<int>& a, int start, int end) { if (a.size() == 0 || end - start <= 1 || start < 0) return; int pivot_pos = start; int pivot = a[start]; int temp; for (int i = start + 1; i < end; i++) { if (a[i] < pivot) { if (++pivot_pos != i) { swap(a[pivot_pos], a[i]); } } } a[start] = a[pivot_pos]; a[pivot_pos] = pivot; quick_sort(a, start, pivot_pos - 1); quick_sort(a, pivot_pos + 1, end); }