Add Python and C++ code for the counting sort. (#436)

codes/c/chapter_sorting/counting_sort.c

@@ -72,9 +72,11 @@ int main() {
     printf("计数排序（无法排序对象）完成后 nums = ");
     printArray(nums, size);
 
-    countingSort(nums, size);
-    printf("计数排序完成后 nums = ");
-    printArray(nums, size);
+    int nums1[] = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
+    int size1 = sizeof(nums1) / sizeof(int);
+    countingSort(nums1, size1);
+    printf("计数排序完成后 nums1 = ");
+    printArray(nums1, size1);
 
     return 0;
 }

codes/cpp/chapter_sorting/counting_sort.cpp

@@ -0,0 +1,77 @@
+/**
+ * File: counting_sort.cpp
+ * Created Time: 2023-03-17
+ * Author: Krahets (krahets@163.com)
+ */
+
+#include "../include/include.hpp"
+
+/* 计数排序 */
+// 简单实现，无法用于排序对象
+void countingSortNaive(vector<int>& nums) {
+    // 1. 统计数组最大元素 m
+    int m = 0;
+    for (int num : nums) {
+        m = max(m, num);
+    }
+    // 2. 统计各数字的出现次数
+    // counter[num] 代表 num 的出现次数
+    vector<int> counter(m + 1, 0);
+    for (int num : nums) {
+        counter[num]++;
+    }
+    // 3. 遍历 counter ，将各元素填入原数组 nums
+    int i = 0;
+    for (int num = 0; num < m + 1; num++) {
+        for (int j = 0; j < counter[num]; j++, i++) {
+            nums[i] = num;
+        }
+    }
+}
+
+/* 计数排序 */
+// 完整实现，可排序对象，并且是稳定排序
+void countingSort(vector<int>& nums) {
+    // 1. 统计数组最大元素 m
+    int m = 0;
+    for (int num : nums) {
+        m = max(m, num);
+    }
+    // 2. 统计各数字的出现次数
+    // counter[num] 代表 num 的出现次数
+    vector<int> counter(m + 1, 0);
+    for (int num : nums) {
+        counter[num]++;
+    }
+    // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+    // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+    for (int i = 0; i < m; i++) {
+        counter[i + 1] += counter[i];
+    }
+    // 4. 倒序遍历 nums ，将各元素填入结果数组 res
+    // 初始化数组 res 用于记录结果
+    int n = nums.size();
+    vector<int> res(n);
+    for (int i = n - 1; i >= 0; i--) {
+        int num = nums[i];
+        res[counter[num] - 1] = num; // 将 num 放置到对应索引处
+        counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
+    }
+    // 使用结果数组 res 覆盖原数组 nums
+    nums = res;
+}
+
+/* Driver Code */
+int main() {
+    vector<int> nums = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
+    countingSortNaive(nums);
+    cout << "计数排序（无法排序对象）完成后 nums = ";
+    PrintUtil::printVector(nums);
+
+    vector<int> nums1 = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
+    countingSort(nums1);
+    cout << "计数排序完成后 nums1 = ";
+    PrintUtil::printVector(nums1);
+
+    return 0;
+}

codes/go/chapter_sorting/counting_sort_test.go

@@ -14,6 +14,7 @@ func TestCountingSort(t *testing.T) {
 	countingSortNaive(nums)
 	fmt.Println("计数排序（无法排序对象）完成后 nums = ", nums)
 
-	countingSort(nums)
-	fmt.Println("计数排序完成后 nums = ", nums)
+	nums1 := []int{1, 0, 1, 2, 0, 4, 0, 2, 2, 4}
+	countingSort(nums1)
+	fmt.Println("计数排序完成后 nums1 = ", nums1)
 }

codes/java/chapter_sorting/counting_sort.java

@@ -68,11 +68,11 @@ public class counting_sort {
 
     public static void main(String[] args) {
         int[] nums = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
-
         countingSortNaive(nums);
         System.out.println("计数排序（无法排序对象）完成后 nums = " + Arrays.toString(nums));
-
-        countingSort(nums);
-        System.out.println("计数排序完成后 nums = " + Arrays.toString(nums));
+        
+        int[] nums1 = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 };
+        countingSort(nums1);
+        System.out.println("计数排序完成后 nums1 = " + Arrays.toString(nums1));
     }
 }

codes/python/chapter_sorting/counting_sort.py

@@ -0,0 +1,65 @@
+"""
+File: bubble_sort.py
+Created Time: 2023-03-21
+Author: Krahets (krahets@163.com)
+"""
+
+import sys, os.path as osp
+sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
+from modules import *
+
+def counting_sort_naive(nums: List[int]) -> None:
+    """ 计数排序 """
+    # 简单实现，无法用于排序对象
+    # 1. 统计数组最大元素 m
+    m = 0
+    for num in nums:
+        m = max(m, num)
+    # 2. 统计各数字的出现次数
+    # counter[num] 代表 num 的出现次数
+    counter = [0] * (m + 1)
+    for num in nums:
+        counter[num] += 1
+    # 3. 遍历 counter ，将各元素填入原数组 nums
+    i = 0
+    for num in range(m + 1):
+        for _ in range(counter[num]):
+            nums[i] = num
+            i += 1
+
+def counting_sort(nums: List[int]) -> None:
+    """ 计数排序 """
+    # 完整实现，可排序对象，并且是稳定排序
+    # 1. 统计数组最大元素 m
+    m = max(nums)
+    # 2. 统计各数字的出现次数
+    # counter[num] 代表 num 的出现次数
+    counter = [0] * (m + 1)
+    for num in nums:
+        counter[num] += 1
+    # 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
+    # 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
+    for i in range(m):
+        counter[i + 1] += counter[i]
+    # 4. 倒序遍历 nums ，将各元素填入结果数组 res
+    # 初始化数组 res 用于记录结果
+    n = len(nums)
+    res = [0] * n
+    for i in range(n - 1, -1, -1):
+        num = nums[i]
+        res[counter[num] - 1] = num  # 将 num 放置到对应索引处
+        counter[num] -= 1  # 令前缀和自减 1 ，得到下次放置 num 的索引
+    # 使用结果数组 res 覆盖原数组 nums
+    for i in range(n):
+        nums[i] = res[i]
+
+""" Driver Code """
+if __name__ == "__main__":
+    nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
+
+    counting_sort_naive(nums)
+    print(f"计数排序（无法排序对象）完成后 nums = {nums}")
+
+    nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
+    counting_sort(nums1)
+    print(f"计数排序完成后 nums1 = {nums1}")

docs/chapter_computational_complexity/summary.md

@@ -2,23 +2,22 @@
 
 ### 算法效率评估
 
-- 「时间效率」和「空间效率」是算法性能的两个重要的评价维度。
-- 我们可以通过「实际测试」来评估算法效率，但难以排除测试环境的干扰，并且非常耗费计算资源。
-- 「复杂度分析」克服了实际测试的弊端，分析结果适用于所有运行平台，并且可以体现不同数据大小下的算法效率。
+- 时间效率和空间效率是算法性能的两个重要的评价维度。
+- 我们可以通过实际测试来评估算法效率，但难以排除测试环境的干扰，并且非常耗费计算资源。
+- 复杂度分析克服了实际测试的弊端，分析结果适用于所有运行平台，并且可以体现不同数据大小下的算法效率。
 
 ### 时间复杂度
 
-- 「时间复杂度」统计算法运行时间随着数据量变大时的增长趋势，可以有效评估算法效率，但在某些情况下可能失效，比如在输入数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣性。
-- 「最差时间复杂度」使用大 $O$ 符号表示，即函数渐近上界，其反映当 $n$ 趋于正无穷时，$T(n)$ 处于何种增长级别。
+- 时间复杂度统计算法运行时间随着数据量变大时的增长趋势，可以有效评估算法效率，但在某些情况下可能失效，比如在输入数据量较小或时间复杂度相同时，无法精确对比算法效率的优劣性。
+- 最差时间复杂度使用大 $O$ 符号表示，即函数渐近上界，其反映当 $n$ 趋于正无穷时，$T(n)$ 处于何种增长级别。
 - 推算时间复杂度分为两步，首先统计计算操作数量，再判断渐近上界。
 - 常见时间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n \log n)$ , $O(n^2)$ , $O(2^n)$ , $O(n!)$ 。
-- 某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关。时间复杂度分为「最差时间复杂度」和「最佳时间复杂度」，后者几乎不用，因为输入数据需要满足苛刻的条件才能达到最佳情况。
-- 「平均时间复杂度」可以反映在随机数据输入下的算法效率，最贴合实际使用情况下的算法性能。计算平均时间复杂度需要统计输入数据的分布，以及综合后的数学期望。
+- 某些算法的时间复杂度不是恒定的，而是与输入数据的分布有关。时间复杂度分为最差时间复杂度和最佳时间复杂度，后者几乎不用，因为输入数据需要满足苛刻的条件才能达到最佳情况。
+- 平均时间复杂度可以反映在随机数据输入下的算法效率，最贴合实际使用情况下的算法性能。计算平均时间复杂度需要统计输入数据的分布，以及综合后的数学期望。
 
 ### 空间复杂度
 
-- 与时间复杂度的定义类似，「空间复杂度」统计算法占用空间随着数据量变大时的增长趋势。
-
+- 与时间复杂度的定义类似，空间复杂度统计算法占用空间随着数据量变大时的增长趋势。
 - 算法运行中相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下，输入空间不计入空间复杂度计算。暂存空间可分为指令空间、数据空间、栈帧空间，其中栈帧空间一般在递归函数中才会影响到空间复杂度。
-- 我们一般只关心「最差空间复杂度」，即统计算法在「最差输入数据」和「最差运行时间点」下的空间复杂度。
+- 我们一般只关心最差空间复杂度，即统计算法在最差输入数据和最差运行时间点下的空间复杂度。
 - 常见空间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n^2)$ , $O(2^n)$ 。