各种排序算法（冒泡、选择、快排、插入、希尔、堆排、归并、计数、基数）

版权声明：本文为博主原创文章，未经博主允许不得转载。

计数排序:时间复杂度:O(N), 空间复杂度O(最大数-最小数)
基数排序:时间复杂度:O(N*位数)，空间辅助度O（N）

 

 

冒泡排序（BubbleSort）

       冒泡排序（BubbleSort）是一种简单的排序算法。它重复地遍历过要排序的数列，一次比较两个元素，如果他们的顺序错误把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

冒泡排序算法的步骤：

      1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

      2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

      3.针对所有的元素重复以上的步骤，除了最后一个。

      4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

选择排序(SelectSort)

       选择排序(SelecSort)是一种简单直观的排序算法。它的工作原理如下：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

简单选择排序算法改进

       传统的简单选择排序,每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素(当前趟最大和最小记录)的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序,最多只需进行[n/2]趟循环即可。

快速排序（QuickSort）

       快速排序是冒泡排序的一种改进，冒泡排序排完一趟是最大值冒出来了，那么可不可以先选定一个值，然后扫描待排序序列，把小于该值的记录和大于该值的记录分成两个单独的序列，然后分别对这两个序列进行上述操作。这就是快速排序，我们把选定的那个值称为枢纽值，如果枢纽值为序列中的最大值，那么一趟快速排序就变成了一趟冒泡排序。

快速排序算法的步骤：

       1.从数列中挑出一个元素，称为 "基准"，重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。

       2.递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。

       3.递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。

插入排序（InsertSort）

       插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。 插入排序方法分直接插入排序和折半插入排序两种。

希尔排序（ShellSort）

       希尔排序（ShellSort）又称为“缩小增量排序”。该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率上比前两种方法有较大提高。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

       1.插入排序在对几乎已经排好序的数据操作时， 效率高， 即可以达到线性排序的效率。

       2.插入排序一般来说是低效的， 因为插入排序每次只能将数据移动一位，步长的选择是希尔排序的重要部分。只要最终步长为1任何步长序列都可以工作。

堆排序（HeapSort）

        移除位在第一个数据的根结点，并做最大堆调整的递归运算。

堆的存储

        一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。

归并排序（MergeSort）算法

        归并排序（MergeSort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。

归并排序的步骤如下：

        1. 把长度为n的输入序列分成两个长度为n/2的子序列。

        2. 对这两个子序列分别采用递归归并排序。

        3. 将两个排序好的子序列递归合并成一个最终的排序序列。

基数排序(RadixSort)

       基数排序(RadixSort)是对桶排序的改进和推广。唯一的区别是基数排序强调多关键字，而桶排序没有这个概念，换句话说基数排序对每一种关键字都进行桶排序，而桶排序同一个桶内排序可以任意或直接排好序。基数排序的方式可以采用LSD或MSD，LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

基数排序的基本思想是：从低位到高位依次对Kj(j=d-1，d-2，…，0)进行箱排序。

计数排序(CountSort)

       计数排序(CountSort)是一种稳定的排序算法，和基数排序一样都是桶排序的变体。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值小于等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。

计数排序的原理

       设被排序的数组为A,排序后存储到B，C为临时数组。所谓计数，首先是通过一个数组C[i]计算大小等于i的元素个数，此过程需要一次循环遍历就可以；在此基础上，计算小于或者等于i的元素个数，也是一重循环就完成。下一步是关键：逆序循环，length[A]到1，将A[i]放到B中第C[A[i]]个位置上。原理是：C[A[i]]表示小于等于a[i]的元素个数，正好是A[i]排序后应该在的位置。而且从length[A]到1逆序循环，可以保证相同元素间的相对顺序不变，这也是计数排序稳定性的体现。在数组A有附件属性的时候，稳定性是非常重要的。

 

[cpp] view plain copy
 
  1. #include<iostream>  
  2. #include<assert.h>  
  3. #include<stack>  
  4. using namespace std;  
  5.   
  6. //冒泡排序   O(N^2)  
  7. void BubbleSort(int *arr, int len)  
  8. {  
  9.     for (int i = 0; i < len - 1; ++i)  
  10.     {  
  11.         bool exchange = false;  
  12.         for (int j = 1; j < len - i; ++j)  
  13.         {  
  14.             if (arr[j - 1]>arr[j])  
  15.             {  
  16.                 swap(arr[j-1],arr[j]);  
  17.                 exchange = true;  
  18.             }  
  19.         }  
  20.         if (exchange == false)  
  21.         {  
  22.             return;  
  23.         }  
  24.     }  
  25. }  
  26.   
  27. //选择排序  O(N^2)  
  28. void SelectSort1(int *arr, int len)  
  29. {  
  30.     for (int i = 0; i < len-1; ++i)  
  31.     {  
  32.         int k = i;//k保存最小的数  
  33.         for (int j =i+1; j < len; ++j)  
  34.         {  
  35.             if (arr[k]>arr[j])  
  36.             {  
  37.                 k=j;  
  38.             }  
  39.         }  
  40.         if (k != i)  
  41.         {  
  42.             swap(arr[k], arr[i]);  
  43.         }  
  44.     }  
  45. }  
  46. //选择排序的优化  O(N^2)  
  47. void SelectSort(int *arr, int len)  
  48. {  
  49.     int begin = 0;  
  50.     int end = len - 1;  
  51.     while (begin < end)  
  52.     {  
  53.         int min = begin;  
  54.         int max = end;  
  55.         for (int i = begin; i <= end; ++i)  
  56.         {  
  57.             if (arr[min]>arr[i])  
  58.                 swap(arr[min], arr[i]);  
  59.             if (arr[max] < arr[i])  
  60.                 swap(arr[max], arr[i]);  
  61.         }  
  62.         ++begin;  
  63.         --end;  
  64.     }  
  65. }  
  66.   
  67. //快速排序  O(N*lgN)  
  68. void _QuickSort1(int *arr,int left,int right)  
  69. {  
  70.     assert(arr);  
  71.     if (left >= right)  
  72.         return;  
  73.     int begin = left;  
  74.     int end = right - 1;  
  75.     int key = arr[right];  
  76.     while (begin < end)  
  77.     {  
  78.         if (begin < end && arr[begin] <= key)//找大  
  79.         {  
  80.             ++begin;  
  81.         }  
  82.         if (begin < end && arr[end] >= key)//找小  
  83.         {  
  84.             --end;  
  85.         }  
  86.         if (begin <end)  
  87.         {  
  88.             swap(arr[begin], arr[end]);  
  89.         }  
  90.     }  
  91.     if (arr[begin] < key)  
  92.     {  
  93.         ++begin;  
  94.     }  
  95.     swap(arr[begin], arr[right]);  
  96.     // 递归排序子序列  
  97.     _QuickSort1(arr, left, begin - 1);  
  98.     _QuickSort1(arr,begin + 1,right);  
  99. }  
  100. //快速排序  O(N*lgN)  
  101. void _QuickSort2(int *arr,int left,int right)  
  102. {  
  103.     if (left >= right)  
  104.         return;  
  105.     assert(arr);  
  106.     int key = arr[right];  
  107.     int cur = left;  
  108.     int prev = left - 1;  
  109.     while (cur < right)  
  110.     {  
  111.         //找小，停下进行翻转  
  112.         if (arr[cur] < key &&  ++prev!=cur)  
  113.         {  
  114.             swap(arr[cur], arr[prev]);  
  115.         }  
  116.         ++cur;  
  117.     }  
  118.     swap(arr[++prev], arr[right]);  
  119.   
  120.     _QuickSort2(arr,left,prev-1);  
  121.     _QuickSort2(arr,prev+1,right);  
  122. }  
  123. void QuickSort(int *arr, int len)  
  124. {  
  125.     //_QuickSort1(arr,0,len-1);  
  126.     _QuickSort2(arr,0,len-1);  
  127. }  
  128. int Partion(int *arr, int left, int right)  
  129. {  
  130.     assert(arr);  
  131.     if (left >= right)  
  132.         return -1;  
  133.     int key = arr[right];  
  134.     int cur = left;  
  135.     int prev = left - 1;  
  136.     while (cur < right)  
  137.     {  
  138.         if (arr[cur] < key&& ++prev != cur)  
  139.         {  
  140.             swap(arr[cur], arr[prev]);  
  141.         }  
  142.         ++cur;  
  143.     }  
  144.     swap(arr[++prev],arr[right]);  
  145.   
  146.     return prev;  
  147. }  
  148. //处理栈溢出问题  
  149. void QuickSort_NonR(int *arr, int len)  
  150. {  
  151.     stack<int> s;  
  152.     s.push(len-1);  
  153.     s.push(0);  
  154.   
  155.     while (!s.empty())  
  156.     {  
  157.         int left = s.top();  
  158.         s.pop();  
  159.         int right = s.top();  
  160.         s.pop();  
  161.   
  162.         int key = Partion(arr,left,right);  
  163.         if (key == -1)  
  164.         {  
  165.             continue;  
  166.         }  
  167.         if (key - 1 > left)  
  168.         {  
  169.             s.push(key-1);  
  170.             s.push(left);  
  171.         }  
  172.         if (key + 1 < right)  
  173.         {  
  174.             s.push(right);  
  175.             s.push(key+1);  
  176.         }  
  177.     }  
  178. }  
  179. //插入排序      O(N^2)  
  180. void InsertSort(int *arr, int len)  
  181. {  
  182.     for (int i = 1; i < len; ++i)  
  183.     {  
  184.         //挪动数据  
  185.         int tmp = arr[i];//待插入数据  
  186.         int end = i - 1;  
  187.         while (arr[end]>tmp&&end >= 0)  
  188.         {  
  189.             arr[end + 1] = arr[end];  
  190.             --end;  
  191.         }  
  192.         arr[end + 1] = tmp;  
  193.     }  
  194. }  
  195. //希尔排序    当N大时，平均的时间复杂度，大约在N^1.25--1.6N^1.25之间。  
  196. void ShellSort(int *arr,int len)  
  197. {  
  198.     int gap = len;  
  199.     while (gap > 1)  
  200.     {  
  201.         gap = gap / 3 + 1;  
  202.         for (int i = gap; i < len; i += gap)  
  203.         {  
  204.             int tmp = arr[i];//待插入数据  
  205.             // 挪动数据  
  206.             int end = i - gap;  
  207.             while (arr[end]>tmp&&end >= 0)  
  208.             {  
  209.                 arr[gap+end] = arr[end];  
  210.                 end -= gap;  
  211.             }  
  212.             arr[end + gap] = tmp;  
  213.         }  
  214.     }  
  215. }  
  216.   
  217. //堆排序     O(N*lgN)  
  218. void _AdjustDown(int *arr, int root,int len)  
  219. {  
  220.     int parent = root;  
  221.     int left = 2 * parent+1;  
  222.     int right = left + 1;  
  223.     while (left <len)  
  224.     {  
  225.         int max = left;  
  226.         if (arr[max] < arr[right]&&right<len)  
  227.         {  
  228.             max = right;  
  229.         }  
  230.         if (arr[parent] < arr[max])  
  231.         {  
  232.             swap(arr[parent], arr[max]);  
  233.             parent = max;  
  234.             left = 2 * parent+1;  
  235.                 right = left + 1;  
  236.         }  
  237.         else  
  238.         {  
  239.             break;  
  240.         }  
  241.     }  
  242. }  
  243. void HeapSort(int *arr, int len)  
  244. {  
  245.     //建堆  
  246.     for (int i = len / 2 - 1; i >= 0; --i)  
  247.     {  
  248.         _AdjustDown(arr,i,len);  
  249.     }  
  250.     //选择堆顶数据进行排序  
  251.     int end = len - 1;  
  252.     while (end > 0)  
  253.     {  
  254.         swap(arr[0], arr[end]);  
  255.         _AdjustDown(arr,0,end);  
  256.         --end;  
  257.     }  
  258. }  
  259. //归并排序  
  260. void _Merge(int *src, int *dst, int begin, int mid, int end)  
  261. {  
  262.     int begin1 = begin;  
  263.     int end1 = mid;  
  264.     int begin2 = mid;  
  265.     int end2 = end;  
  266.     int index = begin;  
  267.     while (begin1 < end1 && begin2 < end2)  
  268.     {  
  269.         if (src[begin1] <src[begin2])  
  270.         {  
  271.             dst[index++] = src[begin1++];  
  272.         }  
  273.         else  
  274.         {  
  275.             dst[index++] = src[begin2++];  
  276.         }  
  277.     }  
  278.     while (begin1 < end1)  
  279.     {  
  280.         dst[index++] = src[begin1++];  
  281.     }  
  282.     while (begin2 < end2)  
  283.     {  
  284.         dst[index++] = src[begin2++];  
  285.     }  
  286.     memcpy(src+begin,dst+begin,(end-begin)*sizeof(int));  
  287. }  
  288. void _MergeSort(int *arr,int *tmp, int left, int right)  
  289. {  
  290.     if (left+1 >= right)  
  291.         return;  
  292.       
  293.     int mid = (left + right) / 2;  
  294.     // 递归排序左右区间，  
  295.     _MergeSort(arr,tmp, left, mid);  
  296.     _MergeSort(arr,tmp, mid, right);  
  297.     // 合并左右区间  
  298.     // [left,mid) [mid,right)  
  299.     _Merge(arr, tmp, left, mid, right);  
  300. }  
  301. void MergeSort(int *arr,int len)  
  302. {  
  303.     int *tmp = new int[len]();  
  304.     _MergeSort(arr,tmp,0,len);  
  305.     delete []tmp;  
  306. }  
  307. //计数排序  
  308. void CountSort(int *arr,int len)  
  309. {  
  310.     int max = arr[0];  
  311.     int min = arr[0];  
  312.     for (int i = 1; i < len; ++i)  
  313.     {  
  314.         if (arr[i]>max)  
  315.         {  
  316.             max = arr[i];  
  317.         }  
  318.         if (arr[i] < min)  
  319.         {  
  320.             min = arr[i];  
  321.         }  
  322.     }  
  323.     int *tmp = new int[max-min + 1];  
  324.     memset(tmp,0,sizeof(int)*(max-min+1));  
  325.   
  326.     for (int i = 0; i < len; ++i)  
  327.     {  
  328.         tmp[arr[i] - min]++;  
  329.     }  
[cpp] view plain copy
 
  1. }  
  2. //基数排序  
  3. void RadixSort_LSD(int* arr, int len)  
  4. {  
  5.     int maxBit = 2;  
  6.     int* count = new int[10]();  
  7.     int* bucket = new int[len]();  
  8.   
  9.     int radix = 1;  
  10.     for (int bit = 1; bit <= maxBit; ++bit)  
  11.     {  
  12.         memset(count, 0, sizeof(int)* 10);  
  13.   
  14.         // 统计每个桶的数据个数  
  15.         for (int i = 0; i < len; ++i)  
  16.         {  
  17.             int k = (arr[i] / radix) % 10;  
  18.             count[k]++;  
  19.         }  
  20.   
  21.         // 统计在桶中的位置  
  22.         for (int i = 1; i < len; ++i)  
  23.         {  
  24.             count[i] = count[i] + count[i - 1];  
  25.         }  
  26.   
  27.         for (int i = len - 1; i >= 0; --i)  
  28.         {  
  29.             int k = (arr[i] / radix) % 10;  
  30.             bucket[--count[k]] = arr[i];  
  31.         }  
  32.   
  33.         memcpy(bucket, arr, sizeof(int)*len);  
  34.   
  35.         radix *= 10;  
  36.     }  
  37. }  
  38. void Printf(int *arr,int len)  
  39. {  
  40.     for (int i = 0; i < len; ++i)  
  41.     {  
  42.         printf(" %d ", arr[i]);  
  43.     }  
  44.     printf("\n");  
  45. }  
  46. int main()  
  47. {  
  48.     int arr[] = {10,8,1,4,6,5,0,10,9};  
  49.     int len = sizeof(arr) / sizeof(arr[0]);  
  50.     //BubbleSort(arr, len);  
  51.     //SelectSort1(arr, len);  
  52.     //QuickSort(arr, len);  
  53.     //QuickSort_NonR(arr,len);  
  54.     //InsertSort(arr, len);  
  55.     //ShellSort(arr,len);  
  56.         //HeapSort(arr,len);  
  57.     //MergeSort(arr,len);  
  58.     //CountSort(arr,len);  
  59.     //RadixSort_LSD(arr,len);  
  60.     Printf(arr,len);  
  61.     return 0;  
  62. }  


 

 

 

posted @ 2017-08-31 15:31  G-Beniot  阅读(788)  评论(0)  编辑  收藏  举报