算法：非比较排序（桶排序、计数排序、基数排序）

1.桶排序 

/**
 * 桶排序
 * 原理：假设输入数据服从均匀分布将数据分到有限数量的桶里，然后再对每个桶分别排序，最后把全部桶的数据合并。
 * 时间复杂度：最好情况接近O(n)，最坏情况接近O(nlogn)
 * 空间复杂度：O(n+m)，m为桶的数量
 * 稳定性：取决于桶内使用的排序方法
 * 特征：非比较排序，不涉及元素之间的比较操作。较适合用在外部排序
 *
 * PS：外部排序是指数据存储在外部磁盘中，数据量比较大，内存有限，无法将数据全部加载到内存中。
 */

import java.util.ArrayList;
import java.util.Arrays;

/**
 * 桶排序
 * 原理：假设输入数据服从均匀分布将数据分到有限数量的桶里，然后再对每个桶分别排序，最后把全部桶的数据合并。
 * 时间复杂度：最好情况接近O(n)，最坏情况接近O(nlogn)
 * 空间复杂度：O(n+m)，m为桶的数量
 * 稳定性：取决于桶内使用的排序方法
 * 特征：非比较排序，不涉及元素之间的比较操作。较适合用在外部排序
 * 
 * PS：外部排序是指数据存储在外部磁盘中，数据量比较大，内存有限，无法将数据全部加载到内存中。
 */
public class 桶排序 {
    public static void main(String[] args) {
        int[] arr = {75, 30, 65, 22, 25, 9, 37, 21, 6, 86, 66, 83, 10, 42, 76, 87, 1, 63, 84, 5};
        bucketSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bucketSort(int[] arr) {
        //确定桶的数量
        int max = arr[0];
        int min = arr[0];
        for (int i : arr) {
            if (i > max) {
                max = i;
            }
            if (i < min) {
                min = i;
            }
        }
        ArrayList<ArrayList<Integer>> bucket = new ArrayList<>();
        int count = (max - min) / arr.length + 1;//桶的个数
        //将桶初始化
        for (int i = 0; i < count; i++) {
            bucket.add(new ArrayList<>());
        }
        //把元素放入对应的桶中
        for (int i : arr) {
            bucket.get((i - min) / arr.length).add(i);
            //这一步是先根据元素的数值算出对应的桶,再把元素加入到桶中
        }
        //把每个桶进行排序,可以采用任意一种排序方法,这里用冒泡排序的方法
        for (int i = 0; i < count; i++) {
            bubbleSort3(bucket.get(i));
        }
        //遍历每个桶的每个数据,并存放到数组中
        int x = 0;
        for (ArrayList<Integer> array : bucket) {
            for (Integer i : array) {
                arr[x] = i;
                x++;
            }
        }
    }


    //桶内冒泡排序：从后往前比并加判断
    public static void bubbleSort3(ArrayList<Integer> arr) {
        //一共要比arr.length-1趟
        for (int n = 0; n < arr.size() - 1; n++) {
            //从后往前比,小的往前放,每趟比完了以后,最小的到了前面
            //每趟从最后开始比,到n
            boolean flag = false;//假设没有发生交换
            for (int x = arr.size() - 2; x >= n; x--) {
                if (arr.get(x) > arr.get(x + 1)) {
                    swap(arr, x, x + 1);
                    flag = true;//发生交换就修改标记
                }
            }
            if (!flag) {
                //如果没有发生交换,可以退出循环
                break;
            }
        }
    }

    public static void swap(ArrayList<Integer> arr, int x, int y) {
        int temp = arr.get(x);
        arr.set(x, arr.get(y));
        arr.set(y, temp);
    }
}

2.计数排序

/**
 * 计数排序
 * 时间复杂度：O(n+k) = O(n)，本来为k为待排序数组的取值范围
 * 空间复杂度：O(n+k) = O(n)
 * 稳定性：从后往前填回去，是稳定的
 * 特点：需要排序的元素是整数，排序元素的取值要在一定范围内并且比较集中。例如高考分数统计。
 */

 

 

import java.util.Arrays;

/**
 * 计数排序
 * 时间复杂度：O(n+k) = O(n)，本来为k为待排序数组的取值范围
 * 空间复杂度：O(n+k) = O(n)
 * 稳定性：从后往前填回去，是稳定的
 * 特点：需要排序的元素是整数，排序元素的取值要在一定范围内并且比较集中。例如高考分数统计。
 */
public class 计数排序 {
    public static void main(String[] args) {
        int arr[] = {2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2};
//        countSort(arr, 9);
        countSort2(arr,9,1);
        System.out.println(Arrays.toString(arr));
    }

    public static void countSort(int[] arr, int max) {
        int[] temp = new int[max + 1];
        //初始化一个临时数组，临时数组的下标代表的是原数组的值，临时数组中的值表示原数组中元素的个数
        for (int i = 0; i < arr.length; i++) {
            temp[arr[i]]++;//统计每个元素的个数
        }
        //把临时数组填回去：从后往前填，稳定
        int index = arr.length - 1;
        for (int i = max; i >= 0; i--) {//遍历temp[]数组
            for (int j = temp[i] - 1; j >= 0; j--) {
                arr[index] = i;
                index--;
            }
        }
    }

    public static void countSort2(int[] arr, int max, int min) {
        int[] temp = new int[max - min + 1];
        for (int i = 0; i < arr.length; i++) {
            temp[arr[i] - min]++;//统计每个元素的个数
        }
        //把临时数组填回去：从后往前填，稳定
        int index = arr.length - 1;
        for (int i = max - min; i >= 0; i--) {
            for (int j = temp[i] - 1; j >= 0; j--) {
                arr[index] = i + min;
                index--;
            }
        }
    }
}

3.基数排序

/**
 * 基数排序
 * 时间复杂度：O(k*n) = O(n)，k为最大数的位数
 * 空间复杂度：O(n+k)，k为最大数的位数
 * 稳定性：稳定
 * 特点：适用于位数不多，每一位数的范围不大的情况。因为每次排序时间复杂度O(n)，如果有k位，则时间复杂度为O(k*n)，
 */

 

代码实现的思想：每个桶计数

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

/**
 * 基数排序
 * 时间复杂度：O(k*n) = O(n)，k为最大数的位数
 * 空间复杂度：O(n+k)，k为最大数的位数
 * 稳定性：稳定
 * 特点：适用于位数不多，每一位数的范围不大的情况。因为每次排序时间复杂度O(n)，如果有k位，则时间复杂度为O(k*n)，
 */
public class 基数排序 {
    public static void main(String[] args) {
        //创建由20个随机数组成的数组
        Random r = new Random();
        int[] arr = new int[10];
        int n = 0;
        for (int i = 0; i < 10; i++) {
            arr[n] = r.nextInt(1000);
            n++;
        }
        System.out.println(Arrays.toString(arr));
        radixSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void radixSort(int[] arr) {
        //获取数组中的最大值，用于确定要进行几轮排序
        int max = arr[0];
        for (int i : arr) {
            if (i > max) {
                max = i;
            }
        }
        int exp;//排序指数，按个位排序iexp=1，按十位排序iexp=10，按百位排序iexp=100
        for (exp = 1; max / exp > 0; exp *= 10) {
            //从个位开始进行多轮排序，共需要几轮排序取决于最大值的位数
            radix(arr, exp);
        }
    }

    //把数组按照排序指数排序
    public static void radix(int[] arr, int exp) {
        int[] temp = new int[arr.length];//用于存放排序结果的临时数组
        int[] bucket = new int[10];//初始化10个桶，数组里面存放的是每个桶中元素的个数
        //每个桶计数
        /*
        bucket[0]表示个位为0的元素的个数
        bucket[1]表示个位为1的元素的个数
        ...
        bucket[9]表示个位为9的元素的个数
         */
        for (int i : arr) {
            bucket[(i / exp) % 10]++;
        }

        //调整每个桶的计数（累加）
        //此时每个桶的计数的值-1，就是排序后该桶中的元素在temp数组中位置的下标
        /*
        bucket[0]表示个位为0的元素的个数
        bucket[1]表示个位为0或1的元素的个数
        bucket[2]表示个位为0或1或2的元素的个数
        ...
        bucket[9]表示个位为0或1或2或...或9的元素的个数，也就是所有元素的个数
         */
        for (int i = 1; i < 10; i++) {
            bucket[i] = bucket[i] + bucket[i - 1];
        }
        
        //将arr中的元素填充到临时数组中
        //从后往前遍历是为了保证排序的稳定性，即应先进先出，后进后出。
        //因为同一个桶中可能由多个元素，后面的元素先遍历到，遍历到以后对应的桶的计数-1，
        //所以这个桶中靠前的元素的下标就比上一个元素小
        for (int i = arr.length - 1; i >= 0; i--) {
            int iexp = (arr[i] / exp) % 10;//计算出这个元素在哪个桶
            temp[bucket[iexp] - 1] = arr[i];//这个桶的值-1，就是元素在temp中位置的下标
            bucket[iexp]--;//每往temp中放一个元素，桶的计数要-1
        }
        //将临时数组拷贝到arr中
        for (int i = 0; i < temp.length; i++) {
            arr[i] = temp[i];
        }
    }
}