[转载]浅谈各种排序

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

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

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

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

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

1.冒泡排序

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

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

　　实现：

#include <stdio.h>
#include <stdlib.h>
int a[10000];
int n;/* 共有 n 个需要排序的数 */
void input(){
    int i;
    scanf("%d", &n);
    for(i = 0;i < n;++i){
　　    scanf("%d", &a[i]);
    }
    return ;
}
void output(){
    /* 将排序好的结果输出，以验证 */
    int i;
    for(i = 0;i < n; ++i){
　　    fprintf(stdout,"%d ",a[i]);
    }
    printf("\n");
    return ;
}
void bubble_sort(){
    int i, j;
    for(i = 0;i < n;++i){/* 执行n此迭代 */
 　　   for(j = 0;j < n-i-1; ++j){/* 比较相邻两个数，判断是否互换 */
    　　    if(a[j] > a[j+1]){
    　　　　    int temp = a[j];
  　　　　      a[j] = a[j+1];
  　　 　　     a[j+1] = temp;
 　　       }
　　    }
    }
}
int main(){
    input();
    bubble_sort();
    output();
    exit(0);
}

 

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

 

2. 插入排序：

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

　　实现：

　　

/* 插入排序 */
void insertion_sort(){
    int i;
    for(i = 0;i < n; ++i){
    　　int temp;
   　　 scanf("%d", &temp);
   　　 a[i] = temp;
　　    int j;
   　　 /* 每次输入一个数字，都进行比较 */
  　　  for(j = 0; j < i; ++j){
  　　      if(temp < a[j]){/* 找到前面 <= 它，后面 > 它的位置 */
     　　   　　int k = i;
        　　　　/* 因为是数组，所以需要每位后移，个人猜想用链表实现，会优化许多 */
        　　　　for(;k > j; --k){
            　　　　a[k] = a[k-1];
        　　　　}
     　　  　　 a[j] = temp;
       　　　　 break;
   　　     }
 　　   }
    }
    return ;
}

 

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

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

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

3. 选择排序

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

　　实现：

#define MAX 0xfffffff
void selection_sort(){
    int aim[10000];
    int i;
    int min = MAX;/* 每次选出的最小值 */
    for(i = 0;i < n;++i){
    　　int j;
   　　 int temp;/* 记录最小值的下标，以便修改其值*/
  　　  for(j = 0;j < n;++j){ /* 选出数组中的最小值 */
     　　   if(a[j] < min){
    　　 　　   min = a[j];
   　　   　　  temp = j;
 　　       }
　　    }　　
　　    a[temp] = MAX;
 　　   aim[i] = min;
　　    min = MAX;
    }
    /* 将排序好的结果输出，以验证 */
    for(i = 0;i < n; ++i){
 　　   fprintf(stdout,"%d ",aim[i]);
    }
    printf("\n");
    return ;
}

 

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

4. 快速排序

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

　　实现：

/* 此代码来自《代码之美》，个人以为，确实是非常美 */
void quick_sort(int l, int u){/* l是较低的下标，u是较高的下标 */
    int i, m;
    if(l >= u) return;
    swap(l, randint(l, u));/* swap(i,j)是交换a[i],a[j]，i,j不变 */
    m = l;/* 从与第一个值比较，小的放左边，大的放右边 */
    for(i = l+1; i <= u; ++i)
 　　   if(a[i] < a[l])
    　　    swap(++m, i);
    swap(l, m);/* 将第一个值放在它该在的地方 */
    quick_sort(l, m-1);/* 递归 */
    quick_sort(m+1, u);
}

 

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

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

5. 堆排序

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

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

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

　　实现：

void adjust(int ind, int len){
         /* 置i为要筛选的节点 */
        int i = ind;
        /* c中保存i节点的左孩子 */
     /* +1的目的就是为了解决节点从0开始而他的左孩子一直为0的问题 */
        int c = i * 2 + 1; 
        while(c < len){/* 未筛选到叶子节点 */
                /* 如果要筛选的节点既有左孩子又有右孩子并且左孩子值小于右孩子 */
                /* 从二者中选出较大的并记录 */
                if(c + 1 < len && a[c] < a[c + 1])
                        c++;
                /* 如果要筛选的节点中的值大于左右孩子的较大者则退出 */
                if(a[i] > a[c]) break;
                else{
                        /* 交换 */
                        int temp = a[c];
                        a[c] = a[i];
                        a[i] = temp;
                        /* 重置要筛选的节点和要筛选的左孩子 */
                        i = c;
                        c = 2 * i + 1;
                }
         }
        return;
}
 
void heap_sort(int n){
        /* 初始化建堆, i从最后一个非叶子节点开始 */
        for(int i = n / 2; i >= 0; i--)
                adjust(i, n);
        for(int j = 0; j < n; j++){
                /* 交换 */
                int t = a[0];
                a[0] = a[n - j - 1];
                a[n - j - 1] = t;
                /* 筛选编号为0 */
                adjust(0, n - j - 1);
         }
}

 

 

　　时间复杂度nlog(n)。

6. 归并排序

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

　　实现：

void merge(int first, int mid, int last){/* 两个有序数组分别是a[first...mid]和a[mid+1...last] */
    int temp[last - first + 1];/* 新的有序数组 */
    int i, j, k=0;
    for(i = first, j = mid + 1; i <= mid && j <=last ;){
        if(a[i] < a[j]){
            temp[k++] = a[i++]; 
        }else{
            temp[k++] = a[j++];
        }
        if(i == mid + 1){
            while(j <= last)
                temp[k++] = a[j++];
            break;
        }else if(j == last + 1){
            while(i <=mid)
                temp[k++] = a[i++];
            break;
        }
    }
    for(i = 0; i < k; i++)/* 把排好序的数组，放回这些数据该在的地方 */
        a[first + i] = temp[i];
}
void merge_sort(int first, int last){
    if(first < last){
        int mid = (first + last) / 2;
        /*传说中的分治法*/
        merge_sort(first, mid);
        merge_sort(mid + 1, last);
        merge(first, mid, last);/* 合并 */
    }    
}

 

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

7. 基数排序

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

　　实现：

/* 此代码来此维基百科，我没能写出来。。。 */
#include <iostream>
 
using namespace std;
 
const int base=10;
 
struct wx
{
        int num;
        wx *next;
        wx()
        {
                next=NULL;
        }
};
 
wx *headn,*curn,*box[base],*curbox[base];
 
void basesort(int t)
{
        int i,k=1,r,bn;
        for(i=1;i<=t;i++)
        {
                k*=base;
        }
        r=k*base;
        for(i=0;i<base;i++)
        {
                curbox[i]=box[i];
        }
        for(curn=headn->next;curn!=NULL;curn=curn->next)
        {
                bn=(curn->num%r)/k;
                curbox[bn]->next=curn;
                curbox[bn]=curbox[bn]->next;
        }
        curn=headn;
        for(i=0;i<base;i++)
        {
                if(curbox[i]!=box[i])
                {
                        curn->next=box[i]->next;
                        curn=curbox[i];
                }
        }
        curn->next=NULL;
}
 
void printwx()
{
        for(curn=headn->next;curn!=NULL;curn=curn->next)
        {
                cout<<curn->num<<' ';
        }
        cout<<endl;
}
 
int main()
{
        int i,n,z=0,maxn=0;
        curn=headn=new wx;
        cin>>n;
        for(i=0;i<base;i++)
        {
                curbox[i]=box[i]=new wx;
        }
        for(i=1;i<=n;i++)
        {
                curn=curn->next=new wx;
                cin>>curn->num;
                maxn=max(maxn,curn->num);
        }
        while(maxn/base>0)
        {
                maxn/=base;
                z++;
        }
        for(i=0;i<=z;i++)
        {
                basesort(i);
        }
        printwx();
        return 0;
}

 

 

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

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

　　实现：

void counting_sort(){
    int i;
    int b[100001];/* 只能排序100000以下的数字 */
    memset(b, 0 ,sizeof(b));/* 临时存储区 */
    int max = -1; /* 记录需要排序的最大数 */
    int min = 0xffffffff;/* 记录需要排序的最小数 */
    for(i = 0; i < n; ++i){
        b[a[i]]++;/* 核心的就这一句 */
        max = a[i] > max ? a[i] : max;
        min = a[i] < min ? a[i] : min;
    }
    int k = 0;
    for(i = min ; i <= max; ++i){/* 按顺序将排序的数还原出来 */
        while(b[i]--)
            a[k++]=i;
    }
}

 

在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 在此提前说声抱歉。

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