桶排序

工作原理:

1.将数组分到有限数量的桶里。

2.每个桶再进行个别排序【使用其他排序算法或者以递归实行桶排序】

由此可以看出桶排序利用了分治思想。

---

利用桶排序解决{7，21，8，23，31，32，43}的排序问题：

基于二维数组的实现：

public class BucketSort{

    public static void bucketSort(int[] arr){

        //分桶，这里采用映射函数f(x)=x/10。
        //输入数据为0~99之间的数字
        int bucketCount =10;
        Integer[][] bucket = new Integer[bucketCount][arr.length];  //Integer初始为null,以与数字0区别。
        for (int i=0; i<arr.length; i++){
            int quotient = arr[i]/10;   //这里即是使用f(x)
            for (int j=0; j<arr.length; j++){
                if (bucket[quotient][j]==null){
                    bucket[quotient][j]=arr[i];
                    break;
                }
            }
        }
        //小桶排序
        for (int i=0; i<bucket.length; i++){
                //insertion sort
                for (int j=1; j<bucket[i].length; ++j){
                    if(bucket[i][j]==null){
                        break;
                    }
                    int value = bucket[i][j];
                    int position=j;
                    while (position>0 && bucket[i][position-1]>value){
                        bucket[i][position] = bucket[i][position-1];
                        position--;
                    }
                    bucket[i][position] = value;
                }

        }
        //输出
        for (int i=0, index=0; i<bucket.length; i++){
            for (int j=0; j<bucket[i].length; j++){
                if (bucket[i][j]!=null){
                    arr[index] = bucket[i][j];
                    index++;
                }
                else{
                    break;
                }
            }
        }
    }

    public static void main(String[] args){

        int arr[] ={2,4,5,6,7,8,21,32,43,23,31};
        bucketSort(arr);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

    }



}

基于链表的实现：

public class Test{
    class Node{
       int key;
       Node next;
    }

    public void IncSort(int keys[],int bucketsize){
      int size=keys.length;
      Node[] bucket_table=new Node[bucketsize];
      for(int i=0;i<bucketsize;i++){
        bucket_table[i]=new Node();
        bucket_table[i].key=0;//纪录当前桶中的数量
        bucket_table[i].next=null;
     }
     for(int j=0;j<size;j++){
         Node node=new Node();
         node.key=keys[j];
         node.next=null;
         int index=keys[j]/10;
         Node p=bucket_table[index];
         if(p.key==0){
           bucket_table[index].next=node;
           bucket_table[index].key ++;
        }
         else{//链表结构的插入排序
            while(p.next!=null&&p.next.key<=node.key)
                     p=p.next;
            node.next=p.next;
            p.next=node;
            bucket_table[index].key ++;
         }
      }
   }

    public static void main(String[] args){
        int arr[] = {7,8,21,23,31,32,43};
        Test a = new Test();
        a.IncSort(arr,7);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

}

基于一维数组的实现：

public class BucketSortTest {

    public static int count = 0;

    public static void bucketSort(int data[],int min,int max)
    {
        //缓存数组
        int temp[] = new int[data.length];

        //buckets用于记录待排序元素的信息
        //buckets数组定义了max-min个桶
        int buckets[] = new int[max - min];

        //记录每个元素在序列中出现的次数
        for(int i=0;i<data.length;i++)
        {
            buckets[data[i]-min]++;
        }

        //计算落入各个桶内的元素在有序序列中的位置
        for(int i = 1;i<max-min;i++)
        {
            buckets[i] = buckets[i] + buckets[i -1];
        }

        //将data中的元素完全复制到temp数组
        System.arraycopy(data,0,temp,0,data.length);

        //根据buckets数组的信息，将待排序的元素放入相应位置
        for(int k = data.length - 1;k>=0;k--)
        {
            data[--buckets[temp[k] - min]] = temp[k];
        }



    }

    public static void print(int data[])
    {
        for(int i = 0;i <data.length;i++)
        {
            System.out.print(data[i]+"\t");
        }
        System.out.println();
    }

    public static void main(String[] args)
    {
        int data[] = new int[]{7,21,8,23,31,32,43};
        print(data);
        bucketSort(data, 0, 50);
        System.out.println("排序后的结果:");
        print(data);
    }

}