线性时间排序(计数排序、基数排序、桶排序)

最新推荐文章于 2020-11-14 16:56:25 发布

rock_joker

最新推荐文章于 2020-11-14 16:56:25 发布

阅读量567

点赞数

分类专栏：数据结构与算法

数据结构与算法专栏收录该内容

16 篇文章 0 订阅

订阅专栏

转载:http://blog.csdn.net/luoshixian099/article/details/45043337

线性时间排序

前面介绍的几种排序，都是能够在复杂度nlog(n)时间内排序n个数的算法，这些算法都是通过比较来决定它们的顺序，这类算法叫做比较排序 。下面介绍的几种算法用运算去排序，且它们的复杂度是线性时间[线性时间指的就是O(n)]。

——————————————————————————————————————

1.计数排序

计数排序采用的方法是：对每个元素x，去确定小于x的元素的个数，从而就可以知道元素x在输出数组中的哪个位置了。

计数排序的一个重要性质是它是稳定的，即对于相同的两个数，排序后，还会保持它们在输入数组中的前后顺序，这也是下面基数排序的基础。

虽然复杂度比之间的算法减小了，但在算法实现过程中，它要求输入数组数据位于一个区间[0,k]内，因为要遍历数组，计算[0,k]间的每个数在输入数组中的个数，这也算是计数排序的缺点吧！
下面是调试的程序，可直接运行，详细过程看下《算法导论》

[cpp]view plaincopy 
    
print?
 #include<STDIO.H>  
 #define  K 10                   //数据在[0,K]之间    
 int A[]={2,7,3,5,3,2,9};  
 int B[20]={0};                  //输出数组  
 int C[20]={0};                  //计数数组  
 int Length=sizeof(A)/sizeof(A[0])-1;           
 void Count_Sort(int *A,int *B,int k)  
 {  
    int j;  
    for (j=0;j<=Length;j++)       //为每个数计个数  
    {  
        C[A[j]]=C[A[j]]+1;  
    }  
   
    for (j=1;j<=K;j++)           //计算有多少元素小于等于j  
    {  
        C[j]=C[j]+C[j-1];  
    }  
   
    for (j=Length;j>=0;j--)      //倒叙输出数组，保证了数据是稳定的    
    {  
        B[C[A[j]]]=A[j];  
        C[A[j]]=C[A[j]]-1;     //A[j]输出，对应计数数组元素减1。  
    }  
 }  
 int main()  
 {      
     int i;  
     Count_Sort(A,B,K);  
     for (i=1;i<=Length+1;i++)  
     {  
         printf("%3d",B[i]);  
     }  
     printf("\n");  
     return 0;  
 }  

———————————————————————————————————

2.基数排序

基本思想：对N个d位的数据排序，与传统的想法不同，它是先从最低有效位开始排。

这里必须保证每次排序是稳定的，即对相同的数据，输出的顺序必须与输入的顺序相同。

基数排序介绍

基数排序能达到线性的时间复杂度。
基数排序的主要思路是,将所有待比较数值( 注意,必须是正整数)

统一为同样的数位长度,数位较短的数前面补零. 然后, 从最低位开始, 依次进行一次稳定排序
所以这里的排序可以使用计数排序。
这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列.

为什么要从低位开始向高位排序?

如果要从高位排序, 那么次高位的排序会影响高位已经排好的大小关系. 在数学中, 数位越高,数位值对数的大小的影响就越大

为什么同一数位的排序子程序要使用稳定排序?

稳定排序能保证,上一次的排序成果被保留,十位数的排序过程能保留个位数的排序成果,百位数的排序过程能保留十位数的排序成果.

实现例程：

[cpp]view plaincopy 
    
print?
 #include <STDIO.H>  
 #include <string.h>  
 int A[]={329,457,657,839,436,720,355};    //要排序的数组  
 int Length=sizeof(A)/sizeof(A[0])-1;  
 void Count_Sort(int *A2,int *B)    //计数排序  
 {  
     int j;  
     int C[10]={0};                 //计数数组,数字在[0,9]之间  
     for (j=0;j<=Length;j++)       //为每个数计个数  
     {  
         C[A2[j]]=C[A2[j]]+1;  
     }  
       
     for (j=1;j<=10;j++)           //计算有多少元素小于等于j  
     {  
         C[j]=C[j]+C[j-1];  
     }  
       
     for (j=Length;j>=0;j--)      //倒叙输出数组，保证了数据是稳定的    
     {  
         B[C[A2[j]]]=A[j];       //参照C[A2[j]]的大小，对数组A[j]输出  
         C[A2[j]]=C[A2[j]]-1;  
     }  
 }  
   
 void Radix_Sort(int *A,int d)  
 {   
     int i,j,k,temp;  
     int A2[10]={0};               //存放各个位  
     int B[20]={0};                  //输出数组  
    for(i=1;i<=d;i++)  
    {  
          
        for (j=0;j<=Length;j++)  
        {  
            temp=A[j];  
            k=i;  
             while(k>1)  
             {  
                 temp=temp/10;  
                 k--;  
             }  
             A2[j]=temp%10;      //取指定的位存到A2[j]，等待排序  
        }  
        Count_Sort(A2,B);  
        memcpy(A,&B[1],(Length+1)*4);     
    }        
 }  
 int main()  
 {  
    int j;  
    Radix_Sort(A,3);  
    for (j=0;j<=Length;j++)  
    {  
        printf("%5d\n",A[j]);  
    }  
   
 }  

———————————————————————————————————————————————————————————————————————————

3.桶排序

桶排序是假设输入数据服从均匀分布，平均情况下也是线性时间。假设输入数据是由一个随机过程产生，该过程将元素均匀，独立地分布在[0,1）区间上。

它将[0,1)区间划分为n个相同大小的子区间，称为“桶”，然后遍历输入的数据，分别放入到指定的桶中（放入桶中的同时，有个链表插入排序的过程）。最后依次把各个桶中数据输出即可。

例程：

[cpp]view plaincopy 
    
print?
 #include <STDIO.H>  
 #include <STDLIB.H>  
 int A[]={78,17,39,26,72,94,21,12,23,68};//假如输入数据平均分布在[0,99]区间内  
 int Length = sizeof(A)/sizeof(A[0])-1;  
 typedef struct Node      //链表单元结构  
 {  
    int num;  
    struct Node *next;  
 }Node;   
 Node *Bucket[10]={0};       //分成10个桶，即10个小区间  
 void Bucket_Sort(int *A)  
 {  
    int i;  
    int a;  
    Node * temp=NULL,*Pre_temp=NULL;  
    for (i=0;i<=Length;i++)               //遍历输入数组，放入到指定的桶中  
    {  
        a = (int)(A[i]/10);  
        if(Bucket[a] == 0)                 
        {  
           Bucket[a]=(Node *)malloc(sizeof(Node));  
           Bucket[a]->num=A[i];  
           Bucket[a]->next=NULL;  
        }  
        else                                 //对非空链表插入排序  
        {     
            temp=Pre_temp=Bucket[a];  
            while(A[i] > temp->num)  
            {    
               Pre_temp=temp;  
               temp=temp->next;  
               if (temp==NULL)  
                 break;  
            }  
   
            if (temp == NULL)            // 插入到最后一个位置  
            {  
                temp=(Node *)malloc(sizeof(Node));  
                temp->num=A[i];  
                temp->next=NULL;  
                Pre_temp->next=temp;  
            }  
            else if (temp == Bucket[a])  //插入到第一个位置  
            {  
                temp=(Node *)malloc(sizeof(Node));  
                temp->num=A[i];  
                temp->next=Bucket[a];  
                Bucket[a]=temp;  
            }  
            else                         //插入到中间位置  
            {  
                temp=(Node *)malloc(sizeof(Node));  
                temp->num=A[i];  
                temp->next=Pre_temp->next;  
                Pre_temp->next=temp;      
            }  
        }  
          
    }  
      
      
 }  
 void Free_List(Node * head)      //释放链表结构内存  
 {  
     Node *N=head;  
      while (head!=NULL)  
      {  
          N=head->next;  
          free(head);  
          head=N;  
      }  
 }  
 int main()  
 {  
     Node * temp=NULL;  
     int i=1;  
     Bucket_Sort(A);  
     for(i=0;i<=9;i++)   //依次输出各个桶中的数据  
     {   
         temp=Bucket[i];  
         while(temp!=NULL)  
         {  
             printf("%3d\n",temp->num);  
             temp=temp->next;  
         }  
         Free_List(Bucket[i]);  //释放第i个桶的内存  
     }  
     return 0;  
 }  