【每日算法】桶排序算法

时间 2019-11-10

原文原文链接

1）算法简介

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

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

2）算法描述和分析

桶排序具体算法描述以下：
一、设置一个定量的数组看成空桶子。
二、寻访串行，而且把项目一个一个放到对应的桶子去。
三、对每一个不是空的桶子进行排序。
四、从不是空的桶子里把项目再放回原来的串行中。算法

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

能够证实，即便选用插入排序做为桶内排序的方法，桶排序的平均时间复杂度为线性。具体证实，请参考算法导论。其空间复杂度也为线性。spa

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

图解
设计

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

视频：
这里就不给出桶排序的视频了，见上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）笔试面试题

例题一、一年的全国高考考生人数为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亿个桶显然是不可能的。因此桶排序有其局限性，适合元素值集合并不大的状况。

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

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

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

例题三、给定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;  
}