排序算法

常见排序算法

稳定排序：

  • 冒泡排序 — O(n²)
  • 插入排序 — O(n²)
  • 桶排序 — O(n); 需要 O(k) 额外空间
  • 归并排序 — O(nlogn); 需要 O(n) 额外空间
  • 二叉排序树排序 — O(n log n) 期望时间; O(n²)最坏时间; 需要 O(n) 额外空间
  • 基数排序 — O(n·k); 需要 O(n) 额外空间

不稳定排序

  • 选择排序 — O(n²)
  • 希尔排序 — O(nlogn)
  • 堆排序 — O(nlogn)
  • 快速排序 — O(nlogn) 期望时间, O(n²) 最坏情况; 对于大的、乱数串行一般相信是最快的已知排序

交换排序

冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。冒泡排序总的平均时间复杂度为O(n^2)。冒泡排序是一种稳定排序算法。

  • 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  • 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
  • 针对所有的元素重复以上的步骤，除了最后一个。
  • 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
  1. void bubble_sort(int a[], int n)
  2. {
  3.     int i, j, temp;
  4.     for (j = 0; j < n - 1; j++)
  5.         for (i = 0; i < n - 1 - j; i++)
  6.         {
  7.             if(a[i] > a[i + 1])
  8.             {
  9.                 temp = a[i];
  10.                 a[i] = a[i + 1];
  11.                 a[i + 1] = temp;
  12.             }
  13.         }
  14. }

快速排序 快速排序-百度百科

快速排序是一种 不稳定 的排序算法，平均时间复杂度为 O(nlogn)。快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。 步骤为：

  • 从数列中挑出一个元素，称为”基准”（pivot），
  • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
  • 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

快排的时间花费主要在划分上，所以

  • 最坏情况：时间复杂度为O(n^2)。因为最坏情况发生在每次划分过程产生的两个区间分别包含n-1个元素和1个元素的时候。
  • 最好情况：每次划分选取的基准都是当前无序区的中值。如果每次划分过程产生的区间大小都为n/2，则快速排序法运行就快得多了。
  1.   void Qsort(int a[], int low, int high)
  2.   {
  3.       if(low >= high)
  4.       {
  5.           return;
  6.       }
  7.       int first = low;
  8.       int last = high;
  9.       int key = a[first];
  11.       while(first < last)
  12.       {
  13.           while(first < last && a[last] >= key)
  14.           {
  15.               --last;
  16.           }
  17.           a[first] = a[last];
  18.           while(first < last && a[first] <= key)
  19.           {
  20.               ++first;
  21.           }
  22.           a[last] = a[first];    
  23.       }
  24.       a[first] = key;
  25.       Qsort(a, low, first-1);
  26.       Qsort(a, first+1, high);
  27.   }

快排的优化

  1. 当待排序序列的长度分割到一定大小后，使用插入排序。
  2. 快排函数在函数尾部有两次递归操作，我们可以对其使用尾递归优化。优化后，可以缩减堆栈深度，由原来的O(n)缩减为O(logn)，将会提高性能。
  3. 从左、中、右三个数中取中间值。

插入排序

直接插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。 插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。

  2. void insert_sort(int* a, int len) {
  3.     for (int i = 1; i < len; ++i) {
  4.         int j = i - 1;
  5.         int temp = a[i];
  6.         while (j >= 0 && temp < a[j]) {
  7.             a[j + 1] = a[j];
  8.             j--;
  9.         }
  10.         a[j + 1] = temp;
  11.     }
  12. }

希尔排序

也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

  1. void shell_sort(int* a, int len) {
  2.     int step = len / 2;
  3.     int temp;
  5.     while (step > 0) {
  6.         for (int i = step; i < len; ++i) {
  7.             temp = a[i];
  8.             int j = i - step;
  9.             while (j >= 0 && temp < a[j]) {
  10.                 a[j + step] = a[j];
  11.                 j -= step;
  12.             }
  13.             a[j + step] = temp;
  14.         }
  15.         step /= 2;
  16.     }
  17. }

选择排序

直接选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。实际适用的场合非常罕见。

  1. void selection_sort(int arr[], int len) {
  2.     int i, j, min, temp;
  3.     for (i = 0; i < len - 1; i++) {
  4.         min = i;
  5.         for (j = i + 1; j < len; j++)
  6.             if (arr[min] > arr[j])
  7.                 min = j;
  8.            temp = arr[min];
  9.         arr[min] = arr[i];
  10.         arr[i] = temp;
  11.     }
  12. }

堆排序

堆排序利用了大根堆（或小根堆）堆顶记录的关键字最大（或最小）这一特征，使得在当前无序区中选取最大（或最小）关键字的记录变得简单。

  1. 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区
  2. 再将关键字最大的记录R[1]（即堆顶）和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key
  3. 由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。
  4. 直到无序区只有一个元素为止。
  1. static void max_heap(int[] num, int start, int end) {
  2.     int dad = start;
  3.     int son = dad * 2 + 1;
  5.     while (son < end) {
  6.         if (son + 1 < end && num[son] < num[son + 1])
  7.             son++;
  9.         if (num[dad] > num[son])
  10.             return;
  11.         else {
  12.             num[dad] ^= num[son];
  13.             num[son] ^= num[dad];
  14.             num[dad] ^= num[son];
  16.             dad = son;
  17.             son = dad * 2 + 1;
  18.         }
  19.     }
  20. }
  22. static void heap_sort(int[] num) {
  23.     for (int i = num.length / 2 - 1; i >= 0; --i) {
  24.         max_heap(num, i, num.length);
  25.     }
  27.     for (int i = num.length - 1; i >= 0; --i) {
  28.         num[i] ^= num[0];
  29.         num[0] ^= num[i];
  30.         num[i] ^= num[0];
  32.         max_heap(num, 0, i);
  33.     }
  34. }

归并排序

归并排序采用分治的思想：

  • Divide：将n个元素平均划分为各含n/2个元素的子序列；
  • Conquer：递归的解决俩个规模为n/2的子问题；

  • Combine：合并俩个已排序的子序列。

    性能：时间复杂度总是为O(NlogN)，空间复杂度也总为为O(N)，算法与初始序列无关，排序是稳定的。

  1. void mergeSort(int arr[], int len) {
  2.     int* a = arr;
  3.     int* b = (int*) malloc(len * sizeof(int));
  5.     for (int size = 1; size < len; size += size) {
  6.         for (int start = 0; start < len; start += size + size) {
  7.             int k = start;
  8.             int left = start, right = min(left + size + size, len), mid = min(left + size, len);
  10.             int start1 = left, end1 = mid;
  11.             int start2 = mid, end2 = right;
  13.             while (start1 < end1 && start2 < end2) {
  14.                 b[k++] = a[start1] > a[start2] ? a[start2++] : a[start1++];
  15.             }
  17.             while (start1 < end1) {
  18.                 b[k++] = a[start1++];
  19.             }
  20.             while (start2 < end2) {
  21.                 b[k++] = a[start2++];
  22.             }
  23.         }
  24.         int* temp = a;
  25.         a = b;
  26.         b = temp;
  27.     }
  29.     if (a != arr) {
  30.         for (int i = 0; i < len; ++i) {
  31.             b[i] = a[i];
  32.         }
  33.         b = a;
  34.     }
  36.     free(b);
  37. }

基数排序

对于有d个关键字时，可以分别按关键字进行排序。有俩种方法：

  • MSD：先从高位开始进行排序，在每个关键字上，可采用基数排序
  • LSD：先从低位开始进行排序，在每个关键字上，可采用桶排序

即通过每个数的每位数字的大小来比较

  1. //找出最大数字的位数
  2. int maxNum(int arr[], int len) {
  3.     int _max = 0;
  5.     for (int i = 0; i < len; ++i) {
  6.         int d = 0;
  7.         int a = arr[i];
  9.         while (a) {
  10.             a /= 10;
  11.             d++;
  12.         }
  14.         if (_max < d) {
  15.             _max = d;
  16.         }
  17.     }
  18.     return _max;
  19. }
  22. void radixSort(int *arr, int len) {
  23.     int d = maxNum(arr, len);
  24.     int *temp = new int[len];
  25.     int count[10];
  26.     int radix = 1;
  28.     for (int i = 0; i < d; ++i) {
  29.         for (int j = 0; j < 10; ++j) {
  30.             count[j] = 0;
  31.         }
  33.         for (int k = 0; k < len; ++k) {
  34.             count[(arr[k] / radix) % 10]++;
  35.         }
  37.         for (int l = 1; l < 10; ++l) {
  38.             count[l] += count[l - 1];
  39.         }
  41.         for (int m = 0; m < len; ++m) {
  42.             int index = (arr[m] / radix) % 10;
  43.             temp[count[index] - 1] = arr[m];
  44.             count[index]--;
  45.         }
  47.         for (int n = 0; n < len; ++n) {
  48.             arr[n] = temp[n];
  49.         }
  50.         radix *= 10;
  52.     }
  54.     delete (temp);
  55. }

拓扑排序

在有向图中找拓扑序列的过程，就是拓扑排序。拓扑序列常常用于判定图是否有环。

  • 从有向图中选择一个入度为0的结点，输出它。
  • 将这个结点以及该结点出发的所有边从图中删除。
  • 重复前两步，直到没有入度为0的点。

如果所有点都被输出，即存在一个拓扑序列，则图没有环。