diff --git a/codes/c/chapter_sorting/counting_sort.c b/codes/c/chapter_sorting/counting_sort.c index 3fdadded6..859c44873 100644 --- a/codes/c/chapter_sorting/counting_sort.c +++ b/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; } diff --git a/codes/cpp/chapter_sorting/counting_sort.cpp b/codes/cpp/chapter_sorting/counting_sort.cpp new file mode 100644 index 000000000..45e75284a --- /dev/null +++ b/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& nums) { + // 1. 统计数组最大元素 m + int m = 0; + for (int num : nums) { + m = max(m, num); + } + // 2. 统计各数字的出现次数 + // counter[num] 代表 num 的出现次数 + vector 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& nums) { + // 1. 统计数组最大元素 m + int m = 0; + for (int num : nums) { + m = max(m, num); + } + // 2. 统计各数字的出现次数 + // counter[num] 代表 num 的出现次数 + vector 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 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 nums = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 }; + countingSortNaive(nums); + cout << "计数排序（无法排序对象）完成后 nums = "; + PrintUtil::printVector(nums); + + vector nums1 = { 1, 0, 1, 2, 0, 4, 0, 2, 2, 4 }; + countingSort(nums1); + cout << "计数排序完成后 nums1 = "; + PrintUtil::printVector(nums1); + + return 0; +} diff --git a/codes/go/chapter_sorting/counting_sort_test.go b/codes/go/chapter_sorting/counting_sort_test.go index cd934275f..0a5c88e8a 100644 --- a/codes/go/chapter_sorting/counting_sort_test.go +++ b/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) } diff --git a/codes/java/chapter_sorting/counting_sort.java b/codes/java/chapter_sorting/counting_sort.java index 79b6292d1..c3182c3b4 100644 --- a/codes/java/chapter_sorting/counting_sort.java +++ b/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)); } } diff --git a/codes/python/chapter_sorting/counting_sort.py b/codes/python/chapter_sorting/counting_sort.py new file mode 100644 index 000000000..64be8e2fd --- /dev/null +++ b/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}") diff --git a/docs/chapter_computational_complexity/summary.md b/docs/chapter_computational_complexity/summary.md index e96e0addf..e4e1d5773 100644 --- a/docs/chapter_computational_complexity/summary.md +++ b/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)$ 。