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

build

Browse Source
This commit is contained in:
krahets
2023-04-14 04:01:38 +08:00
parent cf431646e9
commit 4d318e8e6b
26 changed files with 469 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files
chapter_sorting/bubble_sort.md
+9 -7
View File
@@ -67,7 +67,7 @@ comments: true
```cpp title="bubble_sort.cpp"
/* 冒泡排序 */
void bubbleSort(vector<int>& nums) {
void bubbleSort(vector<int> &nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for (int i = nums.size() - 1; i > 0; i--) {
// 内循环：冒泡操作
@@ -244,7 +244,7 @@ comments: true
=== "Java"
```java title="bubble_sort.java"
/* 冒泡排序（标志优化）*/
/* 冒泡排序（标志优化） */
void bubbleSortWithFlag(int[] nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for (int i = nums.length - 1; i > 0; i--) {
@@ -256,10 +256,11 @@ comments: true
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true; // 记录交换元素
flag = true; // 记录交换元素
}
}
if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
if (!flag)
break; // 此轮冒泡未交换任何元素，直接跳出
}
}
```
@@ -268,7 +269,7 @@ comments: true
```cpp title="bubble_sort.cpp"
/* 冒泡排序（标志优化）*/
void bubbleSortWithFlag(vector<int>& nums) {
void bubbleSortWithFlag(vector<int> &nums) {
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for (int i = nums.size() - 1; i > 0; i--) {
bool flag = false; // 初始化标志位
@@ -278,10 +279,11 @@ comments: true
// 交换 nums[j] 与 nums[j + 1]
// 这里使用了 std::swap() 函数
swap(nums[j], nums[j + 1]);
flag = true; // 记录交换元素
flag = true; // 记录交换元素
}
}
if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
if (!flag)
break; // 此轮冒泡未交换任何元素，直接跳出
}
}
```
chapter_sorting/bucket_sort.md
+25 -1
View File
@@ -56,7 +56,31 @@ comments: true
=== "C++"
```cpp title="bucket_sort.cpp"
[class]{}-[func]{bucketSort}
/* 桶排序 */
void bucketSort(vector<float> &nums) {
// 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
int k = nums.size() / 2;
vector<vector<float>> buckets(k);
// 1. 将数组元素分配到各个桶中
for (float num : nums) {
// 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
int i = num * k;
// 将 num 添加进桶 bucket_idx
buckets[i].push_back(num);
}
// 2. 对各个桶执行排序
for (vector<float> &bucket : buckets) {
// 使用内置排序函数，也可以替换成其他排序算法
sort(bucket.begin(), bucket.end());
}
// 3. 遍历桶合并结果
int i = 0;
for (vector<float> &bucket : buckets) {
for (float num : bucket) {
nums[i++] = num;
}
}
}
```
=== "Python"
chapter_sorting/counting_sort.md
+3 -3
View File
@@ -50,7 +50,7 @@ comments: true
```cpp title="counting_sort.cpp"
/* 计数排序 */
// 简单实现，无法用于排序对象
void countingSortNaive(vector<int>& nums) {
void countingSortNaive(vector<int> &nums) {
// 1. 统计数组最大元素 m
int m = 0;
for (int num : nums) {
@@ -311,7 +311,7 @@ $$
```cpp title="counting_sort.cpp"
/* 计数排序 */
// 完整实现，可排序对象，并且是稳定排序
void countingSort(vector<int>& nums) {
void countingSort(vector<int> &nums) {
// 1. 统计数组最大元素 m
int m = 0;
for (int num : nums) {
@@ -335,7 +335,7 @@ $$
for (int i = n - 1; i >= 0; i--) {
int num = nums[i];
res[counter[num] - 1] = num; // 将 num 放置到对应索引处
counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
counter[num]--; // 令前缀和自减 1 ，得到下次放置 num 的索引
}
// 使用结果数组 res 覆盖原数组 nums
nums = res;
chapter_sorting/insertion_sort.md
+5 -5
View File
@@ -34,10 +34,10 @@ comments: true
int base = nums[i], j = i - 1;
// 内循环：将 base 插入到左边的正确位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
}
}
```
@@ -46,16 +46,16 @@ comments: true
```cpp title="insertion_sort.cpp"
/* 插入排序 */
void insertionSort(vector<int>& nums) {
void insertionSort(vector<int> &nums) {
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
for (int i = 1; i < nums.size(); i++) {
int base = nums[i], j = i - 1;
// 内循环：将 base 插入到左边的正确位置
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
nums[j + 1] = base; // 2. 将 base 赋值到正确位置
}
}
```
chapter_sorting/merge_sort.md
+14 -12
View File
@@ -65,13 +65,13 @@ comments: true
// 右子数组区间 [mid + 1, right]
void merge(int[] nums, int left, int mid, int right) {
// 初始化辅助数组
int[] tmp = Arrays.copyOfRange(nums, left, right + 1);
// 左子数组的起始索引和结束索引
int[] tmp = Arrays.copyOfRange(nums, left, right + 1);
// 左子数组的起始索引和结束索引
int leftStart = left - left, leftEnd = mid - left;
// 右子数组的起始索引和结束索引
// 右子数组的起始索引和结束索引
int rightStart = mid + 1 - left, rightEnd = right - left;
// i, j 分别指向左子数组、右子数组的首元素
int i = leftStart, j = rightStart;
int i = leftStart, j = rightStart;
// 通过覆盖原数组 nums 来合并左子数组和右子数组
for (int k = left; k <= right; k++) {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
@@ -89,7 +89,8 @@ comments: true
/* 归并排序 */
void mergeSort(int[] nums, int left, int right) {
// 终止条件
if (left >= right) return; // 当子数组长度为 1 时终止递归
if (left >= right)
return; // 当子数组长度为 1 时终止递归
// 划分阶段
int mid = (left + right) / 2; // 计算中点
mergeSort(nums, left, mid); // 递归左子数组
@@ -105,15 +106,15 @@ comments: true
/* 合并左子数组和右子数组 */
// 左子数组区间 [left, mid]
// 右子数组区间 [mid + 1, right]
void merge(vector<int>& nums, int left, int mid, int right) {
void merge(vector<int> &nums, int left, int mid, int right) {
// 初始化辅助数组
vector<int> tmp(nums.begin() + left, nums.begin() + right + 1);
// 左子数组的起始索引和结束索引
vector<int> tmp(nums.begin() + left, nums.begin() + right + 1);
// 左子数组的起始索引和结束索引
int leftStart = left - left, leftEnd = mid - left;
// 右子数组的起始索引和结束索引
// 右子数组的起始索引和结束索引
int rightStart = mid + 1 - left, rightEnd = right - left;
// i, j 分别指向左子数组、右子数组的首元素
int i = leftStart, j = rightStart;
int i = leftStart, j = rightStart;
// 通过覆盖原数组 nums 来合并左子数组和右子数组
for (int k = left; k <= right; k++) {
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
@@ -129,9 +130,10 @@ comments: true
}
/* 归并排序 */
void mergeSort(vector<int>& nums, int left, int right) {
void mergeSort(vector<int> &nums, int left, int right) {
// 终止条件
if (left >= right) return; // 当子数组长度为 1 时终止递归
if (left >= right)
return; // 当子数组长度为 1 时终止递归
// 划分阶段
int mid = (left + right) / 2; // 计算中点
mergeSort(nums, left, mid); // 递归左子数组
chapter_sorting/quick_sort.md
+17 -17
View File
@@ -75,25 +75,25 @@ comments: true
```cpp title="quick_sort.cpp"
/* 元素交换 */
void swap(vector<int>& nums, int i, int j) {
void swap(vector<int> &nums, int i, int j) {
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 哨兵划分 */
int partition(vector<int>& nums, int left, int right) {
int partition(vector<int> &nums, int left, int right) {
// 以 nums[left] 作为基准数
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 从右向左找首个小于基准数的元素
j--; // 从右向左找首个小于基准数的元素
while (i < j && nums[i] <= nums[left])
i++; // 从左向右找首个大于基准数的元素
swap(nums, i, j); // 交换这两个元素
}
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
```
@@ -316,7 +316,7 @@ comments: true
```cpp title="quick_sort.cpp"
/* 快速排序 */
void quickSort(vector<int>& nums, int left, int right) {
void quickSort(vector<int> &nums, int left, int right) {
// 子数组长度为 1 时终止递归
if (left >= right)
return;
@@ -514,7 +514,7 @@ comments: true
```cpp title="quick_sort.cpp"
/* 选取三个元素的中位数 */
int medianThree(vector<int>& nums, int left, int mid, int right) {
int medianThree(vector<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]))
@@ -526,7 +526,7 @@ comments: true
}
/* 哨兵划分（三数取中值） */
int partition(vector<int>& nums, int left, int right) {
int partition(vector<int> &nums, int left, int right) {
// 选取三个候选元素的中位数
int med = medianThree(nums, left, (left + right) / 2, right);
// 将中位数交换至数组最左端
@@ -535,13 +535,13 @@ comments: true
int i = left, j = right;
while (i < j) {
while (i < j && nums[j] >= nums[left])
j--; // 从右向左找首个小于基准数的元素
j--; // 从右向左找首个小于基准数的元素
while (i < j && nums[i] <= nums[left])
i++; // 从左向右找首个大于基准数的元素
swap(nums, i, j); // 交换这两个元素
}
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
```
@@ -807,8 +807,8 @@ comments: true
int pivot = partition(nums, left, right);
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
@@ -821,18 +821,18 @@ comments: true
```cpp title="quick_sort.cpp"
/* 快速排序（尾递归优化） */
void quickSort(vector<int>& nums, int left, int right) {
void quickSort(vector<int> &nums, int left, int right) {
// 子数组长度为 1 时终止
while (left < right) {
// 哨兵划分操作
int pivot = partition(nums, left, right);
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot) {
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
} else {
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
}
}
}
chapter_sorting/radix_sort.md
+4 -3
View File
@@ -71,7 +71,8 @@ $$
// 获取数组的最大元素，用于判断最大位数
int m = Integer.MIN_VALUE;
for (int num : nums)
if (num > m) m = num;
if (num > m)
m = num;
// 按照从低位到高位的顺序遍历
for (int exp = 1; exp <= m; exp *= 10)
// 对数组元素的第 k 位执行计数排序
@@ -92,7 +93,7 @@ $$
}
/* 计数排序（根据 nums 第 k 位排序） */
void countingSortDigit(vector<int>& nums, int exp) {
void countingSortDigit(vector<int> &nums, int exp) {
// 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
vector<int> counter(10, 0);
int n = nums.size();
@@ -119,7 +120,7 @@ $$
}
/* 基数排序 */
void radixSort(vector<int>& nums) {
void radixSort(vector<int> &nums) {
// 获取数组的最大元素，用于判断最大位数
int m = *max_element(nums.begin(), nums.end());
// 按照从低位到高位的顺序遍历