Merge pull request #273 from Reanon/feat-c-sort

Add quick_sort/radix_sort to C code.

codes/c/chapter_sorting/CMakeLists.txt

@@ -1,2 +1,4 @@
 add_executable(bubble_sort bubble_sort.c)
-add_executable(insertion_sort insertion_sort.c)
+add_executable(insertion_sort insertion_sort.c)
+add_executable(quick_sort quick_sort.c)
+add_executable(radix_sort radix_sort.c)

codes/c/chapter_sorting/quick_sort.c

@@ -0,0 +1,154 @@
+/**
+ * File: quick_sort.c
+ * Created Time: 2023-01-18
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../include/include.h"
+
+/* 元素交换 */
+void swap(int nums[], int i, int j) {
+    int tmp = nums[i];
+    nums[i] = nums[j];
+    nums[j] = tmp;
+}
+
+/* 快速排序类 */
+// 快速排序类-哨兵划分
+int quickSortPartition(int nums[], int left, int right) {
+    // 以 nums[left] 作为基准数
+    int i = left, j = right;
+    while (i < j) {
+        while (i < j && nums[j] >= nums[left]) {
+            // 从右向左找首个小于基准数的元素
+            j--;
+        }
+        while (i < j && nums[i] <= nums[left]) {
+            // 从左向右找首个大于基准数的元素
+            i++;
+        }
+        // 交换这两个元素
+        swap(nums, i, j);
+    }
+    // 将基准数交换至两子数组的分界线
+    swap(nums, i, left);
+    // 返回基准数的索引
+    return i;
+}
+
+// 快速排序类-快速排序
+void quickSort(int nums[], int left, int right) {
+    // 子数组长度为 1 时终止递归
+    if (left >= right) {
+        return;
+    }
+    // 哨兵划分
+    int pivot = quickSortPartition(nums, left, right);
+    // 递归左子数组、右子数组
+    quickSort(nums, left, pivot - 1);
+    quickSort(nums, pivot + 1, right);
+}
+
+/* 快速排序类（中位基准数优化） */
+// 选取三个元素的中位数
+int medianThree(int nums[], int left, int mid, int right) {
+    // 使用了异或操作来简化代码
+    // 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
+    if ((nums[left] < nums[mid]) ^ (nums[left] < nums[right]))
+        return left;
+    else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
+        return mid;
+    else
+        return right;
+}
+
+// 哨兵划分（三数取中值）
+int QuickSortMedianPartition(int nums[], int left, int right) {
+    // 选取三个候选元素的中位数
+    int med = medianThree(nums, left, (left + right) / 2, right);
+    // 将中位数交换至数组最左端
+    swap(nums, left, med);
+    // 以 nums[left] 作为基准数
+    int i = left, j = right;
+    while (i < j) {
+        while (i < j && nums[j] >= nums[left])
+            j--;          // 从右向左找首个小于基准数的元素
+        while (i < j && nums[i] <= nums[left])
+            i++;          // 从左向右找首个大于基准数的元素
+        swap(nums, i, j); // 交换这两个元素
+    }
+    swap(nums, i, left);  // 将基准数交换至两子数组的分界线
+    return i;             // 返回基准数的索引
+}
+
+// 中位基准数优化-快速排序
+void quickSortMedian(int nums[], int left, int right) {
+    // 子数组长度为 1 时终止递归
+    if (left >= right)
+        return;
+    // 哨兵划分
+    int pivot = QuickSortMedianPartition(nums, left, right);
+    // 递归左子数组、右子数组
+    quickSortMedian(nums, left, pivot - 1);
+    quickSortMedian(nums, pivot + 1, right);
+}
+
+
+/* 快速排序类（尾递归优化） */
+/* 尾递归优化-哨兵划分 */
+int quickSortTailCallPartition(int nums[], int left, int right) {
+    // 以 nums[left] 作为基准数
+    int i = left, j = right;
+    while (i < j) {
+        while (i < j && nums[j] >= nums[left])
+            j--;          // 从右向左找首个小于基准数的元素
+        while (i < j && nums[i] <= nums[left])
+            i++;          // 从左向右找首个大于基准数的元素
+        swap(nums, i, j); // 交换这两个元素
+    }
+    swap(nums, i, left);  // 将基准数交换至两子数组的分界线
+    return i; // 返回基准数的索引
+}
+
+
+// 快速排序（尾递归优化）
+void quickSortTailCall(int nums[], int left, int right) {
+    // 子数组长度为 1 时终止
+    while (left < right) {
+        // 哨兵划分操作
+        int pivot = quickSortTailCallPartition(nums, left, right);
+        // 对两个子数组中较短的那个执行快排
+        if (pivot - left < right - pivot) {
+            quickSortTailCall(nums, left, pivot - 1);  // 递归排序左子数组
+            left = pivot + 1;  // 剩余待排序区间为 [pivot + 1, right]
+        } else {
+            quickSortTailCall(nums, pivot + 1, right); // 递归排序右子数组
+            right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+        }
+    }
+}
+
+
+/* Driver Code */
+int main() {
+    /* 快速排序 */
+    int nums[] = {2, 4, 1, 0, 3, 5};
+    int size = sizeof(nums) / sizeof(int);
+    quickSort(nums, 0, size - 1);
+    printf("快速排序完成后 nums = ");
+    printArray(nums, size);
+
+    /* 快速排序（中位基准数优化） */
+    int nums1[] = {2, 4, 1, 0, 3, 5};
+    quickSortMedian(nums1, 0, size - 1);
+    printf("快速排序（中位基准数优化）完成后 nums = ");
+    printArray(nums1, size);
+
+    /* 快速排序（尾递归优化） */
+    int nums2[] = {2, 4, 1, 0, 3, 5};
+    quickSortTailCall(nums2, 0, size - 1);
+    printf("快速排序（尾递归优化）完成后 nums = ");
+    printArray(nums1, size);
+
+    return 0;
+}

codes/c/chapter_sorting/radix_sort.c

@@ -0,0 +1,70 @@
+/**
+ * File: radix_sort.c
+ * Created Time: 2023-01-18
+ * Author: Reanon (793584285@qq.com)
+ */
+
+#include "../include/include.h"
+
+/* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
+int digit(int num, int exp) {
+    // 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
+    return (num / exp) % 10;
+}
+
+/* 计数排序（根据 nums 第 k 位排序） */
+void countSort(int nums[], int size, int exp) {
+    // 十进制的各位数字范围为 0~9 ，因此需要长度为 10 的桶
+    int *bucket = (int *) malloc((sizeof(int) * 10));
+    // 借助桶来统计 0~9 各数字的出现次数
+    for (int i = 0; i < size; i++) {
+        // 获取 nums[i] 第 k 位，记为 d
+        int d = digit(nums[i], exp);
+        // 统计数字 d 的出现次数
+        bucket[d]++;
+    }
+    // 求前缀和，将“出现个数”转换为“数组索引”
+    for (int i = 1; i < 10; i++) {
+        bucket[i] += bucket[i - 1];
+    }
+    // 倒序遍历，根据桶内统计结果，将各元素填入暂存数组 tmp
+    int *tmp = (int *) malloc(sizeof(int) * size);
+    for (int i = size - 1; i >= 0; i--) {
+        int d = digit(nums[i], exp);
+        int j = bucket[d] - 1; // 获取 d 在数组中的索引 j
+        tmp[j] = nums[i];      // 将当前元素填入索引 j
+        bucket[d]--;           // 将 d 的数量减 1
+    }
+    // 将 tmp 复制到 nums
+    for (int i = 0; i < size; i++) {
+        nums[i] = tmp[i];
+    }
+}
+
+/* 基数排序 */
+void radixSort(int nums[], int size) {
+    // 获取数组的最大元素，用于判断最大位数
+    int max = INT32_MIN;
+    for (size_t i = 0; i < size - 1; i++) {
+        if (nums[i] > max) {
+            max = nums[i];
+        }
+    }
+    // 按照从低位到高位的顺序遍历
+    for (int exp = 1; max >= exp; exp *= 10)
+        // 对数组元素的第 k 位执行「计数排序」
+        // k = 1 -> exp = 1
+        // k = 2 -> exp = 10
+        // k = 3 -> exp = 100
+        // 即 exp = 10^(k-1)
+        countSort(nums, size, exp);
+}
+
+int main() {
+    /* 基数排序 */
+    int nums[] = {23, 12, 3, 4, 788, 192};
+    int size = sizeof(nums) / sizeof(int);
+    radixSort(nums, size);
+    printf("基数排序完成后 nums = ");
+    printArray(nums, size);
+}