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

This commit is contained in:
Yudong Jin 2023-03-21 22:24:17 +08:00 committed by GitHub
parent 6d452777a4
commit 65e47b0748
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 163 additions and 19 deletions

View file

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

View file

@ -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;
}

View file

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

View file

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

View file

@ -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}")

View file

@ -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 \log n)$ , $O(n^2)$ , $O(2^n)$ , $O(n!)$ 。
- 某些算法的时间复杂度不是恒定的,而是与输入数据的分布有关。时间复杂度分为最差时间复杂度最佳时间复杂度,后者几乎不用,因为输入数据需要满足苛刻的条件才能达到最佳情况。 - 某些算法的时间复杂度不是恒定的,而是与输入数据的分布有关。时间复杂度分为最差时间复杂度和最佳时间复杂度,后者几乎不用,因为输入数据需要满足苛刻的条件才能达到最佳情况。
- 平均时间复杂度可以反映在随机数据输入下的算法效率,最贴合实际使用情况下的算法性能。计算平均时间复杂度需要统计输入数据的分布,以及综合后的数学期望。 - 平均时间复杂度可以反映在随机数据输入下的算法效率,最贴合实际使用情况下的算法性能。计算平均时间复杂度需要统计输入数据的分布,以及综合后的数学期望。
### 空间复杂度 ### 空间复杂度
- 与时间复杂度的定义类似,「空间复杂度」统计算法占用空间随着数据量变大时的增长趋势。 - 与时间复杂度的定义类似,空间复杂度统计算法占用空间随着数据量变大时的增长趋势。
- 算法运行中相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下,输入空间不计入空间复杂度计算。暂存空间可分为指令空间、数据空间、栈帧空间,其中栈帧空间一般在递归函数中才会影响到空间复杂度。 - 算法运行中相关内存空间可分为输入空间、暂存空间、输出空间。通常情况下,输入空间不计入空间复杂度计算。暂存空间可分为指令空间、数据空间、栈帧空间,其中栈帧空间一般在递归函数中才会影响到空间复杂度。
- 我们一般只关心最差空间复杂度,即统计算法在最差输入数据最差运行时间点下的空间复杂度。 - 我们一般只关心最差空间复杂度,即统计算法在最差输入数据和最差运行时间点下的空间复杂度。
- 常见空间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n^2)$ , $O(2^n)$ 。 - 常见空间复杂度从小到大排列有 $O(1)$ , $O(\log n)$ , $O(n)$ , $O(n^2)$ , $O(2^n)$ 。