1）算法简介

桶排序 (Bucket sort)或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序）。

桶排序是稳定的，且在大多数情况下常见排序里最快的一种,比快排还要快，缺点是非常耗空间,基本上是最耗空间的一种排序算法，而且只能在某些情形下使用。

2）算法描述和分析

桶排序具体算法描述如下：
1、设置一个定量的数组当作空桶子。
2、寻访串行，并且把项目一个一个放到对应的桶子去。
3、对每个不是空的桶子进行排序。
4、从不是空的桶子里把项目再放回原来的串行中。

桶排序最好情况下使用线性时间O(n)，很显然桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为 其它部分的时间复杂度都为O(n);很显然，桶划分的越小，各个桶之间的数据越少，排 序所用的时间也会越少。但相应的空间消耗就会增大。

可以证明，即使选用插入排序作为桶内排序的方法，桶排序的平均时间复杂度为线性。 具体证明，请参考算法导论。其空间复杂度也为线性。

3）算法图解、flash演示、视频演示

图解

Flash：
可以参考http://ds.fzu.edu.cn/fine/resources/FlashContent.asp?id=90中的过程

视频：
这里就不给出桶排序的视频了，见上flash吧

4）算法代码

#include <time.h>  
#include <iostream>  
#include <iomanip>  
using namespace  std;  
  
/*initial arr*/  
void InitialArr(double *arr,int n) {  
    srand((unsigned)time(NULL));  
    for (int i = 0; i<n;i++) {  
        arr[i] = rand()/double(RAND_MAX+1);   //(0.1)  
    }  
}  
  
/* print arr*/  
void PrintArr(double *arr,int n) {  
    for (int i = 0;i < n; i++) {  
        cout<<setw(15)<<arr[i];  
        if ((i+1)%5 == 0 || i ==  n-1) {  
            cout<<endl;  
        }  
    }  
}  
  
void BucketSort(double * arr,int n) {  
    double **bucket = new double*[10];  
    for (int i = 0;i<10;i++) {  
        bucket[i] = new double[n];  
    }  
    int count[10] = {0};  
    for (int i = 0 ; i < n ; i++) {  
        double temp = arr[i];  
        int flag = (int)(arr[i]*10); //flag标识小树的第一位   
        bucket[flag][count[flag]] = temp; //用二维数组的每个向量来存放小树第一位相同的数据  
        int j = count[flag]++;  
  
        /* 利用插入排序对每一行进行排序 */  
        for(;j > 0 && temp < bucket[flag][j - 1]; --j) {  
            bucket[flag][j] = bucket[flag][j-1];  
        }  
        bucket[flag][j] =temp;  
    }  
  
    /* 所有数据重新链接 */  
    int k=0;  
    for (int i = 0 ; i < 10 ; i++) {  
        for (int j = 0 ; j< count[i];j++) {  
            arr[k] = bucket[i][j];  
            k++;  
        }  
    }  
    for (int i = 0 ; i<10 ;i++) {  
        delete bucket[i];  
        bucket[i] =NULL;  
    }  
    delete []bucket;  
    bucket = NULL;  
}  
  
void main() {  
    double *arr=new double[10];  
    InitialArr(arr, 10);  
    BucketSort(arr, 10);  
    PrintArr(arr,10);  
    delete [] arr;  
}  

5）考察点、重点和频度分析

桶排序是一种很巧妙的排序方法，在处理密集型数排序的时候有比较好的效果(主要是这种情况下空间复杂度不高)，其思想也可用在很多算法题上，详见后续笔试面试算法例题。

6）笔试面试题

例题1、一年的全国高考考生人数为500 万，分数使用标准分，最低100 ，最高900 ，没有小数，你把这500 万元素的数组排个序。

对500W数据排序，如果基于比较的先进排序，平均比较次数为O(5000000*log5000000)≈1.112亿。但是我们发现，这些数据都有特殊的条件： 100=<score<=900。那么我们就可以考虑桶排序这样一个“投机取巧”的办法、让其在毫秒级别就完成500万排序。

创建801(900-100)个桶。将每个考生的分数丢进f(score)=score-100的桶中。这个过程从头到尾遍历一遍数据只需要500W次。然后根据桶号大小依次将桶中数值输出，即可以得到一个有序的序列。而且可以很容易的得到100分有人，501分有人。

实际上，桶排序对数据的条件有特殊要求，如果上面的分数不是从100-900，而是从0-2亿，那么分配2亿个桶显然是不可能的。所以桶排序有其局限性，适合元素值集合并不大的情况。

例题2、在一个文件中有 10G 个整数，乱序排列，要求找出中位数。内存限制为 2G。只写出思路即可（内存限制为 2G的意思就是，可以使用2G的空间来运行程序，而不考虑这台机器上的其他软件的占用内存）。

分析： 既然要找中位数，很简单就是排序的想法。那么基于字节的桶排序是一个可行的方法。
思想：将整型的每1byte作为一个关键字，也就是说一个整形可以拆成4个keys，而且最高位的keys越大，整数越大。如果高位keys相同，则比较次高位的keys。整个比较过程类似于字符串的字典序。按以下步骤实施：

1、把10G整数每2G读入一次内存，然后一次遍历这536,870,912即（102410241024）*2 /4个数据。每个数据用位运算”>>”取出最高8位(31-24)。这8bits(0-255)最多表示255个桶，那么可以根据8bit的值来确定丢入第几个桶。最后把每个桶写入一个磁盘文件中，同时在内存中统计每个桶内数据的数量，自然这个数量只需要255个整形空间即可。
2、继续以内存中的整数的次高8bit进行桶排序(23-16)。过程和第一步相同，也是255个桶。
3、一直下去，直到最低字节(7-0bit)的桶排序结束。我相信这个时候完全可以在内存中使用一次快排就可以了。

例题3、给定n个实数x1,x2,…,xn,求这n个实数在实轴上相邻2个数之间的最大差值M,要求设计线性的时间算法
典型的最大间隙问题。
要求线性时间算法。需要使用桶排序。桶排序的平均时间复发度是O(N).如果桶排序的数据分布不均匀，假设都分配到同一个桶中，最坏情况下的时间复杂度将变为O(N^2).

桶排序: 最关键的建桶，如果桶设计得不好的话桶排序是几乎没有作用的。通常情况下，上下界有两种取法，第一种是取一个10^n或者是2^n的数，方便实现。另一种是取数列的最大值和最小值然后均分作桶。

对于这个题，最关键的一步是：由抽屉原理知：最大差值M>= (Max(V[n])-Min(V[n]))/(n-1)！所以，假如以(Max(V[n])-Min(V[n]))/(n-1)为桶宽的话，答案一定不是属于同一个桶的两元素之差。因此，这样建桶，每次只保留桶里面的最大值和最小值即可。

代码如下：

//距离平均值为offset = (arrayMax - arrayMin) / (n - 1), 则距离最大的数必然大于这个值  
//每个桶只要记住桶中的最大值和最小值，依次比较上一个桶的最大值与下一个桶的最小值的差值，找最大的即可.  
#include <iostream>  
#define MAXSIZE 100    //实数的个数  
#define MAXNUM 32767  
using namespace std;  
struct Barrel  
{  
 double min;   //桶中最小的数  
 double max;   //桶中最大的数  
 bool flag;   //标记桶中有数  
};  
int BarrelOperation(double* array, int n)  
{  
 Barrel barrel[MAXSIZE];  //实际使用的桶  
 int nBarrel = 0;  //实际使用桶的个数  
 Barrel tmp[MAXSIZE];   //临时桶，用于暂存数据  
 double arrayMax = -MAXNUM, arrayMin = MAXNUM;  
 for(int i = 0; i < n; i++) {  
  if(array[i] > arrayMax)  
   arrayMax = array[i];  
  if(array[i] < arrayMin)  
   arrayMin = array[i];  
 }  
 double offset = (arrayMax - arrayMin) / (n - 1);  //所有数的平均间隔  
 //对桶进行初始化  
 for(i = 0; i < n; i++) {    
  tmp[i].flag = false;  
  tmp[i].max = arrayMin;  
  tmp[i].min = arrayMax;  
 }  
 //对数据进行分桶  
 for(i = 0; i < n; i++) {     
  int pos = (int)((array[i] - arrayMin) / offset);  
  if(!tmp[pos].flag) {  
   tmp[pos].max = tmp[pos].min = array[i];  
   tmp[pos].flag = true;  
  } else {  
   if(array[i] > tmp[pos].max)  
    tmp[pos].max = array[i];  
   if(array[i] < tmp[pos].min)  
    tmp[pos].min = array[i];  
  }   
 }  
 for(i = 0; i <= n; i++) {  
  if(tmp[i].flag)   
   barrel[nBarrel++] = tmp[i];     
 }  
 int maxOffset = 0.0;  
 for(i = 0; i < nBarrel - 1; i++) {  
  if((barrel[i+1].min - barrel[i].max) > maxOffset)   
   maxOffset = barrel[i+1].min - barrel[i].max;  
 }  
 return maxOffset;  
}  
int main()  
{  
 double array[MAXSIZE] = {1, 8, 6, 11, 7, 13, 16, 5};  //所需处理的数据  
 int n = 8; //数的个数  
 //double array[MAXSIZE] = {8, 6, 11};  
 //int n = 3;  
 int maxOffset = BarrelOperation(array, n);  
 cout << maxOffset << endl;  
 return 0;  
}