桶排序_桶排序怎么保证稳定-CSDN博客

【1】桶排序

桶排序（也称箱排序），据坊间演绎，其实现方式有很多。

在此我们仅仅阐述一下本文的实现思想，以便于更好的理解下面的内容，同时加深对桶排序的认识。

首先，说明一点，我们是使用数组模拟桶（最好应该是使用链表模拟）。

所谓数组模拟桶实现排序的过程到底是怎么进行的呢？呵呵！其实还真有点抽象。

实现步骤如下：

（1）定义映射函数

<1>求得欲排数据序列中的最大数据。

<2>通过遍历欲排数据对每个数据乘以10再与最大数据取余，求得每个数据对应桶的索引（或称关键字）。

（2）求得每个桶中盛放的数据个数（为了保证随后准确分配数据）

（3）求得每个桶盛放数据个数的右边界索引（所谓的桶逻辑控制）

（4）从右向左（确保稳定性）扫描欲排数据序列，依次分配到对应桶中

（5）对各桶中所盛数据进行收集

（6）利用插入排序再对各个桶中所盛数据进行排序

（7）直至排序结束，即为已排序数据序列

其实，整个过程再讲通俗一点，可以如下描述：

建立一个数组作为我们的所谓的桶（逻辑桶）

然后，申请开辟与欲排数据所占空间相同的内存，作为真正的盛放数据的桶（物理桶）

数组的索引默认为桶号

对数组的每一次赋值都有着不同的意义（请参考代码分析）

最后再用插入排序对各桶中所收集数据分别进行排序。即完成桶排序。

总而言之：先分类，后收集，再排序。

【2】示例代码及其分析过程

#include<iostream>
#include<malloc.h>
using namespace std;


void  PrintArr(int ar[],int n)
{
    for(int i = 0; i < n; ++i)
        cout<<ar[i]<<" ";
    cout<<endl;
}

int MapToIndex(int x,int max)  
{  
    return (10 * x) / max;  
} 

void insertion_sort(int arr[],int begin,int end)
{
    for(int i = begin+1; i <= end; ++i)
    {
        int v = arr[i];
        int j = i;
        while(j-1 >= begin && v<arr[j-1])
        {
            arr[j--] = arr[j-1];  
        }
        arr[j] = v;
    }
} 

void bucket_sort(int ar[], int begin, int end)  
{  

    const int radix = 11 ;  //注意：为什么是11？
    int count[radix], i, j;    
    int size = end-begin+1;

    //计数值置空
    for(i = 0; i < radix; ++i)  
    {
        count[i] = 0;    //置空
    }
    
    //end-begin+1 = 9 - 0 + 1 = 10
    int *Temp = (int *) malloc((size) * sizeof(int));     //分配临时空间

    //取得当前待排序数据中的最大数据
    int max = 0;  
    for(i = begin; i < size; ++i)  
    {  
        if(ar[i] > max)  
            max = ar[i];  
    }  

    //统计各桶需要装的元素的个数  
    for(i = begin; i < size; ++i)   
    {
        count[MapToIndex(ar[i], max)]++;   
    }
          
    //输出计数结果：
    PrintArr(count, radix);

    //求出桶的边界索引，count[i]为第i个桶的右边界索引+1   
    for(i = 1; i < radix; ++i)   
    {
        count[i] = count[i] + count[i-1];  
    }

    //输出桶边界索引        
    PrintArr(count, radix);

    //从右向左扫描，保证排序稳定性   
    for(i = end; i >= begin; --i)             
    {    
        j = MapToIndex(ar[i], max);        
        Temp[count[j]-1] = ar[i];  //放入对应的空间中，count[j]-1是第j个桶的右边界索引   
        --count[j];       //准备放置下一个元素的位置索引   
    }     

    for(int i = 0; i < size; ++i)
    {
        cout<<Temp[i]<<"  ";
    }
    cout<<endl;

    PrintArr(count, radix);

    //从各个桶中收集数据   
    for(i = begin, j = 0; i < size; i++, j++)  
    {
        ar[i] = Temp[j];        
    }
    
    PrintArr(ar, end+1);

     //释放空间  
    free(Temp);                          
    
    for(i = 0; i < size; i++)  
    {   
        int index1 = begin + count[i];             //得到第i个桶的左边界   
        int index2 = begin + count[i+1] - 1;       //得到第i个桶的右边界   
        if(index1 < index2)  
            insertion_sort(ar, index1, index2);          
    }  
}  

void  main()
{
    int  ar[] = {12, 14, 54, 5, 6, 3, 9, 8, 47, 89};
    int len = sizeof(ar)/sizeof(int);
    bucket_sort(ar, 0, len-1);
    PrintArr(ar, len);

    getchar();

    getchar();

}
/*
4 3 0 0 0 1 1 0 0 0 1
4 7 7 7 7 8 9 9 9 9 10
5  6  3  8  12  14  9  47  54  89
0 4 7 7 7 7 8 9 9 9 9
5 6 3 8 12 14 9 47 54 89
3 5 6 8 9 12 14 47 54 89
*/

（2）分析过程如下：

学过数据结构的估计都可以想象得到：桶排序中所谓的桶应该是用一个单链表实现

因为，我们一直觉得，计算机世界就是对现实世界的模拟。那么，既然是山寨，当然越逼真越好

但是，假如我们没有学习过单链表，脑子里面根本没有单链表的概念。而且，我们要实现桶排序。

好吧！我唯一可以借助的就是数组。

不过数组模拟桶实现桶排序的确不是很好理解，有几分抽象

上面这就是一个用数组模拟桶实现的桶排序示例代码，现在做一下具体分析，希望可以更深刻理解桶排序。

分析过程如下：

（1）待排序数据序列为：