xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-12 15:36:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-04-18 20:19:07 +08:00
parent cf4a59e3d6
commit 363f1f4b5f
25 changed files with 1910 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files
chapter_sorting/bubble_sort.md
+32 -2
View File
@@ -158,7 +158,20 @@ comments: true
=== "C"
```c title="bubble_sort.c"
[class]{}-[func]{bubbleSort}
/* 冒泡排序 */
void bubbleSort(int nums[], int size) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for (int i = 0; i < size - 1; i++) {
// 内循环：冒泡操作
for (int j = 0; j < size - 1 - i; j++) {
if (nums[j] > nums[j + 1]) {
int temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
}
}
}
}
```
=== "C#"
@@ -379,7 +392,24 @@ comments: true
=== "C"
```c title="bubble_sort.c"
[class]{}-[func]{bubbleSortWithFlag}
/* 冒泡排序（标志优化）*/
void bubbleSortWithFlag(int nums[], int size) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for (int i = 0; i < size - 1; i++) {
bool flag = false;
// 内循环：冒泡操作
for (int j = 0; j < size - 1 - i; j++) {
if (nums[j] > nums[j + 1]) {
int temp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = temp;
flag = true;
}
}
if (!flag)
break;
}
}
```
=== "C#"
chapter_sorting/counting_sort.md
+56 -2
View File
@@ -181,7 +181,30 @@ comments: true
=== "C"
```c title="counting_sort.c"
[class]{}-[func]{countingSortNaive}
/* 计数排序 */
// 简单实现，无法用于排序对象
void countingSortNaive(int nums[], int size) {
// 1. 统计数组最大元素 m
int m = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > m) {
m = nums[i];
}
}
// 2. 统计各数字的出现次数
// counter[num] 代表 num 的出现次数
int *counter = malloc(sizeof(int) * size);
for (int i = 0; i < size; i++) {
counter[nums[i]]++;
}
// 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;
}
}
}
```
=== "C#"
@@ -517,7 +540,38 @@ $$
=== "C"
```c title="counting_sort.c"
[class]{}-[func]{countingSort}
/* 计数排序 */
// 完整实现，可排序对象，并且是稳定排序
void countingSort(int nums[], int size) {
// 1. 统计数组最大元素 m
int m = 0;
for (int i = 0; i < size; i++) {
if (nums[i] > m) {
m = nums[i];
}
}
// 2. 统计各数字的出现次数
// counter[num] 代表 num 的出现次数
int *counter = malloc(sizeof(int) * size);
for (int i = 0; i < size; i++) {
counter[nums[i]]++;
}
// 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
// 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
for (int i = 0; i < m; i++) {
counter[i + 1] += counter[i];
}
// 4. 倒序遍历 nums ，将各元素填入结果数组 res
// 初始化数组 res 用于记录结果
int *res = malloc(sizeof(int) * size);
for (int i = size - 1; i >= 0; i--) {
int num = nums[i];
res[counter[num] - 1] = num; // 将 num 放置到对应索引处
counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
}
// 使用结果数组 res 覆盖原数组 nums
memcpy(nums, res, size * sizeof(int));
}
```
=== "C#"
chapter_sorting/insertion_sort.md
+15 -1
View File
@@ -136,7 +136,21 @@ comments: true
=== "C"
```c title="insertion_sort.c"
[class]{}-[func]{insertionSort}
/* 插入排序 */
void insertionSort(int nums[], int size) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
for (int i = 1; i < size; i++) {
int base = nums[i], j = i - 1;
// 内循环：将 base 插入到左边的正确位置
while (j >= 0 && nums[j] > base) {
// 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j];
j--;
}
// 2. 将 base 赋值到正确位置
nums[j + 1] = base;
}
}
```
=== "C#"
chapter_sorting/merge_sort.md
+41
View File
@@ -335,7 +335,48 @@ comments: true
=== "C"
```c title="merge_sort.c"
/* 合并左子数组和右子数组 */
// 左子数组区间 [left, mid]
// 右子数组区间 [mid + 1, right]
void merge(int *nums, int left, int mid, int right) {
int index;
// 初始化辅助数组
int tmp[right + 1 - left];
for (index = left; index < right + 1; index++) {
tmp[index - left] = nums[index];
}
// 左子数组的起始索引和结束索引
int leftStart = left - left, leftEnd = mid - left;
// 右子数组的起始索引和结束索引
int rightStart = mid + 1 - left, rightEnd = right - left;
// i, j 分别指向左子数组、右子数组的首元素
int i = leftStart, j = rightStart;
// 通过覆盖原数组 nums 来合并左子数组和右子数组
for (int k = left; k <= right; k++) {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
if (i > leftEnd)
nums[k] = tmp[j++];
// 否则，若“右子数组已全部合并完”或“左子数组元素 <= 右子数组元素”，则选取左子数组元素，并且 i++
else if (j > rightEnd || tmp[i] <= tmp[j])
nums[k] = tmp[i++];
// 否则，若“左右子数组都未全部合并完”且“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
else
nums[k] = tmp[j++];
}
}
/* 归并排序 */
void mergeSort(int *nums, int left, int right) {
// 终止条件
if (left >= right)
return; // 当子数组长度为 1 时终止递归
// 划分阶段
int mid = (left + right) / 2; // 计算中点
mergeSort(nums, left, mid); // 递归左子数组
mergeSort(nums, mid + 1, right); // 递归右子数组
// 合并阶段
merge(nums, left, mid, right);
}
```
=== "C#"
chapter_sorting/quick_sort.md
+117 -5
View File
@@ -202,7 +202,28 @@ comments: true
=== "C"
```c title="quick_sort.c"
[class]{quickSort}-[func]{partition}
/* 快速排序类 */
// 快速排序类-哨兵划分
int partition(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;
}
```
=== "C#"
@@ -397,7 +418,41 @@ comments: true
=== "C"
```c title="quick_sort.c"
[class]{quickSort}-[func]{quickSort}
/* 快速排序类 */
// 快速排序类-哨兵划分
int partition(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 = partition(nums, left, right);
// 递归左子数组、右子数组
quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right);
}
```
=== "C#"
@@ -710,9 +765,50 @@ comments: true
=== "C"
```c title="quick_sort.c"
[class]{quickSortMedian}-[func]{medianThree}
/* 快速排序类（中位基准数优化） */
// 选取三个元素的中位数
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;
}
[class]{quickSortMedian}-[func]{partition}
/* 快速排序类（中位基准数优化） */
// 选取三个元素的中位数
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 partitionMedian(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; // 返回基准数的索引
}
```
=== "C#"
@@ -944,7 +1040,23 @@ comments: true
=== "C"
```c title="quick_sort.c"
[class]{quickSortTailCall}-[func]{quickSort}
/* 快速排序类（尾递归优化） */
// 快速排序（尾递归优化）
void quickSortTailCall(int nums[], int left, int right) {
// 子数组长度为 1 时终止
while (left < right) {
// 哨兵划分操作
int pivot = partition(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]
}
}
}
```
=== "C#"
chapter_sorting/radix_sort.md
+50 -3
View File
@@ -353,11 +353,58 @@ $$
=== "C"
```c title="radix_sort.c"
[class]{}-[func]{digit}
/* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
int digit(int num, int exp) {
// 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
return (num / exp) % 10;
}
[class]{}-[func]{countingSortDigit}
/* 计数排序（根据 nums 第 k 位排序） */
void countingSortDigit(int nums[], int size, int exp) {
// 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
int *counter = (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 的出现次数
counter[d]++;
}
// 求前缀和，将“出现个数”转换为“数组索引”
for (int i = 1; i < 10; i++) {
counter[i] += counter[i - 1];
}
// 倒序遍历，根据桶内统计结果，将各元素填入 res
int *res = (int *)malloc(sizeof(int) * size);
for (int i = size - 1; i >= 0; i--) {
int d = digit(nums[i], exp);
int j = counter[d] - 1; // 获取 d 在数组中的索引 j
res[j] = nums[i]; // 将当前元素填入索引 j
counter[d]--; // 将 d 的数量减 1
}
// 使用结果覆盖原数组 nums
for (int i = 0; i < size; i++) {
nums[i] = res[i];
}
}
[class]{}-[func]{radixSort}
/* 基数排序 */
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
// 即 exp = 10^(k-1)
countingSortDigit(nums, size, exp);
}
```
=== "C#"