浅谈各种排序

排序的现实意义每个人都知道，今日突然对各种排序算法产生了兴趣，于是谈下我所接触到的一些排序算法：

选择，插入，冒泡，快排，堆排，归并，基数，计数，bogo。

代码除个别都由本人所写，若有 bug 请您指正。

个人建议，一定要看看计数排序，别的快排和归并排想法也很好。选择和插入很基本，也是最容易理解的，最逆天的就是 bogo 了，一定要看哦！！

注：将input函数和output函数还有主函数写在了冒泡里，以后就直接写排序函数的代码了，其他部分的代码的输入输出函数、主函数和冒泡排序基本一致。

1.冒泡排序

　　描述：依次比较相邻的两个数，将小数放在前面，大数放在后面。这样每次都能将最大的数放在最后，多次迭代，一个有序的序列就出来了～～

　　　　其实冒泡排序就是选择排序，而且还比选择多比较了很多次。

　　实现：

 1 #include <stdio.h>

 2 #include <stdlib.h>

 3 int a[10000];

 4 int n;/* 共有 n 个需要排序的数 */

 5 void input(){

 6     int i;

 7     scanf("%d", &n);

 8     for(i = 0;i < n;++i){

 9 　　    scanf("%d", &a[i]);

10     }

11     return ;

12 }

13 void output(){

14     /* 将排序好的结果输出，以验证 */

15     int i;

16     for(i = 0;i < n; ++i){

17 　　    fprintf(stdout,"%d ",a[i]);

18     }

19     printf("\n");

20     return ;

21 }

22 void bubble_sort(){

23     int i, j;

24     for(i = 0;i < n;++i){/* 执行n此迭代 */

25  　　   for(j = 0;j < n-i-1; ++j){/* 比较相邻两个数，判断是否互换 */

26     　　    if(a[j] > a[j+1]){

27     　　　　    int temp = a[j];

28   　　　　      a[j] = a[j+1];

29   　　 　　     a[j+1] = temp;

30  　　       }

31 　　    }

32     }

33 }

34 int main(){

35     input();

36     bubble_sort();

37     output();

38     exit(0);

39 }

 

　　时间复杂度为n方，基本不需要额外空间。

 

2. 插入排序：

　　描述：想法非常简单，就像抓牌一样，来一张牌，把它放在前面 <= 它、后面 > 它的地方。当所有牌都抓完之后，自然就是一手有序的牌了。

　　实现：

　　

 1 /* 插入排序 */

 2 void insertion_sort(){

 3     int i;

 4     for(i = 0;i < n; ++i){

 5     　　int temp;

 6    　　 scanf("%d", &temp);

 7    　　 a[i] = temp;

 8 　　    int j;

 9    　　 /* 每次输入一个数字，都进行比较 */

10   　　  for(j = 0; j < i; ++j){

11   　　      if(temp < a[j]){/* 找到前面 <= 它，后面 > 它的位置 */

12      　　   　　int k = i;

13         　　　　/* 因为是数组，所以需要每位后移，个人猜想用链表实现，会优化许多 */

14         　　　　for(;k > j; --k){

15             　　　　a[k] = a[k-1];

16         　　　　}

17      　　  　　 a[j] = temp;

18        　　　　 break;

19    　　     }

20  　　   }

21     }

22     return ;

23 }

 

　　时间复杂度，毫无疑问的 n 方的。

　　空间上基本上都是没有什么大的消耗了。

　　用链表实现的话，在最优情况时间复杂度可以达到O(n)的，不过我写的太弱了。

3. 选择排序

　　描述：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好的数列的最后，直到全部待排序的数据元素排完。

　　实现：

 1 #define MAX 0xfffffff

 2 void selection_sort(){

 3     int aim[10000];

 4     int i;

 5     int min = MAX;/* 每次选出的最小值 */

 6     for(i = 0;i < n;++i){

 7     　　int j;

 8    　　 int temp;/* 记录最小值的下标，以便修改其值*/

 9   　　  for(j = 0;j < n;++j){ /* 选出数组中的最小值 */

10      　　   if(a[j] < min){

11     　　 　　   min = a[j];

12    　　   　　  temp = j;

13  　　       }

14 　　    }　　

15 　　    a[temp] = MAX;

16  　　   aim[i] = min;

17 　　    min = MAX;

18     }

19     /* 将排序好的结果输出，以验证 */

20     for(i = 0;i < n; ++i){

21  　　   fprintf(stdout,"%d ",aim[i]);

22     }

23     printf("\n");

24     return ;

25 }

 

　　时间复杂度 n方，空间需要多开一个数组，来存放目标数据。

4. 快速排序

　　描述：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的数据要小，然后再按此方法对这两部分分别递归进行快速排序，然后使整个数组变成有序序列。

　　实现：

 1 /* 此代码来自《代码之美》，个人以为，确实是非常美 */

 2 void quick_sort(int l, int u){/* l是较低的下标，u是较高的下标 */

 3     int i, m;

 4     if(l >= u) return;

 5     swap(l, randint(l, u));/* swap(i,j)是交换a[i],a[j]，i,j不变 */

 6     m = l;/* 从与第一个值比较，小的放左边，大的放右边 */

 7     for(i = l+1; i <= u; ++i)

 8  　　   if(a[i] < a[l])

 9     　　    swap(++m, i);

10     swap(l, m);/* 将第一个值放在它该在的地方 */

11     quick_sort(l, m-1);/* 递归 */

12     quick_sort(m+1, u);

13 }

 

　　时间复杂度：期望时间 O(n log n) , 最坏情况O(n²) ; 对于大的、乱数列表一般公认是最快的已知排序

　　之所以会是log n，是由于二分了。。。

5. 堆排序

　　描述：堆排序就像是选择排序一样，每次都是选出最大或最小的值。不过选出最大或最小的值的方法不是线性的去找出来，而是用一种特殊的数据结构——堆，来管理算法执行中的信息。

　　堆是一个近似完全二叉树的结构，并同时满足堆的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。小于的就是小顶堆，大的就是大顶堆。于是就要建堆，调整出一个顶堆，然后把顶点的值取出来，再调整，再取，直到所有的元素都被取出来，一个有序的序列就出来了。

　　调整就是为了满足堆的性质。我们假定左右两颗子树都是大顶堆。但这时，顶点的值可能小于其孩子，于是就违反了大顶堆的性质，所以就和孩子中大的那个换一下位置，然后再递归判断两个子树的，然后再递归。最后就调整出一个大顶堆啦～～

　　实现：

 1 void adjust(int ind, int len){

 2          /* 置i为要筛选的节点 */

 3         int i = ind;

 4         /* c中保存i节点的左孩子 */

 5      /* +1的目的就是为了解决节点从0开始而他的左孩子一直为0的问题 */

 6         int c = i * 2 + 1; 

 7         while(c < len){/* 未筛选到叶子节点 */

 8                 /* 如果要筛选的节点既有左孩子又有右孩子并且左孩子值小于右孩子 */

 9                 /* 从二者中选出较大的并记录 */

10                 if(c + 1 < len && a[c] < a[c + 1])

11                         c++;

12                 /* 如果要筛选的节点中的值大于左右孩子的较大者则退出 */

13                 if(a[i] > a[c]) break;

14                 else{

15                         /* 交换 */

16                         int temp = a[c];

17                         a[c] = a[i];

18                         a[i] = temp;

19                         /* 重置要筛选的节点和要筛选的左孩子 */

20                         i = c;

21                         c = 2 * i + 1;

22                 }

23          }

24         return;

25 }

26  

27 void heap_sort(int n){

28         /* 初始化建堆, i从最后一个非叶子节点开始 */

29         for(int i = n / 2; i >= 0; i--)

30                 adjust(i, n);

31         for(int j = 0; j < n; j++){

32                 /* 交换 */

33                 int t = a[0];

34                 a[0] = a[n - j - 1];

35                 a[n - j - 1] = t;

36                 /* 筛选编号为0 */

37                 adjust(0, n - j - 1);

38          }

39 }

 

 

　　时间复杂度nlog(n)。

6. 归并排序

　　描述：有两个有序序列，把它们合并成一个，很简单是吧。只要把比较两个序列第一个数的大小，然后取小的放到新的序列里，原来的序列中删除这个数，再比，直到一个序列的所有元素都空了，把另一个序列剩余的全都放过去。一个新的有序序列就成了～～，归并排序基于的就是这个原理，用分治法的思想，递归的排序出来。

　　实现：

 1 void merge(int first, int mid, int last){/* 两个有序数组分别是a[first...mid]和a[mid+1...last] */

 2     int temp[last - first + 1];/* 新的有序数组 */

 3     int i, j, k=0;

 4     for(i = first, j = mid + 1; i <= mid && j <=last ;){

 5         if(a[i] < a[j]){

 6             temp[k++] = a[i++]; 

 7         }else{

 8             temp[k++] = a[j++];

 9         }

10         if(i == mid + 1){

11             while(j <= last)

12                 temp[k++] = a[j++];

13             break;

14         }else if(j == last + 1){

15             while(i <=mid)

16                 temp[k++] = a[i++];

17             break;

18         }

19     }

20     for(i = 0; i < k; i++)/* 把排好序的数组，放回这些数据该在的地方 */

21         a[first + i] = temp[i];

22 }

23 void merge_sort(int first, int last){

24     if(first < last){

25         int mid = (first + last) / 2;

26         /*传说中的分治法*/

27         merge_sort(first, mid);

28         merge_sort(mid + 1, last);

29         merge(first, mid, last);/* 合并 */

30     }    

31 }

 

　　时间复杂度 O(n log n)，需要 O(n)的额外空间。

7. 基数排序

　　描述：原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。我理解的还是不够深。。。

　　实现：

 1 /* 此代码来此维基百科，我没能写出来。。。 */

 2 #include <iostream>

 3  

 4 using namespace std;

 5  

 6 const int base=10;

 7  

 8 struct wx

 9 {

10         int num;

11         wx *next;

12         wx()

13         {

14                 next=NULL;

15         }

16 };

17  

18 wx *headn,*curn,*box[base],*curbox[base];

19  

20 void basesort(int t)

21 {

22         int i,k=1,r,bn;

23         for(i=1;i<=t;i++)

24         {

25                 k*=base;

26         }

27         r=k*base;

28         for(i=0;i<base;i++)

29         {

30                 curbox[i]=box[i];

31         }

32         for(curn=headn->next;curn!=NULL;curn=curn->next)

33         {

34                 bn=(curn->num%r)/k;

35                 curbox[bn]->next=curn;

36                 curbox[bn]=curbox[bn]->next;

37         }

38         curn=headn;

39         for(i=0;i<base;i++)

40         {

41                 if(curbox[i]!=box[i])

42                 {

43                         curn->next=box[i]->next;

44                         curn=curbox[i];

45                 }

46         }

47         curn->next=NULL;

48 }

49  

50 void printwx()

51 {

52         for(curn=headn->next;curn!=NULL;curn=curn->next)

53         {

54                 cout<<curn->num<<' ';

55         }

56         cout<<endl;

57 }

58  

59 int main()

60 {

61         int i,n,z=0,maxn=0;

62         curn=headn=new wx;

63         cin>>n;

64         for(i=0;i<base;i++)

65         {

66                 curbox[i]=box[i]=new wx;

67         }

68         for(i=1;i<=n;i++)

69         {

70                 curn=curn->next=new wx;

71                 cin>>curn->num;

72                 maxn=max(maxn,curn->num);

73         }

74         while(maxn/base>0)

75         {

76                 maxn/=base;

77                 z++;

78         }

79         for(i=0;i<=z;i++)

80         {

81                 basesort(i);

82         }

83         printwx();

84         return 0;

85 }

 

 

　　时间复杂度是 O(k*n)的，k是数字位数。

8. 计数排序
　　描述：这是我最喜欢的排序算法了，典型的用空间换时间的。一看代码就知道了。

　　实现：

 1 void counting_sort(){

 2     int i;

 3     int b[100001];/* 只能排序100000以下的数字 */

 4     memset(b, 0 ,sizeof(b));/* 临时存储区 */

 5     int max = -1; /* 记录需要排序的最大数 */

 6     int min = 0xffffffff;/* 记录需要排序的最小数 */

 7     for(i = 0; i < n; ++i){

 8         b[a[i]]++;/* 核心的就这一句 */

 9         max = a[i] > max ? a[i] : max;

10         min = a[i] < min ? a[i] : min;

11     }

12     int k = 0;

13     for(i = min ; i <= max; ++i){/* 按顺序将排序的数还原出来 */

14         while(b[i]--)

15             a[k++]=i;

16     }

17 }

 

在k以内的数，时间复杂库为O(n)，O(n)有木有啊，还容易实现，我最喜欢了，就是太需要空间了。

9. bogo 排序

　　描述：这个排序是真的超神了，想象一下，把一副扑克向天上一扔，掉桌子上后收拾收拾，看看是不是顺序的，不是的话再扔。。。。

　　实现：真心不会。。。。

　　时间复杂度维基百科上说是其平均时间复杂度是 O(n × n!)，在最坏情况所需时间是无限。

　　据说在量子计算机里，这个算法是O(1)的，表示不明原理。

附上维基百科上排序的链接：https://zh.wikipedia.org/wiki/%E6%8E%92%E5%BA%8F

 

还有很多我没有听说过，根本不会的。。。继续努力吧

 

声明：

　　本文为 iddmx 对自己所学的排序算法的整理和实现。

　　本文档欢迎自由转载，但请务必保持本文档完整或注明来之本文档。本文档未经 iddmx 同意，不得用于商业用途。最后，如果您能从这个简单文档里获得些许帮助，iddmx 将对自己的一点努力感到非常高兴；iddmx 水平有限，如果本文档中包含的错误给您造成了不便，iddmx 在此提前说声抱歉。

　　祝身体健康，工作顺利。☺