algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-11-02 12:58:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix(csharp): Modify method name to PascalCase, simplify new expression (#840)

Browse Source 
* Modify method name to PascalCase(array and linked list)

* Modify method name to PascalCase(backtracking)

* Modify method name to PascalCase(computational complexity)

* Modify method name to PascalCase(divide and conquer)

* Modify method name to PascalCase(dynamic programming)

* Modify method name to PascalCase(graph)

* Modify method name to PascalCase(greedy)

* Modify method name to PascalCase(hashing)

* Modify method name to PascalCase(heap)

* Modify method name to PascalCase(searching)

* Modify method name to PascalCase(sorting)

* Modify method name to PascalCase(stack and queue)

* Modify method name to PascalCase(tree)

* local check
This commit is contained in:
hpstory
2023-10-08 01:33:46 +08:00
committed by GitHub
parent 6f7e768cb7
commit f62256bee1
129 changed files with 1186 additions and 1192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
codes/csharp/chapter_dynamic_programming/climbing_stairs_backtrack.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class climbing_stairs_backtrack {
/* 回溯 */
public void backtrack(List<int> choices, int state, int n, List<int> res) {
public void Backtrack(List<int> choices, int state, int n, List<int> res) {
// 当爬到第 n 阶时，方案数量加 1
if (state == n)
res[0]++;
@ -18,24 +18,24 @@ public class climbing_stairs_backtrack {
if (state + choice > n)
break;
// 尝试：做出选择，更新状态
backtrack(choices, state + choice, n, res);
Backtrack(choices, state + choice, n, res);
// 回退
}
}
/* 爬楼梯：回溯 */
public int climbingStairsBacktrack(int n) {
List<int> choices = new List<int> { 1, 2 }; // 可选择向上爬 1 或 2 阶
public int ClimbingStairsBacktrack(int n) {
List<int> choices = new() { 1, 2 }; // 可选择向上爬 1 或 2 阶
int state = 0; // 从第 0 阶开始爬
List<int> res = new List<int> { 0 }; // 使用 res[0] 记录方案数量
backtrack(choices, state, n, res);
List<int> res = new() { 0 }; // 使用 res[0] 记录方案数量
Backtrack(choices, state, n, res);
return res[0];
}
[Test]
public void Test() {
int n = 9;
int res = climbingStairsBacktrack(n);
int res = ClimbingStairsBacktrack(n);
Console.WriteLine($"爬 {n} 阶楼梯共有 {res} 种方案");
}
}

4
codes/csharp/chapter_dynamic_programming/climbing_stairs_constraint_dp.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class climbing_stairs_constraint_dp {
/* 带约束爬楼梯：动态规划 */
public int climbingStairsConstraintDP(int n) {
public int ClimbingStairsConstraintDP(int n) {
if (n == 1 || n == 2) {
return 1;
}
@ -30,7 +30,7 @@ public class climbing_stairs_constraint_dp {
[Test]
public void Test() {
int n = 9;
int res = climbingStairsConstraintDP(n);
int res = ClimbingStairsConstraintDP(n);
Console.WriteLine($"爬 {n} 阶楼梯共有 {res} 种方案");
}
}

10
codes/csharp/chapter_dynamic_programming/climbing_stairs_dfs.cs
View File

@ -8,24 +8,24 @@ namespace hello_algo.chapter_dynamic_programming;
public class climbing_stairs_dfs {
/* 搜索 */
public int dfs(int i) {
public int Dfs(int i) {
// 已知 dp[1] 和 dp[2] ，返回之
if (i == 1 || i == 2)
return i;
// dp[i] = dp[i-1] + dp[i-2]
int count = dfs(i - 1) + dfs(i - 2);
int count = Dfs(i - 1) + Dfs(i - 2);
return count;
}
/* 爬楼梯：搜索 */
public int climbingStairsDFS(int n) {
return dfs(n);
public int ClimbingStairsDFS(int n) {
return Dfs(n);
}
[Test]
public void Test() {
int n = 9;
int res = climbingStairsDFS(n);
int res = ClimbingStairsDFS(n);
Console.WriteLine($"爬 {n} 阶楼梯共有 {res} 种方案");
}
}

10
codes/csharp/chapter_dynamic_programming/climbing_stairs_dfs_mem.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class climbing_stairs_dfs_mem {
/* 记忆化搜索 */
public int dfs(int i, int[] mem) {
public int Dfs(int i, int[] mem) {
// 已知 dp[1] 和 dp[2] ，返回之
if (i == 1 || i == 2)
return i;
@ -16,24 +16,24 @@ public class climbing_stairs_dfs_mem {
if (mem[i] != -1)
return mem[i];
// dp[i] = dp[i-1] + dp[i-2]
int count = dfs(i - 1, mem) + dfs(i - 2, mem);
int count = Dfs(i - 1, mem) + Dfs(i - 2, mem);
// 记录 dp[i]
mem[i] = count;
return count;
}
/* 爬楼梯：记忆化搜索 */
public int climbingStairsDFSMem(int n) {
public int ClimbingStairsDFSMem(int n) {
// mem[i] 记录爬到第 i 阶的方案总数，-1 代表无记录
int[] mem = new int[n + 1];
Array.Fill(mem, -1);
return dfs(n, mem);
return Dfs(n, mem);
}
[Test]
public void Test() {
int n = 9;
int res = climbingStairsDFSMem(n);
int res = ClimbingStairsDFSMem(n);
Console.WriteLine($"爬 {n} 阶楼梯共有 {res} 种方案");
}
}

8
codes/csharp/chapter_dynamic_programming/climbing_stairs_dp.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class climbing_stairs_dp {
/* 爬楼梯：动态规划 */
public int climbingStairsDP(int n) {
public int ClimbingStairsDP(int n) {
if (n == 1 || n == 2)
return n;
// 初始化 dp 表，用于存储子问题的解
@ -24,7 +24,7 @@ public class climbing_stairs_dp {
}
/* 爬楼梯：空间优化后的动态规划 */
public int climbingStairsDPComp(int n) {
public int ClimbingStairsDPComp(int n) {
if (n == 1 || n == 2)
return n;
int a = 1, b = 2;
@ -40,10 +40,10 @@ public class climbing_stairs_dp {
public void Test() {
int n = 9;
int res = climbingStairsDP(n);
int res = ClimbingStairsDP(n);
Console.WriteLine($"爬 {n} 阶楼梯共有 {res} 种方案");
res = climbingStairsDPComp(n);
res = ClimbingStairsDPComp(n);
Console.WriteLine($"爬 {n} 阶楼梯共有 {res} 种方案");
}
}

8
codes/csharp/chapter_dynamic_programming/coin_change.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class coin_change {
/* 零钱兑换：动态规划 */
public int coinChangeDP(int[] coins, int amt) {
public int CoinChangeDP(int[] coins, int amt) {
int n = coins.Length;
int MAX = amt + 1;
// 初始化 dp 表
@ -33,7 +33,7 @@ public class coin_change {
}
/* 零钱兑换：空间优化后的动态规划 */
public int coinChangeDPComp(int[] coins, int amt) {
public int CoinChangeDPComp(int[] coins, int amt) {
int n = coins.Length;
int MAX = amt + 1;
// 初始化 dp 表
@ -61,11 +61,11 @@ public class coin_change {
int amt = 4;
// 动态规划
int res = coinChangeDP(coins, amt);
int res = CoinChangeDP(coins, amt);
Console.WriteLine("凑到目标金额所需的最少硬币数量为 " + res);
// 空间优化后的动态规划
res = coinChangeDPComp(coins, amt);
res = CoinChangeDPComp(coins, amt);
Console.WriteLine("凑到目标金额所需的最少硬币数量为 " + res);
}
}

8
codes/csharp/chapter_dynamic_programming/coin_change_ii.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class coin_change_ii {
/* 零钱兑换 II：动态规划 */
public int coinChangeIIDP(int[] coins, int amt) {
public int CoinChangeIIDP(int[] coins, int amt) {
int n = coins.Length;
// 初始化 dp 表
int[,] dp = new int[n + 1, amt + 1];
@ -32,7 +32,7 @@ public class coin_change_ii {
}
/* 零钱兑换 II：空间优化后的动态规划 */
public int coinChangeIIDPComp(int[] coins, int amt) {
public int CoinChangeIIDPComp(int[] coins, int amt) {
int n = coins.Length;
// 初始化 dp 表
int[] dp = new int[amt + 1];
@ -58,11 +58,11 @@ public class coin_change_ii {
int amt = 5;
// 动态规划
int res = coinChangeIIDP(coins, amt);
int res = CoinChangeIIDP(coins, amt);
Console.WriteLine("凑出目标金额的硬币组合数量为 " + res);
// 空间优化后的动态规划
res = coinChangeIIDPComp(coins, amt);
res = CoinChangeIIDPComp(coins, amt);
Console.WriteLine("凑出目标金额的硬币组合数量为 " + res);
}
}

32
codes/csharp/chapter_dynamic_programming/edit_distance.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class edit_distance {
/* 编辑距离：暴力搜索 */
public int editDistanceDFS(string s, string t, int i, int j) {
public int EditDistanceDFS(string s, string t, int i, int j) {
// 若 s 和 t 都为空，则返回 0
if (i == 0 && j == 0)
return 0;
@ -20,17 +20,17 @@ public class edit_distance {
return i;
// 若两字符相等，则直接跳过此两字符
if (s[i - 1] == t[j - 1])
return editDistanceDFS(s, t, i - 1, j - 1);
return EditDistanceDFS(s, t, i - 1, j - 1);
// 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
int insert = editDistanceDFS(s, t, i, j - 1);
int delete = editDistanceDFS(s, t, i - 1, j);
int replace = editDistanceDFS(s, t, i - 1, j - 1);
int insert = EditDistanceDFS(s, t, i, j - 1);
int delete = EditDistanceDFS(s, t, i - 1, j);
int replace = EditDistanceDFS(s, t, i - 1, j - 1);
// 返回最少编辑步数
return Math.Min(Math.Min(insert, delete), replace) + 1;
}
/* 编辑距离：记忆化搜索 */
public int editDistanceDFSMem(string s, string t, int[][] mem, int i, int j) {
public int EditDistanceDFSMem(string s, string t, int[][] mem, int i, int j) {
// 若 s 和 t 都为空，则返回 0
if (i == 0 && j == 0)
return 0;
@ -45,18 +45,18 @@ public class edit_distance {
return mem[i][j];
// 若两字符相等，则直接跳过此两字符
if (s[i - 1] == t[j - 1])
return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
return EditDistanceDFSMem(s, t, mem, i - 1, j - 1);
// 最少编辑步数 = 插入、删除、替换这三种操作的最少编辑步数 + 1
int insert = editDistanceDFSMem(s, t, mem, i, j - 1);
int delete = editDistanceDFSMem(s, t, mem, i - 1, j);
int replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
int insert = EditDistanceDFSMem(s, t, mem, i, j - 1);
int delete = EditDistanceDFSMem(s, t, mem, i - 1, j);
int replace = EditDistanceDFSMem(s, t, mem, i - 1, j - 1);
// 记录并返回最少编辑步数
mem[i][j] = Math.Min(Math.Min(insert, delete), replace) + 1;
return mem[i][j];
}
/* 编辑距离：动态规划 */
public int editDistanceDP(string s, string t) {
public int EditDistanceDP(string s, string t) {
int n = s.Length, m = t.Length;
int[,] dp = new int[n + 1, m + 1];
// 状态转移：首行首列
@ -82,7 +82,7 @@ public class edit_distance {
}
/* 编辑距离：空间优化后的动态规划 */
public int editDistanceDPComp(string s, string t) {
public int EditDistanceDPComp(string s, string t) {
int n = s.Length, m = t.Length;
int[] dp = new int[m + 1];
// 状态转移：首行
@ -117,7 +117,7 @@ public class edit_distance {
int n = s.Length, m = t.Length;
// 暴力搜索
int res = editDistanceDFS(s, t, n, m);
int res = EditDistanceDFS(s, t, n, m);
Console.WriteLine("将 " + s + " 更改为 " + t + " 最少需要编辑 " + res + " 步");
// 记忆化搜索
@ -127,15 +127,15 @@ public class edit_distance {
Array.Fill(mem[i], -1);
}
res = editDistanceDFSMem(s, t, mem, n, m);
res = EditDistanceDFSMem(s, t, mem, n, m);
Console.WriteLine("将 " + s + " 更改为 " + t + " 最少需要编辑 " + res + " 步");
// 动态规划
res = editDistanceDP(s, t);
res = EditDistanceDP(s, t);
Console.WriteLine("将 " + s + " 更改为 " + t + " 最少需要编辑 " + res + " 步");
// 空间优化后的动态规划
res = editDistanceDPComp(s, t);
res = EditDistanceDPComp(s, t);
Console.WriteLine("将 " + s + " 更改为 " + t + " 最少需要编辑 " + res + " 步");
}
}

28
codes/csharp/chapter_dynamic_programming/knapsack.cs
View File

@ -8,24 +8,24 @@ namespace hello_algo.chapter_dynamic_programming;
public class knapsack {
/* 0-1 背包：暴力搜索 */
public int knapsackDFS(int[] weight, int[] val, int i, int c) {
public int KnapsackDFS(int[] weight, int[] val, int i, int c) {
// 若已选完所有物品或背包无容量，则返回价值 0
if (i == 0 || c == 0) {
return 0;
}
// 若超过背包容量，则只能不放入背包
if (weight[i - 1] > c) {
return knapsackDFS(weight, val, i - 1, c);
return KnapsackDFS(weight, val, i - 1, c);
}
// 计算不放入和放入物品 i 的最大价值
int no = knapsackDFS(weight, val, i - 1, c);
int yes = knapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];
int no = KnapsackDFS(weight, val, i - 1, c);
int yes = KnapsackDFS(weight, val, i - 1, c - weight[i - 1]) + val[i - 1];
// 返回两种方案中价值更大的那一个
return Math.Max(no, yes);
}
/* 0-1 背包：记忆化搜索 */
public int knapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {
public int KnapsackDFSMem(int[] weight, int[] val, int[][] mem, int i, int c) {
// 若已选完所有物品或背包无容量，则返回价值 0
if (i == 0 || c == 0) {
return 0;
@ -36,18 +36,18 @@ public class knapsack {
}
// 若超过背包容量，则只能不放入背包
if (weight[i - 1] > c) {
return knapsackDFSMem(weight, val, mem, i - 1, c);
return KnapsackDFSMem(weight, val, mem, i - 1, c);
}
// 计算不放入和放入物品 i 的最大价值
int no = knapsackDFSMem(weight, val, mem, i - 1, c);
int yes = knapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];
int no = KnapsackDFSMem(weight, val, mem, i - 1, c);
int yes = KnapsackDFSMem(weight, val, mem, i - 1, c - weight[i - 1]) + val[i - 1];
// 记录并返回两种方案中价值更大的那一个
mem[i][c] = Math.Max(no, yes);
return mem[i][c];
}
/* 0-1 背包：动态规划 */
public int knapsackDP(int[] weight, int[] val, int cap) {
public int KnapsackDP(int[] weight, int[] val, int cap) {
int n = weight.Length;
// 初始化 dp 表
int[,] dp = new int[n + 1, cap + 1];
@ -67,7 +67,7 @@ public class knapsack {
}
/* 0-1 背包：空间优化后的动态规划 */
public int knapsackDPComp(int[] weight, int[] val, int cap) {
public int KnapsackDPComp(int[] weight, int[] val, int cap) {
int n = weight.Length;
// 初始化 dp 表
int[] dp = new int[cap + 1];
@ -95,7 +95,7 @@ public class knapsack {
int n = weight.Length;
// 暴力搜索
int res = knapsackDFS(weight, val, n, cap);
int res = KnapsackDFS(weight, val, n, cap);
Console.WriteLine("不超过背包容量的最大物品价值为 " + res);
// 记忆化搜索
@ -104,15 +104,15 @@ public class knapsack {
mem[i] = new int[cap + 1];
Array.Fill(mem[i], -1);
}
res = knapsackDFSMem(weight, val, mem, n, cap);
res = KnapsackDFSMem(weight, val, mem, n, cap);
Console.WriteLine("不超过背包容量的最大物品价值为 " + res);
// 动态规划
res = knapsackDP(weight, val, cap);
res = KnapsackDP(weight, val, cap);
Console.WriteLine("不超过背包容量的最大物品价值为 " + res);
// 空间优化后的动态规划
res = knapsackDPComp(weight, val, cap);
res = KnapsackDPComp(weight, val, cap);
Console.WriteLine("不超过背包容量的最大物品价值为 " + res);
}
}

8
codes/csharp/chapter_dynamic_programming/min_cost_climbing_stairs_dp.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class min_cost_climbing_stairs_dp {
/* 爬楼梯最小代价：动态规划 */
public int minCostClimbingStairsDP(int[] cost) {
public int MinCostClimbingStairsDP(int[] cost) {
int n = cost.Length - 1;
if (n == 1 || n == 2)
return cost[n];
@ -25,7 +25,7 @@ public class min_cost_climbing_stairs_dp {
}
/* 爬楼梯最小代价：空间优化后的动态规划 */
public int minCostClimbingStairsDPComp(int[] cost) {
public int MinCostClimbingStairsDPComp(int[] cost) {
int n = cost.Length - 1;
if (n == 1 || n == 2)
return cost[n];
@ -44,10 +44,10 @@ public class min_cost_climbing_stairs_dp {
Console.WriteLine("输入楼梯的代价列表为");
PrintUtil.PrintList(cost);
int res = minCostClimbingStairsDP(cost);
int res = MinCostClimbingStairsDP(cost);
Console.WriteLine($"爬完楼梯的最低代价为 {res}");
res = minCostClimbingStairsDPComp(cost);
res = MinCostClimbingStairsDPComp(cost);
Console.WriteLine($"爬完楼梯的最低代价为 {res}");
}
}

24
codes/csharp/chapter_dynamic_programming/min_path_sum.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class min_path_sum {
/* 最小路径和：暴力搜索 */
public int minPathSumDFS(int[][] grid, int i, int j) {
public int MinPathSumDFS(int[][] grid, int i, int j) {
// 若为左上角单元格，则终止搜索
if (i == 0 && j == 0) {
return grid[0][0];
@ -18,14 +18,14 @@ public class min_path_sum {
return int.MaxValue;
}
// 计算从左上角到 (i-1, j) 和 (i, j-1) 的最小路径代价
int left = minPathSumDFS(grid, i - 1, j);
int up = minPathSumDFS(grid, i, j - 1);
int left = MinPathSumDFS(grid, i - 1, j);
int up = MinPathSumDFS(grid, i, j - 1);
// 返回从左上角到 (i, j) 的最小路径代价
return Math.Min(left, up) + grid[i][j];
}
/* 最小路径和：记忆化搜索 */
public int minPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {
public int MinPathSumDFSMem(int[][] grid, int[][] mem, int i, int j) {
// 若为左上角单元格，则终止搜索
if (i == 0 && j == 0) {
return grid[0][0];
@ -39,15 +39,15 @@ public class min_path_sum {
return mem[i][j];
}
// 左边和上边单元格的最小路径代价
int left = minPathSumDFSMem(grid, mem, i - 1, j);
int up = minPathSumDFSMem(grid, mem, i, j - 1);
int left = MinPathSumDFSMem(grid, mem, i - 1, j);
int up = MinPathSumDFSMem(grid, mem, i, j - 1);
// 记录并返回左上角到 (i, j) 的最小路径代价
mem[i][j] = Math.Min(left, up) + grid[i][j];
return mem[i][j];
}
/* 最小路径和：动态规划 */
public int minPathSumDP(int[][] grid) {
public int MinPathSumDP(int[][] grid) {
int n = grid.Length, m = grid[0].Length;
// 初始化 dp 表
int[,] dp = new int[n, m];
@ -70,7 +70,7 @@ public class min_path_sum {
}
/* 最小路径和：空间优化后的动态规划 */
public int minPathSumDPComp(int[][] grid) {
public int MinPathSumDPComp(int[][] grid) {
int n = grid.Length, m = grid[0].Length;
// 初始化 dp 表
int[] dp = new int[m];
@ -104,7 +104,7 @@ public class min_path_sum {
int n = grid.Length, m = grid[0].Length;
// 暴力搜索
int res = minPathSumDFS(grid, n - 1, m - 1);
int res = MinPathSumDFS(grid, n - 1, m - 1);
Console.WriteLine("从左上角到右下角的做小路径和为 " + res);
// 记忆化搜索
@ -113,15 +113,15 @@ public class min_path_sum {
mem[i] = new int[m];
Array.Fill(mem[i], -1);
}
res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
res = MinPathSumDFSMem(grid, mem, n - 1, m - 1);
Console.WriteLine("从左上角到右下角的做小路径和为 " + res);
// 动态规划
res = minPathSumDP(grid);
res = MinPathSumDP(grid);
Console.WriteLine("从左上角到右下角的做小路径和为 " + res);
// 空间优化后的动态规划
res = minPathSumDPComp(grid);
res = MinPathSumDPComp(grid);
Console.WriteLine("从左上角到右下角的做小路径和为 " + res);
}
}

8
codes/csharp/chapter_dynamic_programming/unbounded_knapsack.cs
View File

@ -8,7 +8,7 @@ namespace hello_algo.chapter_dynamic_programming;
public class unbounded_knapsack {
/* 完全背包：动态规划 */
public int unboundedKnapsackDP(int[] wgt, int[] val, int cap) {
public int UnboundedKnapsackDP(int[] wgt, int[] val, int cap) {
int n = wgt.Length;
// 初始化 dp 表
int[,] dp = new int[n + 1, cap + 1];
@ -28,7 +28,7 @@ public class unbounded_knapsack {
}
/* 完全背包：空间优化后的动态规划 */
public int unboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
public int UnboundedKnapsackDPComp(int[] wgt, int[] val, int cap) {
int n = wgt.Length;
// 初始化 dp 表
int[] dp = new int[cap + 1];
@ -54,11 +54,11 @@ public class unbounded_knapsack {
int cap = 4;
// 动态规划
int res = unboundedKnapsackDP(wgt, val, cap);
int res = UnboundedKnapsackDP(wgt, val, cap);
Console.WriteLine("不超过背包容量的最大物品价值为 " + res);
// 空间优化后的动态规划
res = unboundedKnapsackDPComp(wgt, val, cap);
res = UnboundedKnapsackDPComp(wgt, val, cap);
Console.WriteLine("不超过背包容量的最大物品价值为 " + res);
}
}