algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-07-06 22:34:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2023-04-14 06:00:50 +08:00
parent 3c1eacca7f
commit 72a8318c75
4 changed files with 214 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
chapter_graph/graph_traversal.md
View File

@ -223,7 +223,36 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质
=== "C#"
```csharp title="graph_bfs.cs"
[class]{graph_bfs}-[func]{graphBFS}
/* 广度优先遍历 BFS */
// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet)
{
// 顶点遍历序列
List<Vertex> res = new List<Vertex>();
// 哈希表，用于记录已被访问过的顶点
HashSet<Vertex> visited = new HashSet<Vertex>() { startVet };
// 队列用于实现 BFS
Queue<Vertex> que = new Queue<Vertex>();
que.Enqueue(startVet);
// 以顶点 vet 为起点，循环直至访问完所有顶点
while (que.Count > 0)
{
Vertex vet = que.Dequeue(); // 队首顶点出队
res.Add(vet); // 记录访问顶点
foreach (Vertex adjVet in graph.adjList[vet])
{
if (visited.Contains(adjVet))
{
continue; // 跳过已被访问过的顶点
}
que.Enqueue(adjVet); // 只入队未访问的顶点
visited.Add(adjVet); // 标记该顶点已被访问
}
}
// 返回顶点遍历序列
return res;
}
```
=== "Swift"
@ -500,9 +529,34 @@ BFS 通常借助「队列」来实现。队列具有“先入先出”的性质
=== "C#"
```csharp title="graph_dfs.cs"
[class]{graph_dfs}-[func]{dfs}
/* 深度优先遍历 DFS 辅助函数 */
void dfs(GraphAdjList graph, HashSet<Vertex> visited, List<Vertex> res, Vertex vet)
{
res.Add(vet); // 记录访问顶点
visited.Add(vet); // 标记该顶点已被访问
// 遍历该顶点的所有邻接顶点
foreach (Vertex adjVet in graph.adjList[vet])
{
if (visited.Contains(adjVet))
{
continue; // 跳过已被访问过的顶点
}
// 递归访问邻接顶点
dfs(graph, visited, res, adjVet);
}
}
[class]{graph_dfs}-[func]{graphDFS}
/* 深度优先遍历 DFS */
// 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet)
{
// 顶点遍历序列
List<Vertex> res = new List<Vertex>();
// 哈希表，用于记录已被访问过的顶点
HashSet<Vertex> visited = new HashSet<Vertex>();
dfs(graph, visited, res, startVet);
return res;
}
```
=== "Swift"

35
chapter_sorting/bucket_sort.md
View File

@ -218,7 +218,40 @@ comments: true
=== "C#"
```csharp title="bucket_sort.cs"
[class]{bucket_sort}-[func]{bucketSort}
/* 桶排序 */
void bucketSort(float[] nums)
{
// 初始化 k = n/2 个桶，预期向每个桶分配 2 个元素
int k = nums.Length / 2;
List<List<float>> buckets = new List<List<float>>();
for (int i = 0; i < k; i++)
{
buckets.Add(new List<float>());
}
// 1. 将数组元素分配到各个桶中
foreach (float num in nums)
{
// 输入数据范围 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
int i = (int)num * k;
// 将 num 添加进桶 i
buckets[i].Add(num);
}
// 2. 对各个桶执行排序
foreach (List<float> bucket in buckets)
{
// 使用内置排序函数，也可以替换成其他排序算法
bucket.Sort();
}
// 3. 遍历桶合并结果
int j = 0;
foreach (List<float> bucket in buckets)
{
foreach (float num in bucket)
{
nums[j++] = num;
}
}
}
```
=== "Swift"

68
chapter_sorting/counting_sort.md
View File

@ -187,7 +187,33 @@ comments: true
=== "C#"
```csharp title="counting_sort.cs"
[class]{counting_sort}-[func]{countingSortNaive}
/* 计数排序 */
// 简单实现，无法用于排序对象
void countingSortNaive(int[] nums)
{
// 1. 统计数组最大元素 m
int m = 0;
foreach (int num in nums)
{
m = Math.Max(m, num);
}
// 2. 统计各数字的出现次数
// counter[num] 代表 num 的出现次数
int[] counter = new int[m + 1];
foreach (int num in 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;
}
}
}
```
=== "Swift"
@ -497,7 +523,45 @@ $$
=== "C#"
```csharp title="counting_sort.cs"
[class]{counting_sort}-[func]{countingSort}
/* 计数排序 */
// 完整实现，可排序对象，并且是稳定排序
void countingSort(int[] nums)
{
// 1. 统计数组最大元素 m
int m = 0;
foreach (int num in nums)
{
m = Math.Max(m, num);
}
// 2. 统计各数字的出现次数
// counter[num] 代表 num 的出现次数
int[] counter = new int[m + 1];
foreach (int num in 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.Length;
int[] res = new int[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
for (int i = 0; i < n; i++)
{
nums[i] = res[i];
}
}
```
=== "Swift"

60
chapter_sorting/radix_sort.md
View File

@ -363,11 +363,65 @@ $$
=== "C#"
```csharp title="radix_sort.cs"
[class]{radix_sort}-[func]{digit}
/* 获取元素 num 的第 k 位，其中 exp = 10^(k-1) */
int digit(int num, int exp)
{
// 传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
return (num / exp) % 10;
}
[class]{radix_sort}-[func]{countingSortDigit}
/* 计数排序（根据 nums 第 k 位排序） */
void countingSortDigit(int[] nums, int exp)
{
// 十进制的位范围为 0~9 ，因此需要长度为 10 的桶
int[] counter = new int[10];
int n = nums.Length;
// 统计 0~9 各数字的出现次数
for (int i = 0; i < n; i++)
{
int d = digit(nums[i], exp); // 获取 nums[i] 第 k 位，记为 d
counter[d]++; // 统计数字 d 的出现次数
}
// 求前缀和，将“出现个数”转换为“数组索引”
for (int i = 1; i < 10; i++)
{
counter[i] += counter[i - 1];
}
// 倒序遍历，根据桶内统计结果，将各元素填入 res
int[] res = new int[n];
for (int i = n - 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 < n; i++)
{
nums[i] = res[i];
}
}
[class]{radix_sort}-[func]{radixSort}
/* 基数排序 */
void radixSort(int[] nums)
{
// 获取数组的最大元素，用于判断最大位数
int m = int.MinValue;
foreach (int num in nums)
{
if (num > m) m = num;
}
// 按照从低位到高位的顺序遍历
for (int exp = 1; exp <= m; exp *= 10)
{
// 对数组元素的第 k 位执行计数排序
// k = 1 -> exp = 1
// k = 2 -> exp = 10
// 即 exp = 10^(k-1)
countingSortDigit(nums, exp);
}
}
```
=== "Swift"