桶排序(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);
        }
        
    }

}

　　總結：

桶排序是以空間消耗換時間消耗，桶划分的越小，各個桶之間的數據越少，排序所用的時間也會越少，但相應的空間消耗就會增大。