桶排序
计数排序（基于统计）
- 要求数据是有限的，和数据状况有关，比如对于200个人统计他们的年龄分布，这个时候需要申请200个桶，因此对于输入数据的规模有限制，如果输入规模是不定的，空间申请就会很麻烦。
基数排序
思想
- 要求排序的数字都是十进制的数字，找到最高位的数字，对于其中不满足位数的数字前面补0，例如【100，23，34】就需要改写成【100，023，034】的形式。
- 准备和数字相同数目的桶（类比于先进先出的队列），所有数字按照个位数字进桶，然后按照从左往右的次序依次往出倒数字，如果一个桶内有多个数字按照次序（队列）倒数，再按照十位数字进桶，原理和先前类似，倒出；再按照百位数字进桶，出桶。最后的次序是从小到大的。
落地
- 初始数组为【23，13，3，24，23，14】，申请两个栈，一个为count，一个是help。count按照次序分别是【0，1，2，3，4，5，6，7，8，9】这个用于统计对应的数字的个数，比如上面这个例子的话，个位是3的个数有4个，个位是4的个数有3个。而help指定的是数组中元素的个数。此时一个6个元素，所以将help的大小设置为6。
- 统计完对应的数字数字之后，得到的count为【0，0，0，4，2，0，0，0，0，0】，对其进行加工，对应元素的位置等于自身的值+前面的元素值。如果是0号位置就是本身，1号就是0+0，2号是0+0；3号是4+0；4号是4+0；5号是6+0；依次类推剩余元素的值都是6。经过加工后的count数组含义就是小于等于相应位置上元素的个数。比如小于等于3的有三个元素；小于等于5，6，7，8，9的有6个元素。
操作过程
- 从右往左遍历，第一个元素是14，个位数小于等于6的有6个，所以将14填写在help的5位置上，并且将count数组中的4对应的6减1，变成5。
- 下一个元素是23，个位元素对应的是3，查询count数组，小于等于3的元素有四个，因此将23填写在help数组的3号位置，count中3号位置的4减1；
- 下一个元素是24， 个位元素对应的是4，查询count数组，小于等于4的元素有5个，因此将24填写在help数组的4号位置，count中4号位置的5减1；
- 下一个元素是3， 个位元素对应的是3，查询count数组，小于等于3的元素有3个，因此将3填写在help数组的2号位置，count中3号位置的3减1；
- 下一个元素是13， 个位元素对应的是3，查询count数组，小于等于3的元素有2个，因此将3填写在help数组的1号位置，count中3号位置的2减1；
- 下一个元素是23， 个位元素对应的是3，查询count数组，小于等于3的元素有1个，因此将3填写在help数组的0号位置，count中3号位置的1减1；
完整代码
package class03;import java.util.Arrays;public class Code02_RadixSort {// only for no-negative valuepublic static void radixSort(int[] arr) {if (arr == null || arr.length < 2) {return;}radixSort(arr, 0, arr.length - 1, maxbits(arr));}public static int maxbits(int[] arr) {int max = Integer.MIN_VALUE;for (int i = 0; i < arr.length; i++) {max = Math.max(max, arr[i]);}int res = 0;while (max != 0) {res++;max /= 10;}return res;}// arr[begin..end]排序public static void radixSort(int[] arr, int L, int R, int digit) {final int radix = 10;int i = 0, j = 0;// 有多少个数准备多少个辅助空间int[] bucket = new int[R - L + 1];for (int d = 1; d <= digit; d++) { // 有多少位就进出几次// 10个空间// count[0] 当前位(d位)是0的数字有多少个// count[1] 当前位(d位)是(0和1)的数字有多少个// count[2] 当前位(d位)是(0、1和2)的数字有多少个// count[i] 当前位(d位)是(0~i)的数字有多少个int[] count = new int[radix]; // count[0..9]for (i = L; i <= R; i++) {j = getDigit(arr[i], d);count[j]++;}for (i = 1; i < radix; i++) {count[i] = count[i] + count[i - 1];}for (i = R; i >= L; i--) {j = getDigit(arr[i], d);bucket[count[j] - 1] = arr[i];count[j]--;}for (i = L, j = 0; i <= R; i++, j++) {arr[i] = bucket[j];}}}public static int getDigit(int x, int d) {return ((x / ((int) Math.pow(10, d - 1))) % 10);}// for testpublic static void comparator(int[] arr) {Arrays.sort(arr);}// for testpublic static int[] generateRandomArray(int maxSize, int maxValue) {int[] arr = new int[(int) ((maxSize + 1) * Math.random())];for (int i = 0; i < arr.length; i++) {arr[i] = (int) ((maxValue + 1) * Math.random());}return arr;}// for testpublic static int[] copyArray(int[] arr) {if (arr == null) {return null;}int[] res = new int[arr.length];for (int i = 0; i < arr.length; i++) {res[i] = arr[i];}return res;}// for testpublic static boolean isEqual(int[] arr1, int[] arr2) {if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {return false;}if (arr1 == null && arr2 == null) {return true;}if (arr1.length != arr2.length) {return false;}for (int i = 0; i < arr1.length; i++) {if (arr1[i] != arr2[i]) {return false;}}return true;}// for testpublic static void printArray(int[] arr) {if (arr == null) {return;}for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + " ");}System.out.println();}// for testpublic static void main(String[] args) {int testTime = 500000;int maxSize = 100;int maxValue = 100000;boolean succeed = true;for (int i = 0; i < testTime; i++) {int[] arr1 = generateRandomArray(maxSize, maxValue);int[] arr2 = copyArray(arr1);radixSort(arr1);comparator(arr2);if (!isEqual(arr1, arr2)) {succeed = false;printArray(arr1);printArray(arr2);break;}}System.out.println(succeed ? "Nice!" : "Fucking fucked!");int[] arr = generateRandomArray(maxSize, maxValue);printArray(arr);radixSort(arr);printArray(arr);}}
稳定性
- 相同元素排序保证先后顺序
- 同样数值的个体之间，如果不因为排序而改变相对次序，这个排序就是有稳定性的，否则则没有
- 基于比较的排序，一般都是不稳定的；基数排序（按照个位、十位、百位上的元素的大小进行相对次序的排列）和计数排序（统计相同数值的元素出现的次数，押入对应的元素组成的数据栈，利用栈先入后出的特性，保持元素的相对次序，参考上文统计0-200员工年龄分布问题）是稳定的
- 不具备稳定性的排序：选择排序、快速排序 和 堆排序
- 具备稳定性的排序 ：冒泡排序、插入排序 、归并排序 、一切桶排序思想下的排序（计数排序和基数排序）
- 目前没有 时间复杂度为O(N*logN) 额外时间复杂度O(1) 又稳定的排序
- 稳定性 主要体现在 非基础类型数据的排序，比如对自定义结构体学生类型{年龄、班级},先按照年龄排序，再按照班级进行排序
分析：
- 桶排序思想下的排序都是不基于比较的排序
- 时间复杂度为O(N)，额外空间负载度O(M)
- 应用范围有限，需要样本的数据状况满足桶的划分
汇总
- 快速排序不是基于比较的排序
| 时间 | 空间 | 稳定性 | 备注 | |
| 选择排序 | O(N^2) | O(1) | 不稳定 | {5,5,5,3} 3和第一个5交换，不稳定 |
| 冒泡排序 | O(N^2) | O(1) | 稳定 | |
| 插入排序 | O(N^2) | O(1) | 稳定 | {3,4,4,5}新插入元素4，不可以越过与其相等元素的左边，即元素相等的话，只会排在相等区域的最后位置 |
| 归并排序 | O(N*logN) | O(N) | 稳定 | {1,1,2,2}{1,1,2,2}左边和右边进行比较拼接的时候，先拷贝左边的元素，再拷贝右边的元素 |
| 快速排序 | O(N*logN) | O(logN) | 不稳定 | {3,4,5,6,6,6,6,6,|2,333} 2会和第一个6进行交换，打破了相对次序 |
| 堆排序 | O(N*logN) | O(1) | 不稳定 | 树状结构，{5,5,5,5,6}第一个5会和6交换，不稳定 |
| 桶排序（基数/计数） | O(N) | O(M) | 稳定 | 非比较 |
- 归并、快排、和堆排序最为关键；不在乎稳定性的前提小，使用快速排序最好，时间最快（实验可知）；需要稳定性的话，使用归并排序；在乎额外空间的话，使用堆排序
常见的坑
- 归并排序的额外空间复杂度可以变为O(1)，但是会失去稳定性的优势，详见《归并排序，内部缓冲法》
- 原地归并排序，很垃圾，会将时间复杂度变成O(N^2)
- 快速排序也可以做到稳定性，但是非常难，详见《01 stable sort》
- 所有的改进都不重要 目前没有 时间复杂度为O(N*logN) 额外空间复杂度为 O(1) 又稳定的排序
- 将一个数组中，所有的奇数移到数组的左边，所有的偶数移到数组的右边。保持相对次序不变的同时，要是时间复杂度为O(N),空间复杂度为O(1)。这个没法做😂😂😂😂
对于排序的改进优化
- 充分利用O(N*logN)和O(N^2)的排序的各自优势
-
数据规模很大的时候使用快速排序，当数据规模减少，数据项在60以内的时候，该换成插入排序，同时使用快速和插入两种方法，能进一步提高效率，减少时间复杂度。
稳定性考虑
- 如果输入的数据是基础类型，使用快速排序；如果输入的类型是自定义的类型，使用插入、归并这些可以保证稳定性的排序方法
- Java里面自带的排序算法，即array.sort，如果是常规类型，比如int的话是使用快速排序，提高速度；如果是自定义的类型，比如学生的年龄，结构体定义的字段，会使用桶排序，保证比较的稳定性。即算法看重时间复杂度 空间复杂度和稳定性（数值相等的元素排序，保证先后次序不变）
- 基础类型按照数值传递，非基础类型，比如自定义结构体按照引用传递，具体体现在integer这个类型，127相等，128就不等了。因为128以上就作为不同内存了，也就是按照引用比较了
