[关闭]
@kakadee 2016-07-12T06:52:09.000000Z 字数 5918 阅读 1339

八大排序算法

算法 查找和排序

1. 插入排序—直接插入排序 ( 稳定的 O(nlogn) )

基本思想:

将一个记录插入到已排序好的有序表中，从而得到一个新，记录数增1的有序表。即：先将序列的第1个记录看成是一个有序的子序列，然后从第2个记录逐个进行插入，直至整个序列有序为止。

要点：设立哨兵，作为临时存储和判断数组边界之用。

如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

算法实现：

  1. // 1. 直接插入排序
  2. void InsertSort(vector<int> &num) {
  3.     int low = 0, high = num.size()-1;
  4.     for (int i = low + 1; i <= high; ++i)
  5.     {
  6.         if (num[i] < num[i - 1]) {
  7.             int j = i;
  8.             while (j > low && num[j] < num[j - 1]) {
  9.                 swap(num[j], num[j - 1]);
  10.                 j--;
  11.             }
  12.         }
  13.     }
  14. }

2. 插入排序—希尔排序（Shell`s Sort） ( 不稳定 O() )

基本思想:

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

操作方法:

  1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  2. 按增量序列个数k，对序列进行k 趟排序；
  3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

算法实现: 

  1. void ShellInsertSort(vector<int> &num, int n, int dk) {
  2.     for (int i = dk; i < n; ++i) {
  3.         int j = i;
  4.         while (j - dk >= 0 && num[j] < num[j - dk]) {
  5.             swap(num[j], num[j - dk]);
  6.             j -= dk;
  7.         }
  8.     }
  9. }
  10. void ShellSort(vector<int> &num) {
  11.     int dk = num.size() / 2;
  12.     while (dk >= 1) {
  13.         ShellInsertSort(num, num.size(), dk);
  14.         dk /= 2;
  15.     }
  16. }

3. 选择排序—简单选择排序（Simple Selection Sort） (不稳定 O() )

基本思想:

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；然后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

操作方法:

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；
第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；
以此类推.....
第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，
直到整个序列按关键码有序。

算法实现: 

  1. int SelectMinKey(vector<int> &num, int i) {
  2.     int minKey = i;
  3.     for (int j = i + 1; j < num.size(); ++j) {
  4.         minKey = num[j] < num[minKey] ? j : minKey;
  5.     }
  6.     return minKey;
  7. }
  8. void SimpleSelectSort(vector<int> &num) {
  9.     for (int i = 0; i < num.size(); ++i) {
  10.         int minKey = SelectMinKey(num, i);
  11.         if (minKey != i)
  12.             swap(num[minKey], num[i]);
  13.     }
  14. }


4. 选择排序—堆排序（Heap Sort） ( 不稳定的 O(nlogn) )

基本思想:

堆的定义如下：具有n个元素的序列（),当且仅当满

或者，

时称之为堆(前者为小顶堆，后者为大顶堆）。

堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

堆的存储

一般都用数组来表示堆，i结点的父结点下标就为。它的左右子结点下标分别为和。如第0个结点左右子结点下标分别为1和2。

小顶堆的插入

  1. // 新加入i结点  其父结点为(i - 1) / 2  
  2. void MinHeapFixup(vector<int> &a, int i)  
  3. {  
  4.     int j = (i - 1) / 2, temp = a[i];  
  5.     while (j >= 0 && i != 0)  
  6.     {   //把较大的子结点往下移动,替换它的子结点
  7.         if (a[j] <= temp)  break; 
  8.         a[i] = a[j];       
  9.         i = j;  
  10.         j = (i - 1) / 2;  
  11.     }  
  12.     a[i] = temp;  
  13. }  
  14. // 更简短的表达：
  15. void MinHeapFixup2(vector<int> &a, int i)  
  16. {  
  17.     for (int j = (i - 1) / 2; (j >= 0 && i != 0)&& a[i] > a[j]; i = j, j = (i - 1) / 2)  
  18.         Swap(a[i], a[j]);  
  19. }  
  20. // 在最小堆中加入新的数据nNum  
  21. void MinHeapAddNumber(vector<int>, int nNum)  
  22. {  
  23.     a.push_back(nNum);  
  24.     MinHeapFixup(a, a.size()-1);  
  25. }

堆的删除

堆中每次都只能删除第0个数据。为了便于重建堆，实际的操作是将最后一个数据的值赋给根结点，然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最小的，如果父结点比这个最小的子结点还小说明不需要调整了，反之将父结点和它交换后再考虑后面的结点。

  1. //  从i节点开始调整,n为节点总数 从0开始计算 i节点的子节点为 2*i+1, 2*i+2  
  2. void MinHeapFixdown(vector<int> &a, int i, int n)  
  3. {  
  4.     int j, temp;  
  5.     temp = a[i];  
  6.     j = 2 * i + 1;  
  7.     while (j < n)  
  8.     {  
  9.         if (j + 1 < n && a[j + 1] < a[j]) //在左右孩子中找最小的  
  10.             j++;  
  12.         if (a[j] >= temp)  
  13.             break;  
  15.         a[i] = a[j];     //把较小的子结点往上移动,替换它的父结点  
  16.         i = j;  
  17.         j = 2 * i + 1;  
  18.     }  
  19.     a[i] = temp;  
  20. }  
  21. //在最小堆中删除数  
  22. void MinHeapDeleteNumber(vector<int> &a,int n)  
  23. {  
  24.     Swap(a[0], a[n - 1]);  
  25.     MinHeapFixdown(a, 0, n - 1);  
  26. }

建立小顶堆

  1. void MakeMinHeap(vector<int> &a, int n)  
  2. {  
  3.     for (int i = n / 2 - 1; i >= 0; i--)  
  4.         MinHeapFixdown(a, i, n);  
  5. }

堆排序

  1. // 小顶堆排序后的数组是递减的，若要递增，使用大顶堆
  2. void Minheapsort(vector<int> &a, int n)  
  3. {   
  4.     MakeMinHeap(a, n); 
  5.     for (int i = n - 1; i >= 1; i--)  
  6.     {  
  7.         Swap(a[i], a[0]);  
  8.         MinHeapFixdown(a, 0, i);  
  9.     }  
  10. }

完整的堆排序

  1. // 4. 堆排序
  2. void MaxHeapFixdown(vector<int> &a, int i, int n)  
  3. {  
  4.     int j = 2 * i + 1, temp = a[i];  
  5.     while (j < n)  
  6.     {  
  7.         if (j + 1 < n && a[j + 1] > a[j]) //在左右孩子中找最大的  
  8.             j++;  
  10.         if (a[j] <= temp)  
  11.             break;  
  13.         a[i] = a[j];     //把较大的子结点往上移动,替换它的父结点  
  14.         i = j;  
  15.         j = 2 * i + 1;  
  16.     }  
  17.     a[i] = temp;  
  18. }  
  19. void MakeMaxHeap(vector<int> &a, int n)  
  20. {  
  21.     for (int i = (n-1)/2; i >= 0; i--)  
  22.         MaxHeapFixdown(a, i, n);  
  23. }  
  24. void Maxheapsort(vector<int> &a, int n)  
  25. {  
  26.     MakeMaxHeap(a, n);  
  27.     for (int i = n - 1; i > 0; i--)  
  28.     {  
  29.         swap(a[i], a[0]);  
  30.         MaxHeapFixdown(a, 0, i);  
  31.     }  
  32. }

5. 交换排序—冒泡排序（Bubble Sort） ( 稳定的 O() )

基本思想:

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

算法实现: 

  1. void BubbleSort(vector<int> &a) {
  2.     int n = a.size();
  3.     for(int i = 0;i<n;++i)
  4.     for(int j=0;j<n-i-1;++j){
  5.         if(a[j] > a[j+1])
  6.             swap(a[j],a[j+1]);
  7.     }
  8. }

6. 交换排序—快速排序（Quick Sort） ( 不稳定的 O(nlogn) )

基本思想:

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,
2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
3）此时基准元素在其排好序后的正确位置
4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

快速排序的示例：

（a）一趟排序的过程：
初 始 关 键 字 : (49) 38 65 97 76 13 27 49
进 行 1 次 交 換: 27 38 65 97 76 13 (49) 49
进 行 2 次 交 换: 27 38 (49) 97 76 13 65 49
迸 行 3 次 交 換: 27 38 13 97 76 (49) 65 49
进 行 4 次 交 换: 27 38 13 (49) 76 97 65 49

算法实现: 

  1. int Partition(vector<int> &a, int low, int high) {
  2.     int pivotKey = a[low]; // 这里pivotKey记录的一定是值，不能是下标，因为下标的值可能会换
  3.     while (low < high) {
  4.         while (low < high && a[high] >= pivotKey) high--;
  5.         swap(a[high], a[low]);
  6.         while (low < high && a[low] <= pivotKey) low++;
  7.         swap(a[high], a[low]);
  8.     }
  9.     return low;
  10. }
  11. void QuickSort(vector<int> &a, int low, int high) {
  12.     if (low < high) {
  13.         int pivotLoc = Partition(a, low, high);
  14.         QuickSort(a, low, pivotLoc - 1);
  15.         QuickSort(a, pivotLoc + 1, high);
  16.     }
  17. }

7. 归并排序（Merge Sort） ( 稳定的 O(nlogn) )

基本思想：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

算法实现：

  1. // 7. 归并排序
  2. //将二个有序数列a[first...mid]和a[mid...last]合并。
  3. void MergeArray(vector<int> &array, int low, int mid, int high)
  4. {
  5.     int i = low; // i是第一段序列的下标
  6.     int j = mid + 1; // j是第二段序列的下标
  7.     int k = 0; // k是临时存放合并序列的下标
  8.     vector<int> tmp(high - low + 1); // array2是临时合并序列
  9.     // 扫描第一段和第二段序列，直到有一个扫描结束
  10.     while (i <= mid && j <= high) {
  11.         // 判断第一段和第二段取出的数哪个更小，将其存入合并序列，并继续向下扫描
  12.         if (array[i] <= array[j]) {
  13.             tmp[k++] = array[i++];
  14.         } else {
  15.             tmp[k++] = array[j++];
  16.         }
  17.     }
  18.     // 若第一段序列还没扫描完，将其全部复制到合并序列
  19.     while (i <= mid) {
  20.         tmp[k++] = array[i++];
  21.     }
  22.     // 若第二段序列还没扫描完，将其全部复制到合并序列
  23.     while (j <= high) {
  24.         tmp[k++] = array[j++];
  25.     }
  26.     // 将合并序列复制到原始序列中
  27.     for (i = 0; i < k; i++)
  28.         array[low + i] = tmp[i];
  29. }
  30. void MergeSort(vector<int> &a, int low, int high)
  31. {
  32.     if (low < high)
  33.     {
  34.         int mid = (low + high) / 2;
  35.         MergeSort(a, low, mid);    //左边有序
  36.         MergeSort(a, mid + 1, high); //右边有序
  37.         MergeArray(a, low, mid, high); //再将二个有序数列合并
  38.     }
  39. }

8. 桶排序/基数排序(Radix Sort) ( 稳定的 O(n) )

基本思想：

是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（O（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。

算法实现：

  1. // 8. 桶排序
  2. //找到num的从低到高的第pos位的数据
  3. int GetNumInPos(int num, int pos)
  4. {
  5.     int temp = 1;
  6.     for (int i = 0; i < pos - 1; i++)
  7.         temp *= 10;
  9.     return (num / temp) % 10;
  10. }
  11. #define RADIXNUM 10   // 基数（桶的个数）
  12. #define KEYNUM 10     // 关键字个数，这里为最大整数的位数
  13. void RadixSort(vector<int> &a)
  14. {
  15.     int n = a.size();
  16.     vector<vector<int> > bucket(RADIXNUM, vector<int>(n)); // 分配桶空间
  17.     for (int pos = 1; pos <= KEYNUM; pos++)    //从个位到最高位
  18.     {
  19.         for (int i = 0; i < n; i++)    //分配过程
  20.         {
  21.             int num = GetNumInPos(a[i], pos);
  22.             int index = ++bucket[num][0];
  23.             bucket[num][index] = a[i];
  24.         }
  26.         for (int i = 0, j = 0; i < RADIXNUM; i++)   //收集
  27.         {
  28.             for (int k = 1; k <= bucket[i][0]; k++)
  29.                 a[j++] = bucket[i][k];
  30.             bucket[i][0] = 0;    //复位
  31.         }
  32.     }
  33. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注