实现桶排序算法

Java语言实现

定义节点

package bucketSort;

public class LinkedNode {
    public int value;
    public LinkedNode next;

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

 桶排序

package bucketSort;

import java.util.Arrays;

public class BucketSort {
    //根据桶的个数来确定hash函数,这份代码适合桶的个数等于数组的长度
    private static int hash(int element,int max,int length){
        return (element*length)/(max+1);
    }

    //生成随机数
    private static int[] getRandomArr(int length,int min,int max){
        int nums[]=new int[length];
        for(int i=0;i<length;++i){
            nums[i]=(int)(min+Math.random()*(max-min+1));
        }
        return nums;
    }

    private static  int maxOf(int[] nums){
        int max=Integer.MIN_VALUE;
        for(int n:nums){
            max=Math.max(max,n);
        }
        return max;
    }
    public static void main(String[] args){
        int[] arr=getRandomArr(10,1,100);
        System.out.println("begin..."+Arrays.toString(arr));
        new BucketSort().sort(arr);
        System.out.println("final..."+Arrays.toString(arr));
    }

    private void sort(int[] arr){
        int length=arr.length;
        LinkedNode[] bucket=new LinkedNode[length];//桶的个数=length
        int max=maxOf(arr);//求max

        //入桶
        for(int i=0;i<length;++i){
            int value=arr[i];//枚举每个元素
            int hash=hash(value,max,length);//桶的下标
            if(bucket[hash]==null){
                bucket[hash]=new LinkedNode(value);//不存在时,初始化链表表头
            }else{
                insertInto(value,bucket[hash],bucket,hash);//存在时,插入链表
            }
        }

        int k=0;//记录数组下标

        //出桶,回填
        for(LinkedNode node:bucket){
            if(node!=null){
                while(node!=null){
                    arr[k++]=node.value;
                    node=node.next;
                }
            }
        }
    }

    //默认从小到大
    private void insertInto(int value,LinkedNode head,LinkedNode[] bucket,int hash){
        LinkedNode newNode=new LinkedNode(value);
        //小于头节点,放在头部
        if(value<=head.value){
            newNode.next=head;
            //替换头节点
            bucket[hash]=newNode;
            return;
        }
        LinkedNode p=head;
        LinkedNode pre=p;
        while(p!=null&&value>p.value){
            pre=p;
            p=p.next;
        }
        //往后找第一个比当前值大的节点,放在这个节点的前面
        if(p==null){
            pre.next=newNode;//最后的节点
        }else{//插入到pre和p之间
            pre.next=newNode;
            newNode.next=p;
        }
    }
}