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

* 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

codes/csharp/chapter_hashing/array_hash_map.cs

@@ -18,7 +18,7 @@ class Pair {
 
 /* 基于数组简易实现的哈希表 */
 class ArrayHashMap {
-    private List<Pair?> buckets;
+    private readonly List<Pair?> buckets;
     public ArrayHashMap() {
         // 初始化数组，包含 100 个桶
         buckets = new();
@@ -28,35 +28,35 @@ class ArrayHashMap {
     }
 
     /* 哈希函数 */
-    private int hashFunc(int key) {
+    private int HashFunc(int key) {
         int index = key % 100;
         return index;
     }
 
     /* 查询操作 */
-    public string? get(int key) {
-        int index = hashFunc(key);
+    public string? Get(int key) {
+        int index = HashFunc(key);
         Pair? pair = buckets[index];
         if (pair == null) return null;
         return pair.val;
     }
 
     /* 添加操作 */
-    public void put(int key, string val) {
-        Pair pair = new Pair(key, val);
-        int index = hashFunc(key);
+    public void Put(int key, string val) {
+        Pair pair = new(key, val);
+        int index = HashFunc(key);
         buckets[index] = pair;
     }
 
     /* 删除操作 */
-    public void remove(int key) {
-        int index = hashFunc(key);
+    public void Remove(int key) {
+        int index = HashFunc(key);
         // 置为 null ，代表删除
         buckets[index] = null;
     }
 
     /* 获取所有键值对 */
-    public List<Pair> pairSet() {
+    public List<Pair> PairSet() {
         List<Pair> pairSet = new();
         foreach (Pair? pair in buckets) {
             if (pair != null)
@@ -66,7 +66,7 @@ class ArrayHashMap {
     }
 
     /* 获取所有键 */
-    public List<int> keySet() {
+    public List<int> KeySet() {
         List<int> keySet = new();
         foreach (Pair? pair in buckets) {
             if (pair != null)
@@ -76,7 +76,7 @@ class ArrayHashMap {
     }
 
     /* 获取所有值 */
-    public List<string> valueSet() {
+    public List<string> ValueSet() {
         List<string> valueSet = new();
         foreach (Pair? pair in buckets) {
             if (pair != null)
@@ -86,8 +86,8 @@ class ArrayHashMap {
     }
 
     /* 打印哈希表 */
-    public void print() {
-        foreach (Pair kv in pairSet()) {
+    public void Print() {
+        foreach (Pair kv in PairSet()) {
             Console.WriteLine(kv.key + " -> " + kv.val);
         }
     }
@@ -98,40 +98,40 @@ public class array_hash_map {
     [Test]
     public void Test() {
         /* 初始化哈希表 */
-        ArrayHashMap map = new ArrayHashMap();
+        ArrayHashMap map = new();
 
         /* 添加操作 */
         // 在哈希表中添加键值对 (key, value)
-        map.put(12836, "小哈");
-        map.put(15937, "小啰");
-        map.put(16750, "小算");
-        map.put(13276, "小法");
-        map.put(10583, "小鸭");
+        map.Put(12836, "小哈");
+        map.Put(15937, "小啰");
+        map.Put(16750, "小算");
+        map.Put(13276, "小法");
+        map.Put(10583, "小鸭");
         Console.WriteLine("\n添加完成后，哈希表为\nKey -> Value");
-        map.print();
+        map.Print();
 
         /* 查询操作 */
         // 向哈希表输入键 key ，得到值 value
-        string? name = map.get(15937);
+        string? name = map.Get(15937);
         Console.WriteLine("\n输入学号 15937 ，查询到姓名 " + name);
 
         /* 删除操作 */
         // 在哈希表中删除键值对 (key, value)
-        map.remove(10583);
+        map.Remove(10583);
         Console.WriteLine("\n删除 10583 后，哈希表为\nKey -> Value");
-        map.print();
+        map.Print();
 
         /* 遍历哈希表 */
         Console.WriteLine("\n遍历键值对 Key->Value");
-        foreach (Pair kv in map.pairSet()) {
+        foreach (Pair kv in map.PairSet()) {
             Console.WriteLine(kv.key + " -> " + kv.val);
         }
         Console.WriteLine("\n单独遍历键 Key");
-        foreach (int key in map.keySet()) {
+        foreach (int key in map.KeySet()) {
             Console.WriteLine(key);
         }
         Console.WriteLine("\n单独遍历值 Value");
-        foreach (string val in map.valueSet()) {
+        foreach (string val in map.ValueSet()) {
             Console.WriteLine(val);
         }
     }

codes/csharp/chapter_hashing/built_in_hash.cs

@@ -29,7 +29,7 @@ public class built_in_hash {
         int hashTup = arr.GetHashCode();
         Console.WriteLine("数组 [" + string.Join(", ", arr) + "] 的哈希值为 " + hashTup);
 
-        ListNode obj = new ListNode(0);
+        ListNode obj = new(0);
         int hashObj = obj.GetHashCode();
         Console.WriteLine("节点对象 " + obj + " 的哈希值为 " + hashObj);
     }

codes/csharp/chapter_hashing/hash_map.cs

@@ -11,15 +11,15 @@ public class hash_map {
     [Test]
     public void Test() {
         /* 初始化哈希表 */
-        Dictionary<int, string> map = new();
-
-        /* 添加操作 */
-        // 在哈希表中添加键值对 (key, value)
-        map.Add(12836, "小哈");
-        map.Add(15937, "小啰");
-        map.Add(16750, "小算");
-        map.Add(13276, "小法");
-        map.Add(10583, "小鸭");
+        Dictionary<int, string> map = new() {
+            /* 添加操作 */
+            // 在哈希表中添加键值对 (key, value)
+            { 12836, "小哈" },
+            { 15937, "小啰" },
+            { 16750, "小算" },
+            { 13276, "小法" },
+            { 10583, "小鸭" }
+        };
         Console.WriteLine("\n添加完成后，哈希表为\nKey -> Value");
         PrintUtil.PrintHashMap(map);
 

codes/csharp/chapter_hashing/hash_map_chaining.cs

@@ -10,8 +10,8 @@ namespace hello_algo.chapter_hashing;
 class HashMapChaining {
     int size; // 键值对数量
     int capacity; // 哈希表容量
-    double loadThres; // 触发扩容的负载因子阈值
-    int extendRatio; // 扩容倍数
+    readonly double loadThres; // 触发扩容的负载因子阈值
+    readonly int extendRatio; // 扩容倍数
     List<List<Pair>> buckets; // 桶数组
 
     /* 构造方法 */
@@ -27,18 +27,18 @@ class HashMapChaining {
     }
 
     /* 哈希函数 */
-    private int hashFunc(int key) {
+    private int HashFunc(int key) {
         return key % capacity;
     }
 
     /* 负载因子 */
-    private double loadFactor() {
+    private double LoadFactor() {
         return (double)size / capacity;
     }
 
     /* 查询操作 */
-    public string? get(int key) {
-        int index = hashFunc(key);
+    public string? Get(int key) {
+        int index = HashFunc(key);
         // 遍历桶，若找到 key 则返回对应 val
         foreach (Pair pair in buckets[index]) {
             if (pair.key == key) {
@@ -50,12 +50,12 @@ class HashMapChaining {
     }
 
     /* 添加操作 */
-    public void put(int key, string val) {
+    public void Put(int key, string val) {
         // 当负载因子超过阈值时，执行扩容
-        if (loadFactor() > loadThres) {
-            extend();
+        if (LoadFactor() > loadThres) {
+            Extend();
         }
-        int index = hashFunc(key);
+        int index = HashFunc(key);
         // 遍历桶，若遇到指定 key ，则更新对应 val 并返回
         foreach (Pair pair in buckets[index]) {
             if (pair.key == key) {
@@ -69,8 +69,8 @@ class HashMapChaining {
     }
 
     /* 删除操作 */
-    public void remove(int key) {
-        int index = hashFunc(key);
+    public void Remove(int key) {
+        int index = HashFunc(key);
         // 遍历桶，从中删除键值对
         foreach (Pair pair in buckets[index].ToList()) {
             if (pair.key == key) {
@@ -82,7 +82,7 @@ class HashMapChaining {
     }
 
     /* 扩容哈希表 */
-    private void extend() {
+    private void Extend() {
         // 暂存原哈希表
         List<List<Pair>> bucketsTmp = buckets;
         // 初始化扩容后的新哈希表
@@ -95,15 +95,15 @@ class HashMapChaining {
         // 将键值对从原哈希表搬运至新哈希表
         foreach (List<Pair> bucket in bucketsTmp) {
             foreach (Pair pair in bucket) {
-                put(pair.key, pair.val);
+                Put(pair.key, pair.val);
             }
         }
     }
 
     /* 打印哈希表 */
-    public void print() {
+    public void Print() {
         foreach (List<Pair> bucket in buckets) {
-            List<string> res = new List<string>();
+            List<string> res = new();
             foreach (Pair pair in bucket) {
                 res.Add(pair.key + " -> " + pair.val);
             }
@@ -118,27 +118,27 @@ public class hash_map_chaining {
     [Test]
     public void Test() {
         /* 初始化哈希表 */
-        HashMapChaining map = new HashMapChaining();
+        HashMapChaining map = new();
 
         /* 添加操作 */
         // 在哈希表中添加键值对 (key, value)
-        map.put(12836, "小哈");
-        map.put(15937, "小啰");
-        map.put(16750, "小算");
-        map.put(13276, "小法");
-        map.put(10583, "小鸭");
+        map.Put(12836, "小哈");
+        map.Put(15937, "小啰");
+        map.Put(16750, "小算");
+        map.Put(13276, "小法");
+        map.Put(10583, "小鸭");
         Console.WriteLine("\n添加完成后，哈希表为\nKey -> Value");
-        map.print();
+        map.Print();
 
         /* 查询操作 */
         // 向哈希表输入键 key ，得到值 value
-        string name = map.get(13276);
+        string? name = map.Get(13276);
         Console.WriteLine("\n输入学号 13276 ，查询到姓名 " + name);
 
         /* 删除操作 */
         // 在哈希表中删除键值对 (key, value)
-        map.remove(12836);
+        map.Remove(12836);
         Console.WriteLine("\n删除 12836 后，哈希表为\nKey -> Value");
-        map.print();
+        map.Print();
     }
 }

codes/csharp/chapter_hashing/hash_map_open_addressing.cs

@@ -10,10 +10,10 @@ namespace hello_algo.chapter_hashing;
 class HashMapOpenAddressing {
     private int size; // 键值对数量
     private int capacity = 4; // 哈希表容量
-    private double loadThres = 2.0 / 3.0; // 触发扩容的负载因子阈值
-    private int extendRatio = 2; // 扩容倍数
+    private readonly double loadThres = 2.0 / 3.0; // 触发扩容的负载因子阈值
+    private readonly int extendRatio = 2; // 扩容倍数
     private Pair[] buckets; // 桶数组
-    private Pair TOMBSTONE = new Pair(-1, "-1"); // 删除标记
+    private readonly Pair TOMBSTONE = new(-1, "-1"); // 删除标记
 
     /* 构造方法 */
     public HashMapOpenAddressing() {
@@ -22,18 +22,18 @@ class HashMapOpenAddressing {
     }
 
     /* 哈希函数 */
-    private int hashFunc(int key) {
+    private int HashFunc(int key) {
         return key % capacity;
     }
 
     /* 负载因子 */
-    private double loadFactor() {
+    private double LoadFactor() {
         return (double)size / capacity;
     }
 
     /* 搜索 key 对应的桶索引 */
-    private int findBucket(int key) {
-        int index = hashFunc(key);
+    private int FindBucket(int key) {
+        int index = HashFunc(key);
         int firstTombstone = -1;
         // 线性探测，当遇到空桶时跳出
         while (buckets[index] != null) {
@@ -59,9 +59,9 @@ class HashMapOpenAddressing {
     }
 
     /* 查询操作 */
-    public string? get(int key) {
+    public string? Get(int key) {
         // 搜索 key 对应的桶索引
-        int index = findBucket(key);
+        int index = FindBucket(key);
         // 若找到键值对，则返回对应 val
         if (buckets[index] != null && buckets[index] != TOMBSTONE) {
             return buckets[index].val;
@@ -71,13 +71,13 @@ class HashMapOpenAddressing {
     }
 
     /* 添加操作 */
-    public void put(int key, string val) {
+    public void Put(int key, string val) {
         // 当负载因子超过阈值时，执行扩容
-        if (loadFactor() > loadThres) {
-            extend();
+        if (LoadFactor() > loadThres) {
+            Extend();
         }
         // 搜索 key 对应的桶索引
-        int index = findBucket(key);
+        int index = FindBucket(key);
         // 若找到键值对，则覆盖 val 并返回
         if (buckets[index] != null && buckets[index] != TOMBSTONE) {
             buckets[index].val = val;
@@ -89,9 +89,9 @@ class HashMapOpenAddressing {
     }
 
     /* 删除操作 */
-    public void remove(int key) {
+    public void Remove(int key) {
         // 搜索 key 对应的桶索引
-        int index = findBucket(key);
+        int index = FindBucket(key);
         // 若找到键值对，则用删除标记覆盖它
         if (buckets[index] != null && buckets[index] != TOMBSTONE) {
             buckets[index] = TOMBSTONE;
@@ -100,7 +100,7 @@ class HashMapOpenAddressing {
     }
 
     /* 扩容哈希表 */
-    private void extend() {
+    private void Extend() {
         // 暂存原哈希表
         Pair[] bucketsTmp = buckets;
         // 初始化扩容后的新哈希表
@@ -110,13 +110,13 @@ class HashMapOpenAddressing {
         // 将键值对从原哈希表搬运至新哈希表
         foreach (Pair pair in bucketsTmp) {
             if (pair != null && pair != TOMBSTONE) {
-                put(pair.key, pair.val);
+                Put(pair.key, pair.val);
             }
         }
     }
 
     /* 打印哈希表 */
-    public void print() {
+    public void Print() {
         foreach (Pair pair in buckets) {
             if (pair == null) {
                 Console.WriteLine("null");
@@ -133,27 +133,27 @@ public class hash_map_open_addressing {
     [Test]
     public void Test() {
         /* 初始化哈希表 */
-        HashMapOpenAddressing map = new HashMapOpenAddressing();
+        HashMapOpenAddressing map = new();
 
         /* 添加操作 */
         // 在哈希表中添加键值对 (key, value)
-        map.put(12836, "小哈");
-        map.put(15937, "小啰");
-        map.put(16750, "小算");
-        map.put(13276, "小法");
-        map.put(10583, "小鸭");
+        map.Put(12836, "小哈");
+        map.Put(15937, "小啰");
+        map.Put(16750, "小算");
+        map.Put(13276, "小法");
+        map.Put(10583, "小鸭");
         Console.WriteLine("\n添加完成后，哈希表为\nKey -> Value");
-        map.print();
+        map.Print();
 
         /* 查询操作 */
         // 向哈希表输入键 key ，得到值 value
-        string name = map.get(13276);
+        string? name = map.Get(13276);
         Console.WriteLine("\n输入学号 13276 ，查询到姓名 " + name);
 
         /* 删除操作 */
         // 在哈希表中删除键值对 (key, value)
-        map.remove(16750);
+        map.Remove(16750);
         Console.WriteLine("\n删除 16750 后，哈希表为\nKey -> Value");
-        map.print();
+        map.Print();
     }
 }

codes/csharp/chapter_hashing/simple_hash.cs

@@ -8,7 +8,7 @@ namespace hello_algo.chapter_hashing;
 
 public class simple_hash {
     /* 加法哈希 */
-    public static int addHash(string key) {
+    public static int AddHash(string key) {
         long hash = 0;
         const int MODULUS = 1000000007;
         foreach (char c in key) {
@@ -18,7 +18,7 @@ public class simple_hash {
     }
 
     /* 乘法哈希 */
-    public static int mulHash(string key) {
+    public static int MulHash(string key) {
         long hash = 0;
         const int MODULUS = 1000000007;
         foreach (char c in key) {
@@ -28,7 +28,7 @@ public class simple_hash {
     }
 
     /* 异或哈希 */
-    public static int xorHash(string key) {
+    public static int XorHash(string key) {
         int hash = 0;
         const int MODULUS = 1000000007;
         foreach (char c in key) {
@@ -38,7 +38,7 @@ public class simple_hash {
     }
 
     /* 旋转哈希 */
-    public static int rotHash(string key) {
+    public static int RotHash(string key) {
         long hash = 0;
         const int MODULUS = 1000000007;
         foreach (char c in key) {
@@ -51,16 +51,16 @@ public class simple_hash {
     public void Test() {
         string key = "Hello 算法";
 
-        int hash = addHash(key);
+        int hash = AddHash(key);
         Console.WriteLine("加法哈希值为 " + hash);
 
-        hash = mulHash(key);
+        hash = MulHash(key);
         Console.WriteLine("乘法哈希值为 " + hash);
 
-        hash = xorHash(key);
+        hash = XorHash(key);
         Console.WriteLine("异或哈希值为 " + hash);
 
-        hash = rotHash(key);
+        hash = RotHash(key);
         Console.WriteLine("旋转哈希值为 " + hash);
     }
 }