排序算法----桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序的工作原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶在分别排序（有可能在使用别的排序算法或是以递归方式继续使用桶排序进行排）
时间复杂度：O（n+m）
空间复杂度：O（n+m）
稳定性：稳定

package 排序算法;

import shixianClass.ArrayList;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;

public class BucketSort {
    public static void main(String[] args) {
        int []arr=new int[20];
        Random random=new Random();
        for (int i=0;i<arr.length;i++){
            arr[i]=random.nextInt(100);
        }
        buckrtSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    private static void buckrtSort(int[] arr) {
        //1.获取最大值和最小值
        int max=arr[0];
        int min=arr[0];
        for (int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        //2.计算桶的数量
        int bucketNum=(max-min)/arr.length+1;
        //3.创建所有的桶
        ArrayList<Integer> [] buckets=new ArrayList[bucketNum];
        for (int i=0;i<buckets.length;i++){
            buckets[i]=new ArrayList<>();
        }

        //4.遍历元素分别进桶
        for(int i=0;i<arr.length;i++){
           buckets[(arr[i]-min)/arr.length].add(arr[i]);
        }
        //5.对每一个桶进行排序
        for(int i=0;i<buckets.length;i++){
            buckets[i].sort(new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                    return o1.compareTo(02);
                }
            });
            System.out.println(buckets[i]);
        }
        //6.将桶中的数据放到原数组中
        int index=0;
        for(int i=0;i<buckets.length;i++){
          for(int j=0;j<buckets[i].size();j++){
               arr[index++]=buckets[i].get(j);
          }
        }
    }
}

执行结果

ArrayList:5/10[2,11,9,19,7]
ArrayList:4/10[38,29,41,41]
ArrayList:6/10[42,44,61,45,60,46]
ArrayList:4/10[68,80,72,81]
ArrayList:1/10[84]
[2, 11, 9, 19, 7, 38, 29, 41, 41, 42, 44, 61, 45, 60, 46, 68, 80, 72, 81, 84]

测试：

package 排序算法;

import java.util.Arrays;
import java.util.Random;

public class TestSort {
    /*
    数据分布情况
    1.完全随机
    2.大致有序
    3.方差小
     */
    public static int[] getTotalRandom(){
        Random random=new Random();
        int [] arr=new int[40000];
        for (int i=0;i<arr.length;i++){
            arr[i]=random.nextInt(10000);
        }
        return arr;
    }

    public static void main(String[] args) {
        int [] arr1=getTotalRandom();
        int [] arr2= Arrays.copyOf(arr1, arr1.length);
        int [] arr3= Arrays.copyOf(arr1, arr1.length);
        int [] arr4= Arrays.copyOf(arr1, arr1.length);
        int [] arr5= Arrays.copyOf(arr1, arr1.length);
        int [] arr6= Arrays.copyOf(arr1, arr1.length);
        int [] arr7= Arrays.copyOf(arr1, arr1.length);
        int [] arr8= Arrays.copyOf(arr1, arr1.length);
        int [] arr9= Arrays.copyOf(arr1, arr1.length);
        int [] arr10= Arrays.copyOf(arr1, arr1.length);
        int [] arr11= Arrays.copyOf(arr1, arr1.length);
       /* testSelectionSort(arr1);
        testBubbleSort(arr2);
        testInsertSort(arr3);
        testShellSort(arr4);
        testMergSort(arr5);
        testHeapSort(arr6);*/
        testQuickSort01(arr7);
        testQuickSort02(arr8);
        testQuickSort09(arr9);
        testCounting(arr10);
        testBucketSort(arr11);


    }

    private static void testBucketSort(int[] arr11) {
        long startTime=System.currentTimeMillis();
        BucketSort. buckrtSort(arr11);
        long endTime=System.currentTimeMillis();
        System.out.println("桶排序"+(endTime-startTime));
    }

    private static void testCounting(int[] arr10) {
        long startTime=System.currentTimeMillis();
        CountingSort.countingSort(arr10);
        long endTime=System.currentTimeMillis();
        System.out.println("计数排序"+(endTime-startTime));

    }

    private static void testQuickSort09(int[] arr9) {
        long startTime=System.currentTimeMillis();
        QuickSort03.quickSort03(arr9,0,arr9.length-1);
        long endTime=System.currentTimeMillis();
        System.out.println("三路快排"+(endTime-startTime));
    }

    private static void testQuickSort02(int[] arr8) {
        long startTime=System.currentTimeMillis();
        QuickSort02.quickSort02(arr8,0,arr8.length-1);
        long endTime=System.currentTimeMillis();
        System.out.println("双路快排"+(endTime-startTime));

    }

    private static void testQuickSort01(int[] arr7) {
        long startTime=System.currentTimeMillis();
        QuickSort01.quickSort(arr7,0,arr7.length-1);
        long endTime=System.currentTimeMillis();
        System.out.println("单路快排"+(endTime-startTime));
    }

    private static void testHeapSort(int[] arr6) {
            long startTime=System.currentTimeMillis();
            HeapSort.heapSort(arr6);
            long endTime=System.currentTimeMillis();
            System.out.println("堆排序"+(endTime-startTime));
    }

    private static void testInsertSort(int[] arr3) {
        long startTime=System.currentTimeMillis();
        BubbleSort.bubbleSort(arr3);
        long endTime=System.currentTimeMillis();
        System.out.println("冒泡排序"+(endTime-startTime));
    }

    private static void testBubbleSort(int[] arr2) {
        long startTime=System.currentTimeMillis();
        insertionSort.lnsertionSortUpper(arr2);
        long endTime=System.currentTimeMillis();
        System.out.println("插入排序"+(endTime-startTime));
    }

    private static void testSelectionSort(int[] arr) {
        long startTime=System.currentTimeMillis();
        SelectionSort.selectionSort(arr);
        long endTime=System.currentTimeMillis();
        System.out.println("选择排序"+(endTime-startTime));
    }
    private static void testShellSort(int[] arr) {
        long startTime=System.currentTimeMillis();
        ShellSort.shellSort(arr);
        long endTime=System.currentTimeMillis();
        System.out.println("希尔排序"+(endTime-startTime));
    }
    private static void testMergSort(int[] arr) {
        long startTime=System.currentTimeMillis();
        MergSort.mergSort(arr,0,arr.length-1);
        long endTime=System.currentTimeMillis();
        System.out.println("归并排序"+(endTime-startTime));
    }

}

执行结果

单路快排7
双路快排10
三路快排9
计数排序3
桶排序934