1、冒泡排序
//冒泡排序 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、插入排序
//插入排序 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、希尔排序
//希尔排序 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、选择排序
//选择排序 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、归并排序
//归并排序 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]交换,然后调整堆。
如果排序过程中,是按照从小到大正序,那么建立一个大顶堆。如果是逆序就建立一个小顶堆。
//堆排序 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)。
优点： 快速，数据移动少
缺点：不稳定
快速排序被认为是目前基于比较的内部排序中较好的方法，当待排序的关键字随机分布时，快速排序的平均时间最短。
堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况，但这两种排序都是不稳定的，归并排序是稳定的。
//快速排序 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);
}