update note about count sort

src/main/java/snippet/Code_0031_CountSort.java

-package snippet;
-
-import java.util.Arrays;
-
-/**
- * 计数排序 一般来讲，计数排序要求，样本是整数，且范围比较窄 桶排序思想下的排序：计数排序 & 基数排序
- * <p>
- * 1)桶排序思想下的排序都是不基于比较的排序
- * <p>
- * 2)时间复杂度为O(N)，额外空间负载度O(M)
- * <p>
- * 3)应用范围有限，需要样本的数据状况满足桶的划分
- */
-public class Code_0031_CountSort {
-    // 非负数
-    public static void countSort(int[] arr) {
-        if (null == arr || arr.length <= 1) {
-            return;
-        }
-        int max = arr[0];
-        for (int i = 1; i < arr.length; i++) {
-            max = Math.max(arr[i], max);
-        }
-        int[] help = new int[max + 1];
-        for (int j : arr) {
-            help[j]++;
-        }
-        int t = 0;
-        for (int i = 0; i < help.length; i++) {
-            while (help[i] != 0) {
-                arr[t++] = i;
-                help[i]--;
-            }
-        }
-    }
-
-    // for test
-    public static void comparator(int[] arr) {
-        Arrays.sort(arr);
-    }
-
-    // for test
-    public 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 test
-    public 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 test
-    public static boolean isEqual(int[] arr1, int[] arr2) {
-        if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
-            return false;
-        }
-        if (arr1 == 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 test
-    public 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 test
-    public static void main(String[] args) {
-        int testTime = 500000;
-        int maxSize = 100;
-        int maxValue = 150;
-        boolean succeed = true;
-        for (int i = 0; i < testTime; i++) {
-            int[] arr1 = generateRandomArray(maxSize, maxValue);
-            int[] arr2 = copyArray(arr1);
-            countSort(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);
-        countSort(arr);
-        printArray(arr);
-
-    }
-
-}
\ No newline at end of file

src/main/java/snippet/Code_0032_RadixSort.java

-package snippet;
-
-import java.util.Arrays;
-
-/**
- * 基数排序 一般来讲，基数排序要求，样本是10进制的正整数, 流程如下
- * <p>
- * 1. 找到最大值，这个最大值是几位的
- * <p>
- * 2. 其他数不足这个位数的，用0补齐
- * <p>
- * 3. 准备10个桶，每个桶是队列
- * <p>
- * 4. 从个位依次进桶
- * <p>
- * 5. 然后依次倒出
- * <p>
- * 6. 根据十位数进桶
- * <p>
- * 7. 依次倒出 .......
- * <p>
- * 1) 桶排序思想下的排序都是不基于比较的排序
- * <p>
- * 2) 时间复杂度为O(N)，额外空间复杂度O(M)
- * <p>
- * 3) 应用范围有限，需要样本的数据状况满足桶的划分
- */
-public class Code_0032_RadixSort {
-
-    // 非负数
-    public static void radixSort(int[] arr) {
-        if (arr == null || arr.length <= 1) {
-            return;
-        }
-        int max = arr[0];
-        for (int i = 1; i < arr.length; i++) {
-            max = Math.max(arr[i], max);
-        }
-        // 最大值有几位
-        int bits = 0;
-        while (max != 0) {
-            bits++;
-            max /= 10;
-        }
-        int[] help = new int[arr.length];
-        for (int bit = 1; bit <= bits; bit++) {
-            int[] count = new int[10];
-            for (int num : arr) {
-                count[digit(num, bit)]++;
-            }
-            // 前缀和
-            for (int j = 1; j < 10; j++) {
-                count[j] = count[j - 1] + count[j];
-            }
-            // 倒序遍历数组
-            for (int i = arr.length - 1; i >= 0; i--) {
-                int pos = digit(arr[i], bit);
-                help[--count[pos]] = arr[i];
-            }
-            int m = 0;
-            for (int num : help) {
-                arr[m++] = num;
-            }
-        }
-
-    }
-
-    // 获取某个数在某一位上的值
-    // 从1开始，从个位开始
-    public static int digit(int num, int digit) {
-        return ((num / (int) Math.pow(10, digit - 1)) % 10);
-    }
-
-    // for test
-    public static void comparator(int[] arr) {
-        Arrays.sort(arr);
-    }
-
-    // for test
-    public 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 test
-    public 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 test
-    public 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 test
-    public 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 test
-    public static void main(String[] args) {
-        int testTime = 500000;
-        int maxSize = 100;
-        int maxValue = 10000;
-        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);
-
-    }
-
-}

src/main/java/snippet/Code_CountSort.java

+package snippet;
+
+import java.util.Arrays;
+// 笔记：https://www.cnblogs.com/greyzeng/p/16928076.html
+/**
+ * 计数排序 一般来讲，计数排序要求，样本是整数，且范围比较窄 桶排序思想下的排序：计数排序 & 基数排序
+ *
+ * <p>1)桶排序思想下的排序都是不基于比较的排序
+ *
+ * <p>2)时间复杂度为O(N)，额外空间负载度O(M)
+ *
+ * <p>3)应用范围有限，需要样本的数据状况满足桶的划分
+ */
+public class Code_CountSort {
+  // 非负数
+  public static void countSort(int[] arr) {
+    if (null == arr || arr.length <= 1) {
+      return;
+    }
+    int max = arr[0];
+    for (int i = 1; i < arr.length; i++) {
+      max = Math.max(arr[i], max);
+    }
+    int[] help = new int[max + 1];
+    for (int j : arr) {
+      help[j]++;
+    }
+    int t = 0;
+    for (int i = 0; i < help.length; i++) {
+      while (help[i] != 0) {
+        arr[t++] = i;
+        help[i]--;
+      }
+    }
+  }
+
+  // for test
+  public static void comparator(int[] arr) {
+    Arrays.sort(arr);
+  }
+
+  // for test
+  public 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 test
+  public 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 test
+  public static boolean isEqual(int[] arr1, int[] arr2) {
+    if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
+      return false;
+    }
+    if (arr1 == 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 test
+  public 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 test
+  public static void main(String[] args) {
+    int testTime = 500000;
+    int maxSize = 100;
+    int maxValue = 150;
+    boolean succeed = true;
+    for (int i = 0; i < testTime; i++) {
+      int[] arr1 = generateRandomArray(maxSize, maxValue);
+      int[] arr2 = copyArray(arr1);
+      countSort(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);
+    countSort(arr);
+    printArray(arr);
+  }
+}

src/main/java/snippet/Code_RadixSort.java

+package snippet;
+
+import java.util.Arrays;
+
+// 笔记：
+/**
+ * 基数排序 一般来讲，基数排序要求，样本是10进制的正整数, 流程如下
+ *
+ * <p>1. 找到最大值，这个最大值是几位的
+ *
+ * <p>2. 其他数不足这个位数的，用0补齐
+ *
+ * <p>3. 准备10个桶，每个桶是队列
+ *
+ * <p>4. 从个位依次进桶
+ *
+ * <p>5. 然后依次倒出
+ *
+ * <p>6. 根据十位数进桶
+ *
+ * <p>7. 依次倒出 .......
+ *
+ * <p>1) 桶排序思想下的排序都是不基于比较的排序
+ *
+ * <p>2) 时间复杂度为O(N)，额外空间复杂度O(M)
+ *
+ * <p>3) 应用范围有限，需要样本的数据状况满足桶的划分
+ */
+public class Code_RadixSort {
+
+  // 非负数
+  public static void radixSort(int[] arr) {
+    if (arr == null || arr.length <= 1) {
+      return;
+    }
+    int max = arr[0];
+    for (int i = 1; i < arr.length; i++) {
+      max = Math.max(arr[i], max);
+    }
+    // 最大值有几位
+    int bits = 0;
+    while (max != 0) {
+      bits++;
+      max /= 10;
+    }
+    int[] help = new int[arr.length];
+    for (int bit = 1; bit <= bits; bit++) {
+      int[] count = new int[10];
+      for (int num : arr) {
+        count[digit(num, bit)]++;
+      }
+      // 前缀和
+      for (int j = 1; j < 10; j++) {
+        count[j] = count[j - 1] + count[j];
+      }
+      // 倒序遍历数组
+      for (int i = arr.length - 1; i >= 0; i--) {
+        int pos = digit(arr[i], bit);
+        help[--count[pos]] = arr[i];
+      }
+      int m = 0;
+      for (int num : help) {
+        arr[m++] = num;
+      }
+    }
+  }
+
+  // 获取某个数在某一位上的值
+  // 从1开始，从个位开始
+  public static int digit(int num, int digit) {
+    return ((num / (int) Math.pow(10, digit - 1)) % 10);
+  }
+
+  // for test
+  public static void comparator(int[] arr) {
+    Arrays.sort(arr);
+  }
+
+  // for test
+  public 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 test
+  public 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 test
+  public 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 test
+  public 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 test
+  public static void main(String[] args) {
+    int testTime = 500000;
+    int maxSize = 100;
+    int maxValue = 10000;
+    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);
+
+  }
+}