添加计数排序

Author: dyh

java/java_test/src/sort/CountSort.java

@@ -0,0 +1,51 @@
+package sort;
+
+import java.util.Arrays;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/11/30 17:38
+ * @description 计数排序
+ */
+public class CountSort {
+    public static void countingSort(int[] arr) {
+        if (arr == null || arr.length < 2)  return;
+        int max = arr[0];
+        int min = arr[0];
+        for (int num : arr) {
+            if (num > max) max = num;
+            if (num < min) min = num;
+        }
+        int rangeNum = max - min + 1;
+        int count[] = new int[rangeNum];
+        for(int ele : arr){
+            count[ele - min] ++;
+
+        }
+        System.out.println(Arrays.toString(count));
+        int preCount = 0;//计数
+        for (int i = 0 ; i < rangeNum; i ++){
+            preCount += count[i];
+            count[i] = preCount - count[i];
+//            System.out.println(count[i]);
+        }
+        System.out.println(Arrays.toString(count));
+
+        int res[] = new int[arr.length];
+        for(int ele : arr){
+            res[count[ele - min]] = ele;
+            count[ele - min]--;
+        }
+        int i = 0;
+        for (int ele : res) {
+            arr[i++] = ele;
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] arr = new int[]{6, 6, 12, 31, 54, 4};
+        countingSort(arr);
+        System.out.println(Arrays.toString(arr));
+    }
+}

java/java_test/src/sort/MergeSort.java

@@ -0,0 +1,139 @@
+package sort;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/11/30 15:38
+ * @description
+ */
+public class MergeSort {
+    public static int[] merge(int[] arr1, int[] arr2){
+        int[] res = new int[arr1.length + arr2.length];
+        int i = 0, j = 0;
+        while(i < arr1.length && j < arr2.length){
+            if(arr1[i] < arr2[j]){
+                res[i+j] = arr1[i];
+                i ++;
+            }else {
+                res[i+j] = arr2[j];
+                j++;
+            }
+        }
+        while(i < arr1.length){
+            res[i+j] = arr1[i];
+            i++;
+        }
+        while(j < arr2.length){
+            res[i+j] = arr2[j];
+            j++;
+        }
+        return res;
+    }
+
+    public static void mergeSort(int[] arr) {
+        if (arr.length == 0) return;
+        int[] result = mergeSort(arr, 0, arr.length - 1);
+        // 将结果拷贝到 arr 数组中
+        for (int i = 0; i < result.length; i++) {
+            arr[i] = result[i];
+        }
+    }
+
+    // 对 arr 的 [start, end] 区间归并排序
+    private static int[] mergeSort(int[] arr, int start, int end) {
+        // 只剩下一个数字，停止拆分，返回单个数字组成的数组
+        if (start == end) return new int[]{arr[start]};
+        int middle = (start + end) / 2;
+        // 拆分左边区域
+        int[] left = mergeSort(arr, start, middle);
+        // 拆分右边区域
+        int[] right = mergeSort(arr, middle + 1, end);
+        // 合并左右区域
+        return merge(left, right);
+    }
+    
+    private static void merge(int[] arr, int start,  int end, int[] result) {
+        int middle = (start + end) / 2;
+        // 数组 1 的首尾位置
+        int start1 = start;
+        int end1 = middle;
+        // 数组 2 的首尾位置
+        int start2 = middle + 1;
+        int end2 = end;
+        // 用来遍历数组的指针
+        int index1 = start1;
+        int index2 = start2;
+        // 结果数组的指针
+        int resultIndex = start1;
+        while (index1 <= end1 && index2 <= end2) {
+            if (arr[index1] <= arr[index2]) {
+                result[resultIndex++] = arr[index1++];
+            } else {
+                result[resultIndex++] = arr[index2++];
+            }
+        }
+        // 将剩余数字补到结果数组之后
+        while (index1 <= end1) {
+            result[resultIndex++] = arr[index1++];
+        }
+        while (index2 <= end2) {
+            result[resultIndex++] = arr[index2++];
+        }
+        // 将 result 操作区间的数字拷贝到 arr 数组中，以便下次比较
+        for (int i = start; i <= end; i++) {
+            arr[i] = result[i];
+        }
+    }
+
+    public static void main(String[] args) {
+        int[] arr = new int[]{6, 2, 1, 3, 5, 4};
+        mergeSort2(arr);
+        System.out.println(Arrays.toString(arr));
+    }
+
+    //原地归并
+    public static void mergeSort2(int[] arr) {
+        if (arr.length == 0) return;
+        mergeSort2(arr, 0, arr.length - 1);
+    }
+
+    private static void mergeSort2(int[] arr, int start, int end) {
+        // 只剩下一个数字，停止拆分
+        if (start == end) return;
+        int middle = (start + end) / 2;
+        // 拆分左边区域
+        mergeSort2(arr, start, middle);
+        // 拆分右边区域
+        mergeSort2(arr, middle + 1, end);
+        // 合并左右区域
+        merge2(arr, start, end);
+    }
+
+    public static void merge2(int[] arr, int start, int end) {
+        int end1 = (start + end)/2;
+        int start2 = end1 + 1;
+        int idx1 = start;
+        int idx2 = start2;
+        while(idx1 <= end1 && idx2 <= end){
+            if(arr[idx1] < arr[idx2]){
+                idx1 ++;
+            }else {
+                int val = arr[idx2];
+                int index = idx2;
+                while (index > idx1){
+                    arr[index] = arr[index - 1];
+                    index --;
+                }
+                arr[index] = val;
+                idx1 ++;
+                idx2 ++;
+                end1 ++;
+            }
+        }
+    }
+
+
+}

java/java_test/src/sort/RelativeSortArray.java

@@ -0,0 +1,54 @@
+package sort;
+
+import java.util.Arrays;
+
+/**
+ * @author dengyh
+ * @version 1.0
+ * @date 2024/12/1 13:43
+ * @description 相对排序
+ */
+public class RelativeSortArray {
+    public static int[] relativeSortArray(int[] arr1, int[] arr2){
+        if (arr1 == null || arr1.length < 2) return arr1;
+        int min = arr1[0], max = arr1[0];
+        for(int num : arr1){
+            max = Math.max(max, num);
+            min = Math.min(min, num);
+        }
+        int range = max - min + 1;
+        int[] count = new int[range];
+        for(int num:arr1){
+            count[num-min]++;
+        }
+        System.out.println(Arrays.toString(count));
+        int index = 0;
+        int[] res = new int[arr1.length];
+        for(int num : arr2){
+            while (count[num-min] != 0){
+                res[index++] = num;
+                count[num-min] --;
+            }
+        }
+        System.out.println(Arrays.toString(arr2));
+        System.out.println(Arrays.toString(count));
+        System.out.println(index);
+        for (int i = 0; i < count.length; i++){
+            while (count[i] != 0){
+                res[index++] = i + index;
+                count[i] --;
+            }
+        }
+        for (int i = 0; i < res.length; i++){
+            arr1[i] = res[i];
+        }
+        return arr1;
+    }
+
+    public static void main(String[] args) {
+        int[] arr1 = new int[]{2,3,1,3,2,4,6,7,9,2,19};
+        int[] arr2 = new int[]{2,1,4,3,9,6};
+        int[] res = relativeSortArray(arr1, arr2);
+        System.out.println(Arrays.toString(res));
+    }
+}

python/sort/count_sort.py

@@ -0,0 +1,35 @@
+#计数排序
+
+def count_sort(nums):
+    if not nums:
+        return []
+
+        # 找到数组中的最大值和最小值，确定计数范围
+    max_value = max(nums)
+    min_value = min(nums)
+    range_of_values = max_value - min_value + 1
+
+    # 创建计数数组，初始化为0
+    count_array = [0] * range_of_values
+
+    # 统计每个元素出现的次数
+    for num in nums:
+        count_array[num - min_value] += 1
+
+    # 计算计数数组的前缀和，确定每个元素在排序后数组中的位置
+    for i in range(1, range_of_values):
+        count_array[i] += count_array[i - 1]
+
+    # 创建排序后的数组
+    sorted_array = [0] * len(nums)
+
+    # 将元素放入排序后数组的正确位置
+    for num in reversed(nums):
+        sorted_array[count_array[num - min_value] - 1] = num
+        count_array[num - min_value] -= 1
+
+    return sorted_array
+if __name__ == '__main__':
+    nums = [5,1,1,2,0,0]
+    res = count_sort(nums)
+    print(res)

python/sort/merge_sort.py

@@ -0,0 +1,45 @@
+from typing import List
+
+
+class Solution:
+    def mergeSort(self,A: List[int], start: int, end: int):
+        if start == end:
+            return
+        mid = (start + end) // 2
+        self.mergeSort(A, start, mid)
+        self.mergeSort(A, mid + 1, end)
+        self.mergeSort2(A, start, end)
+
+    def mergeSort2(self,A: List[int], start: int, end: int):
+        end1 = (start + end) // 2
+        start2 = end1 + 1
+        idx1 = start, idx2 = start2
+        while idx1 <= end1 and idx2 <= end:
+            if A[idx1] < A[idx2]:
+                idx1 += 1
+            else:
+                val = A[idx2]
+                index = idx2
+                while index > idx1:
+                    A[index + 1] = A[index]
+                    index -= 1
+                A[index] = val
+                idx1 += 1
+                idx2 += 1
+                end1 += 1
+
+    def merge(self, A: List[int], m: int, B: List[int], n: int) -> None:
+        """
+        Do not return anything, modify A in-place instead.
+        """
+        len_A = len(A)
+        if len_A < 2:
+            return A
+        j = 0
+        for i in range(m, len_A):
+            A[i] = B[j]
+            j += 1
+
+        self.mergeSort(A, 0, len_A - 1)
+        return A
+