桶排序(BucketSort)

　　桶排序：工作的原理是将数组分到有限数量的桶里。每个桶再个别排序(可能在使用别的排序算法，我这里用的单向链表在放入时就排好了顺序)，最后依次把各个桶中的记录列出来得到有序序列。分布均匀的一组数，用桶排序效率很高。

　　

　　1.桶的个数是用这组数的个数确定的

　　2.每个数值入桶的位置(桶的下标)，是由（数值*数组长度/（最大数值+1））这个确定的。

　　桶排序(BucketSort)概略图

　　1.LinkedNode类

public class LinkedNode {
    private int value;
    private LinkedNode next;
    
    public LinkedNode(int value)
    {
        this.value=value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public LinkedNode getNext() {
        return next;
    }

    public void setNext(LinkedNode next) {
        this.next = next;
    }
    
    
}

　　2.BucketSort类

　　

import java.util.Arrays;

public class BucketSort {
    //计算出入那桶(桶的下标)
    public static int hash(int value,int length,int max)
    {
        return ((value*length)/(max+1));
    }

    public static void main(String[] args) {
        int arr[]= {1045,3434,3566,4325,3234,6545,8237,4540,1550,5653,43534};
        System.out.println("开始："+Arrays.toString(arr));
        BucketSort.sort(arr);
        System.out.println("最终；"+Arrays.toString(arr));
    }
    
    public static void sort(int arr[])
    {
        //1定义桶的大小
        int length=arr.length;
        LinkedNode bucket[]=new LinkedNode[length];
        //2求最大值
        int max=arr[0];
        for(int i=1;i<length;i++)
        {
            if(arr[i]>max)
                max=arr[i];
        }
        //入桶
        for(int i=0;i<length;i++)
        {
            int value=arr[i];
            //得到入桶的下标
            int hash=hash(value,length,max);  
            if(bucket[hash]==null)
            {
                bucket[hash]=new LinkedNode(value);
            }else {
                insertInto(value,bucket[hash],bucket,hash);  //桶有值时入桶方法
            }
            
        }
        
        //出桶
        int i=0;
        for(LinkedNode node:bucket)
        {
            while(node!=null)
            {
                arr[i++]=node.getValue();
                node=node.getNext();
            }
        }
        
        
    }
    
    
    public static void insertInto(int value,LinkedNode head,LinkedNode bucket[],int hash)
    {
        LinkedNode newNode=new LinkedNode(value);
        if(value<head.getValue())
        {
            newNode.setNext(head);
            bucket[hash]=newNode;
            return ;
        }
        LinkedNode p=head;
        LinkedNode pre=null; 
        while(p!=null&&value>p.getValue())
        {
            pre=p;
            p=p.getNext();
        }
        if(p==null) 
        {
            pre.setNext(newNode);
        }else {
            pre.setNext(newNode);
            newNode.setNext(p);
        }
        
    }

}

　　总结：

桶排序是以空间消耗换时间消耗，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少，但相应的空间消耗就会增大。