Merge branch 'krahets:master' into master

.github/pull_request_template.md

@@ -1,6 +1,4 @@
-> Tip: If this PR is not related to the coding or code translation, please ignore the checklist.
-
-### Checklist
+If this PR is related to coding or code translation, please fill out the checklist.
 
 - [ ] I've tested the code and ensured the outputs are the same as the outputs of reference codes.
 - [ ] I've checked the codes (formatting, comments, indentation, file header, etc) carefully.

.gitignore

@@ -13,3 +13,6 @@ docs/overrides/
 
 # python files
 __pycache__
+
+# iml
+hello-algo.iml

README.md

@@ -36,7 +36,7 @@
 - 开源免费，所有同学都可在网上获取本书；
 - 新手友好，适合算法初学者自主学习入门；
 - 动画讲解，尽可能地保证平滑的学习曲线；
-- 代码导向，提供精简、可运行的算法代码；
+- 代码导向，提供可一键运行的算法源代码；
 - 讨论学习，提问一般能在三日内得到回复；
 
 如果感觉本书对你有所帮助，请点个 Star :star: 支持一下，谢谢！

codes/c/chapter_sorting/bubble_sort.c

@@ -0,0 +1,72 @@
+/**
+ * File: bubble_sort.c
+ * Created Time: 2022-12-26
+ * Author: Listening (https://github.com/L-Super)
+ */
+
+#include "../include/include.h"
+
+/* 冒泡排序 */
+void bubble_sort(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;
+            }
+        }
+    }
+}
+
+/* 冒泡排序（标志优化）*/
+void bubble_sort_with_flag(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;
+    }
+}
+
+
+/* Driver Code */
+int main()
+{
+    int nums[6] = {4, 1, 3, 1, 5, 2};
+    printf("冒泡排序后:\n");
+    bubble_sort(nums, 6);
+    for (int i = 0; i < 6; i++)
+    {
+        printf("%d ", nums[i]);
+    }
+
+    printf("优化版冒泡排序后:\n");
+    bubble_sort_with_flag(nums, 6);
+    for (int i = 0; i < 6; i++)
+    {
+        printf("%d ", nums[i]);
+    }
+    printf("\n");
+
+    return 0;
+}

codes/c/include/include.h

@@ -0,0 +1,2 @@
+#include <stdio.h>
+#include <stdbool.h>

codes/cpp/chapter_sorting/bubble_sort.cpp

@@ -14,9 +14,8 @@ void bubbleSort(vector<int>& nums) {
         for (int j = 0; j < i; j++) {
             if (nums[j] > nums[j + 1]) {
                 // 交换 nums[j] 与 nums[j + 1]
-                int tmp = nums[j];
-                nums[j] = nums[j + 1];
-                nums[j + 1] = tmp;
+                // 这里使用了 std::swap() 函数
+                swap(nums[j], nums[j + 1]);
             }
         }
     }
@@ -31,9 +30,8 @@ void bubbleSortWithFlag(vector<int>& nums) {
         for (int j = 0; j < i; j++) {
             if (nums[j] > nums[j + 1]) {
                 // 交换 nums[j] 与 nums[j + 1]
-                int tmp = nums[j];
-                nums[j] = nums[j + 1];
-                nums[j + 1] = tmp;
+                // 这里使用了 std::swap() 函数
+                swap(nums[j], nums[j + 1]);
                 flag = true;  // 记录交换元素
             }
         }

codes/cpp/chapter_sorting/merge_sort.cpp

@@ -22,13 +22,13 @@ void merge(vector<int>& nums, int left, int mid, int right) {
     int i = leftStart, j = rightStart;                
     // 通过覆盖原数组 nums 来合并左子数组和右子数组
     for (int k = left; k <= right; k++) {
-        // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+        // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
         if (i > leftEnd)
             nums[k] = tmp[j++];
-        // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+        // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
         else if (j > rightEnd || tmp[i] <= tmp[j])
             nums[k] = tmp[i++];
-        // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
         else
             nums[k] = tmp[j++];
     }

codes/cpp/chapter_stack_and_queue/array_queue.cpp

@@ -64,13 +64,6 @@ public:
         return nums[front];
     }
 
-    /* 访问指定索引元素 */
-    int get(int index) {
-        if (index >= size())
-            throw out_of_range("索引越界");
-        return nums[(front + index) % capacity()];
-    }
-
     /* 将数组转化为 Vector 并返回 */
     vector<int> toVector() {
         int siz = size();
@@ -103,11 +96,7 @@ int main() {
     /* 访问队首元素 */
     int peek = queue->peek();
     cout << "队首元素 peek = " << peek << endl;
-
-    /* 访问指定索引元素 */
-    int num = queue->get(2);
-    cout << "队列第 3 个元素为 num = " << num << endl;
-
+    
     /* 元素出队 */
     int poll = queue->poll();
     cout << "出队元素 poll = " << poll << "，出队后 queue = ";

codes/cpp/chapter_stack_and_queue/array_stack.cpp

@@ -41,13 +41,6 @@ public:
         return stack.back();
     }
 
-    /* 访问索引 index 处元素 */
-    int get(int index) {
-        if(index >= size())
-            throw out_of_range("索引越界");
-        return stack[index];
-    }
-
     /* 返回 Vector */
     vector<int> toVector() {
         return stack;
@@ -73,10 +66,6 @@ int main() {
     int top = stack->top();
     cout << "栈顶元素 top = " << top << endl;
 
-    /* 访问索引 index 处元素 */
-    int num = stack->get(3);
-    cout << "栈索引 3 处的元素为 num = " << num << endl;
-
     /* 元素出栈 */
     int pop = stack->pop();
     cout << "出栈元素 pop = " << pop << "，出栈后 stack = ";

codes/cpp/chapter_tree/binary_tree_bfs.cpp

@@ -15,12 +15,12 @@ vector<int> hierOrder(TreeNode* root) {
     vector<int> vec;
     while (!queue.empty()) {
         TreeNode* node = queue.front();
-        queue.pop();  // 队列出队
-        vec.push_back(node->val);            // 保存结点
+        queue.pop();                 // 队列出队
+        vec.push_back(node->val);    // 保存结点
         if (node->left != nullptr)
-            queue.push(node->left);    // 左子结点入队
+            queue.push(node->left);  // 左子结点入队
         if (node->right != nullptr)
-            queue.push(node->right);   // 右子结点入队
+            queue.push(node->right); // 右子结点入队
     }
     return vec;
 }

codes/csharp/chapter_array_and_linkedlist/array.cs

@@ -1,4 +1,4 @@
-// File: Array.cs
+// File: array.cs
 // Created Time: 2022-12-14
 // Author: mingXta (1195669834@qq.com)
 
@@ -134,4 +134,4 @@ namespace hello_algo.chapter_array_and_linkedlist
             Console.WriteLine("在 nums 中查找元素 3 ，得到索引 = " + index);
         }
     }
-}
+}

codes/csharp/chapter_array_and_linkedlist/linked_list.cs

@@ -1,4 +1,4 @@
-// File: LinkedList.cs
+// File: linked_list.cs
 // Created Time: 2022-12-16
 // Author: mingXta (1195669834@qq.com)
 
@@ -7,14 +7,14 @@ using NUnit.Framework;
 
 namespace hello_algo.chapter_array_and_linkedlist
 {
-    public class LinkedList
+    public class linked_list
     {
         /// <summary>
         /// 在链表的结点 n0 之后插入结点 P
         /// </summary>
         public static void Insert(ListNode n0, ListNode P)
         {
-            ListNode n1 = n0.next;
+            ListNode? n1 = n0.next;
             n0.next = P;
             P.next = n1;
         }
@@ -28,14 +28,14 @@ namespace hello_algo.chapter_array_and_linkedlist
                 return;
             // n0 -> P -> n1
             ListNode P = n0.next;
-            ListNode n1 = P.next;
+            ListNode? n1 = P.next;
             n0.next = n1;
         }
 
         /// <summary>
         /// 访问链表中索引为 index 的结点
         /// </summary>
-        public static ListNode Access(ListNode head, int index)
+        public static ListNode? Access(ListNode head, int index)
         {
             for (int i = 0; i < index; i++)
             {
@@ -89,12 +89,12 @@ namespace hello_algo.chapter_array_and_linkedlist
             Console.WriteLine($"删除结点后的链表为{n0}");
 
             // 访问结点 
-            ListNode node = Access(n0, 3);
-            Console.WriteLine($"链表中索引 3 处的结点的值 = {node.val}");
+            ListNode? node = Access(n0, 3);
+            Console.WriteLine($"链表中索引 3 处的结点的值 = {node?.val}");
 
             // 查找结点 
             int index = Find(n0, 2);
             Console.WriteLine($"链表中值为 2 的结点的索引 = {index}");    
         }
     }
-}
+}

codes/csharp/chapter_array_and_linkedlist/list.cs

@@ -0,0 +1,75 @@
+/**
+ * File: list.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_array_and_linkedlist
+{
+    public class list
+    {
+        [Test]
+        public void Test()
+        {
+
+            /* 初始化列表 */
+            // 注意数组的元素类型是 int[] 的包装类 int[]
+            int[] numbers = new int[] { 1, 3, 2, 5, 4 };
+            List<int> list = numbers.ToList();
+            Console.WriteLine("列表 list = " + string.Join(",",list));
+
+            /* 访问元素 */
+            int num = list[1];
+            Console.WriteLine("访问索引 1 处的元素，得到 num = " + num);
+
+            /* 更新元素 */
+            list[1] = 0;
+            Console.WriteLine("将索引 1 处的元素更新为 0 ，得到 list = " + string.Join(",", list));
+
+            /* 清空列表 */
+            list.Clear();
+            Console.WriteLine("清空列表后 list = " + string.Join(",", list));
+
+            /* 尾部添加元素 */
+            list.Add(1);
+            list.Add(3);
+            list.Add(2);
+            list.Add(5);
+            list.Add(4);
+            Console.WriteLine("添加元素后 list = " + string.Join(",", list));
+
+            /* 中间插入元素 */
+            list.Insert(3, 6);
+            Console.WriteLine("在索引 3 处插入数字 6 ，得到 list = " + string.Join(",", list));
+
+            /* 删除元素 */
+            list.RemoveAt(3);
+            Console.WriteLine("删除索引 3 处的元素，得到 list = " + string.Join(",", list));
+
+            /* 通过索引遍历列表 */
+            int count = 0;
+            for (int i = 0; i < list.Count(); i++)
+            {
+                count++;
+            }
+
+            /* 直接遍历列表元素 */
+            count = 0;
+            foreach (int n in list)
+            {
+                count++;
+            }
+
+            /* 拼接两个列表 */
+            List<int> list1 = new() { 6, 8, 7, 10, 9 };
+            list.AddRange(list1);
+            Console.WriteLine("将列表 list1 拼接到 list 之后，得到 list = " + string.Join(",", list));
+
+            /* 排序列表 */
+            list.Sort(); // 排序后，列表元素从小到大排列
+            Console.WriteLine("排序列表后 list = " + string.Join(",", list));
+        }
+    }
+}

codes/csharp/chapter_array_and_linkedlist/my_list.cs

@@ -0,0 +1,164 @@
+/**
+ * File: my_list.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_array_and_linkedlist
+{
+    class MyList
+    {
+        private int[] nums;           // 数组（存储列表元素）
+        private int capacity = 10;    // 列表容量
+        private int size = 0;         // 列表长度（即当前元素数量）
+        private int extendRatio = 2;  // 每次列表扩容的倍数
+
+        /* 构造函数 */
+        public MyList()
+        {
+            nums = new int[capacity];
+        }
+
+        /* 获取列表长度（即当前元素数量）*/
+        public int Size()
+        {
+            return size;
+        }
+
+        /* 获取列表容量 */
+        public int Capacity()
+        {
+            return capacity;
+        }
+
+        /* 访问元素 */
+        public int Get(int index)
+        {
+            // 索引如果越界则抛出异常，下同
+            if (index >= size)
+                throw new IndexOutOfRangeException("索引越界");
+            return nums[index];
+        }
+
+        /* 更新元素 */
+        public void Set(int index, int num)
+        {
+            if (index >= size)
+                throw new IndexOutOfRangeException("索引越界");
+            nums[index] = num;
+        }
+
+        /* 尾部添加元素 */
+        public void Add(int num)
+        {
+            // 元素数量超出容量时，触发扩容机制
+            if (size == Capacity())
+                ExtendCapacity();
+            nums[size] = num;
+            // 更新元素数量
+            size++;
+        }
+
+        /* 中间插入元素 */
+        public void Insert(int index, int num)
+        {
+            if (index >= size)
+                throw new IndexOutOfRangeException("索引越界");
+            // 元素数量超出容量时，触发扩容机制
+            if (size == Capacity())
+                ExtendCapacity();
+            // 将索引 index 以及之后的元素都向后移动一位
+            for (int j = size - 1; j >= index; j--)
+            {
+                nums[j + 1] = nums[j];
+            }
+            nums[index] = num;
+            // 更新元素数量
+            size++;
+        }
+
+        /* 删除元素 */
+        public int Remove(int index)
+        {
+            if (index >= size)
+                throw new IndexOutOfRangeException("索引越界");
+            int num = nums[index];
+            // 将索引 index 之后的元素都向前移动一位
+            for (int j = index; j < size - 1; j++)
+            {
+                nums[j] = nums[j + 1];
+            }
+            // 更新元素数量
+            size--;
+            // 返回被删除元素
+            return num;
+        }
+
+        /* 列表扩容 */
+        public void ExtendCapacity()
+        {
+            // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+            System.Array.Resize(ref nums, Capacity() * extendRatio);
+            // 更新列表容量
+            capacity = nums.Length;
+        }
+
+        /* 将列表转换为数组 */
+        public int[] ToArray()
+        {
+            int size = Size();
+            // 仅转换有效长度范围内的列表元素
+            int[] nums = new int[size];
+            for (int i = 0; i < size; i++)
+            {
+                nums[i] = Get(i);
+            }
+            return nums;
+        }
+    }
+
+    public class my_list
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化列表 */
+            MyList list = new MyList();
+            /* 尾部添加元素 */
+            list.Add(1);
+            list.Add(3);
+            list.Add(2);
+            list.Add(5);
+            list.Add(4);
+            Console.WriteLine("列表 list = " + string.Join(",", list.ToArray()) +
+                               " ，容量 = " + list.Capacity() + " ，长度 = " + list.Size());
+
+            /* 中间插入元素 */
+            list.Insert(3, 6);
+            Console.WriteLine("在索引 3 处插入数字 6 ，得到 list = " + string.Join(",", list.ToArray()));
+
+            /* 删除元素 */
+            list.Remove(3);
+            Console.WriteLine("删除索引 3 处的元素，得到 list = " + string.Join(",", list.ToArray()));
+
+            /* 访问元素 */
+            int num = list.Get(1);
+            Console.WriteLine("访问索引 1 处的元素，得到 num = " + num);
+
+            /* 更新元素 */
+            list.Set(1, 0);
+            Console.WriteLine("将索引 1 处的元素更新为 0 ，得到 list = " + string.Join(",", list.ToArray()));
+
+            /* 测试扩容机制 */
+            for (int i = 0; i < 10; i++)
+            {
+                // 在 i = 5 时，列表长度将超出列表容量，此时触发扩容机制
+                list.Add(i);
+            }
+            Console.WriteLine("扩容后的列表 list = " + string.Join(",", list.ToArray()) +
+                               " ，容量 = " + list.Capacity() + " ，长度 = " + list.Size());
+        }
+    }
+}

codes/csharp/chapter_computational_complexity/leetcode_two_sum.cs

@@ -0,0 +1,69 @@
+/**
+ * File: leetcode_two_sum.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_computational_complexity
+{
+    class SolutionBruteForce
+    {
+        public int[] twoSum(int[] nums, int target)
+        {
+            int size = nums.Length;
+            // 两层循环，时间复杂度 O(n^2)
+            for (int i = 0; i < size - 1; i++)
+            {
+                for (int j = i + 1; j < size; j++)
+                {
+                    if (nums[i] + nums[j] == target)
+                        return new int[] { i, j };
+                }
+            }
+            return new int[0];
+        }
+    }
+
+    class SolutionHashMap
+    {
+        public int[] twoSum(int[] nums, int target)
+        {
+            int size = nums.Length;
+            // 辅助哈希表，空间复杂度 O(n)
+            Dictionary<int, int> dic = new();
+            // 单层循环，时间复杂度 O(n)
+            for (int i = 0; i < size; i++)
+            {
+                if (dic.ContainsKey(target - nums[i]))
+                {
+                    return new int[] { dic[target - nums[i]], i };
+                }
+                dic.Add(nums[i], i);
+            }
+            return new int[0];
+        }
+    }
+
+    public class leetcode_two_sum
+    {
+        [Test]
+        public void Test()
+        {
+            // ======= Test Case =======
+            int[] nums = { 2, 7, 11, 15 };
+            int target = 9;
+
+            // ====== Driver Code ======
+            // 方法一
+            SolutionBruteForce slt1 = new SolutionBruteForce();
+            int[] res = slt1.twoSum(nums, target);
+            Console.WriteLine("方法一 res = " + string.Join(",", res));
+            // 方法二
+            SolutionHashMap slt2 = new SolutionHashMap();
+            res = slt2.twoSum(nums, target);
+            Console.WriteLine("方法二 res = " + string.Join(",", res));
+        }
+    }
+}

codes/csharp/chapter_computational_complexity/space_complexity.cs

@@ -0,0 +1,122 @@
+/**
+ * File: space_complexity.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_computational_complexity
+{
+    public class space_complexity
+    {
+        /* 函数 */
+        static int function()
+        {
+            // do something
+            return 0;
+        }
+
+        /* 常数阶 */
+        static void constant(int n)
+        {
+            // 常量、变量、对象占用 O(1) 空间
+            int a = 0;
+            int b = 0;
+            int[] nums = new int[10000];
+            ListNode node = new ListNode(0);
+            // 循环中的变量占用 O(1) 空间
+            for (int i = 0; i < n; i++)
+            {
+                int c = 0;
+            }
+            // 循环中的函数占用 O(1) 空间
+            for (int i = 0; i < n; i++)
+            {
+                function();
+            }
+        }
+
+        /* 线性阶 */
+        static void linear(int n)
+        {
+            // 长度为 n 的数组占用 O(n) 空间
+            int[] nums = new int[n];
+            // 长度为 n 的列表占用 O(n) 空间
+            List<ListNode> nodes = new();
+            for (int i = 0; i < n; i++)
+            {
+                nodes.Add(new ListNode(i));
+            }
+            // 长度为 n 的哈希表占用 O(n) 空间
+            Dictionary<int, String> map = new();
+            for (int i = 0; i < n; i++)
+            {
+                map.Add(i, i.ToString());
+            }
+        }
+
+        /* 线性阶（递归实现） */
+        static void linearRecur(int n)
+        {
+            Console.WriteLine("递归 n = " + n);
+            if (n == 1) return;
+            linearRecur(n - 1);
+        }
+
+        /* 平方阶 */
+        static void quadratic(int n)
+        {
+            // 矩阵占用 O(n^2) 空间
+            int[,] numMatrix = new int[n, n];
+            // 二维列表占用 O(n^2) 空间
+            List<List<int>> numList = new();
+            for (int i = 0; i < n; i++)
+            {
+                List<int> tmp = new();
+                for (int j = 0; j < n; j++)
+                {
+                    tmp.Add(0);
+                }
+                numList.Add(tmp);
+            }
+        }
+
+        /* 平方阶（递归实现） */
+        static int quadraticRecur(int n)
+        {
+            if (n <= 0) return 0;
+            int[] nums = new int[n];
+            Console.WriteLine("递归 n = " + n + " 中的 nums 长度 = " + nums.Length);
+            return quadraticRecur(n - 1);
+        }
+
+        /* 指数阶（建立满二叉树） */
+        static TreeNode? buildTree(int n)
+        {
+            if (n == 0) return null;
+            TreeNode root = new TreeNode(0);
+            root.left = buildTree(n - 1);
+            root.right = buildTree(n - 1);
+            return root;
+        }
+
+        [Test]
+        public void Test()
+        {
+            int n = 5;
+            // 常数阶
+            constant(n);
+            // 线性阶
+            linear(n);
+            linearRecur(n);
+            // 平方阶
+            quadratic(n);
+            quadraticRecur(n);
+            // 指数阶
+            TreeNode? root = buildTree(n);
+            PrintUtil.PrintTree(root);
+        }
+    }
+}

codes/csharp/chapter_computational_complexity/time_complexity.cs

@@ -0,0 +1,232 @@
+/**
+ * File: time_complexity.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_computational_complexity
+{
+    public class time_complexity
+    {
+        void algorithm(int n)
+        {
+            int a = 1;  // +0（技巧 1）
+            a = a + n;  // +0（技巧 1）
+            // +n（技巧 2）
+            for (int i = 0; i < 5 * n + 1; i++)
+            {
+                Console.WriteLine(0);
+            }
+            // +n*n（技巧 3）
+            for (int i = 0; i < 2 * n; i++)
+            {
+                for (int j = 0; j < n + 1; j++)
+                {
+                    Console.WriteLine(0);
+                }
+            }
+        }
+
+        // 算法 A 时间复杂度：常数阶
+        void algorithm_A(int n)
+        {
+            Console.WriteLine(0);
+        }
+        // 算法 B 时间复杂度：线性阶
+        void algorithm_B(int n)
+        {
+            for (int i = 0; i < n; i++)
+            {
+                Console.WriteLine(0);
+            }
+        }
+        // 算法 C 时间复杂度：常数阶
+        void algorithm_C(int n)
+        {
+            for (int i = 0; i < 1000000; i++)
+            {
+                Console.WriteLine(0);
+            }
+        }
+
+        /* 常数阶 */
+        static int constant(int n)
+        {
+            int count = 0;
+            int size = 100000;
+            for (int i = 0; i < size; i++)
+                count++;
+            return count;
+        }
+
+        /* 线性阶 */
+        static int linear(int n)
+        {
+            int count = 0;
+            for (int i = 0; i < n; i++)
+                count++;
+            return count;
+        }
+
+        /* 线性阶（遍历数组） */
+        static int arrayTraversal(int[] nums)
+        {
+            int count = 0;
+            // 循环次数与数组长度成正比
+            foreach (int num in nums)
+            {
+                count++;
+            }
+            return count;
+        }
+
+        /* 平方阶 */
+        static int quadratic(int n)
+        {
+            int count = 0;
+            // 循环次数与数组长度成平方关系
+            for (int i = 0; i < n; i++)
+            {
+                for (int j = 0; j < n; j++)
+                {
+                    count++;
+                }
+            }
+            return count;
+        }
+
+        /* 平方阶（冒泡排序） */
+        static int bubbleSort(int[] nums)
+        {
+            int count = 0;  // 计数器
+            // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+            for (int i = nums.Length - 1; i > 0; i--)
+            {
+                // 内循环：冒泡操作
+                for (int j = 0; j < i; j++)
+                {
+                    if (nums[j] > nums[j + 1])
+                    {
+                        // 交换 nums[j] 与 nums[j + 1]
+                        int tmp = nums[j];
+                        nums[j] = nums[j + 1];
+                        nums[j + 1] = tmp;
+                        count += 3;  // 元素交换包含 3 个单元操作
+                    }
+                }
+            }
+            return count;
+        }
+
+        /* 指数阶（循环实现） */
+        static int exponential(int n)
+        {
+            int count = 0, bas = 1;
+            // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+            for (int i = 0; i < n; i++)
+            {
+                for (int j = 0; j < bas; j++)
+                {
+                    count++;
+                }
+                bas *= 2;
+            }
+            // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+            return count;
+        }
+
+        /* 指数阶（递归实现） */
+        static int expRecur(int n)
+        {
+            if (n == 1) return 1;
+            return expRecur(n - 1) + expRecur(n - 1) + 1;
+        }
+
+        /* 对数阶（循环实现） */
+        static int logarithmic(float n)
+        {
+            int count = 0;
+            while (n > 1)
+            {
+                n = n / 2;
+                count++;
+            }
+            return count;
+        }
+
+        /* 对数阶（递归实现） */
+        static int logRecur(float n)
+        {
+            if (n <= 1) return 0;
+            return logRecur(n / 2) + 1;
+        }
+
+        /* 线性对数阶 */
+        static int linearLogRecur(float n)
+        {
+            if (n <= 1) return 1;
+            int count = linearLogRecur(n / 2) +
+                        linearLogRecur(n / 2);
+            for (int i = 0; i < n; i++)
+            {
+                count++;
+            }
+            return count;
+        }
+
+        /* 阶乘阶（递归实现） */
+        static int factorialRecur(int n)
+        {
+            if (n == 0) return 1;
+            int count = 0;
+            // 从 1 个分裂出 n 个
+            for (int i = 0; i < n; i++)
+            {
+                count += factorialRecur(n - 1);
+            }
+            return count;
+        }
+
+        [Test]
+        public void Test()
+        {
+            // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+            int n = 8;
+            Console.WriteLine("输入数据大小 n = " + n);
+
+            int count = constant(n);
+            Console.WriteLine("常数阶的计算操作数量 = " + count);
+
+            count = linear(n);
+            Console.WriteLine("线性阶的计算操作数量 = " + count);
+            count = arrayTraversal(new int[n]);
+            Console.WriteLine("线性阶（遍历数组）的计算操作数量 = " + count);
+
+            count = quadratic(n);
+            Console.WriteLine("平方阶的计算操作数量 = " + count);
+            int[] nums = new int[n];
+            for (int i = 0; i < n; i++)
+                nums[i] = n - i;  // [n,n-1,...,2,1]
+            count = bubbleSort(nums);
+            Console.WriteLine("平方阶（冒泡排序）的计算操作数量 = " + count);
+
+            count = exponential(n);
+            Console.WriteLine("指数阶（循环实现）的计算操作数量 = " + count);
+            count = expRecur(n);
+            Console.WriteLine("指数阶（递归实现）的计算操作数量 = " + count);
+
+            count = logarithmic((float)n);
+            Console.WriteLine("对数阶（循环实现）的计算操作数量 = " + count);
+            count = logRecur((float)n);
+            Console.WriteLine("对数阶（递归实现）的计算操作数量 = " + count);
+
+            count = linearLogRecur((float)n);
+            Console.WriteLine("线性对数阶（递归实现）的计算操作数量 = " + count);
+
+            count = factorialRecur(n);
+            Console.WriteLine("阶乘阶（递归实现）的计算操作数量 = " + count);
+        }
+    }
+}

codes/csharp/chapter_computational_complexity/worst_best_time_complexity.cs

@@ -0,0 +1,61 @@
+/**
+ * File: worst_best_time_complexity.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_computational_complexity
+{
+    public class worst_best_time_complexity
+    {
+        /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+        static int[] randomNumbers(int n)
+        {
+            int[] nums = new int[n];
+            // 生成数组 nums = { 1, 2, 3, ..., n }
+            for (int i = 0; i < n; i++)
+            {
+                nums[i] = i + 1;
+            }
+
+            // 随机打乱数组元素
+            for (int i = 0; i < nums.Length; i++)
+            {
+                var index = new Random().Next(i, nums.Length);
+                var tmp = nums[i];
+                var ran = nums[index];
+                nums[i] = ran;
+                nums[index] = tmp;
+            }
+            return nums;
+        }
+
+        /* 查找数组 nums 中数字 1 所在索引 */
+        static int findOne(int[] nums)
+        {
+            for (int i = 0; i < nums.Length; i++)
+            {
+                if (nums[i] == 1)
+                    return i;
+            }
+            return -1;
+        }
+
+
+        /* Driver Code */
+        [Test]
+        public void Test()
+        {
+            for (int i = 0; i < 10; i++)
+            {
+                int n = 100;
+                int[] nums = randomNumbers(n);
+                int index = findOne(nums);
+                Console.WriteLine("\n数组 [ 1, 2, ..., n ] 被打乱后 = " + string.Join(",", nums));
+                Console.WriteLine("数字 1 的索引为 " + index);
+            }
+        }
+    }
+}

codes/csharp/chapter_hashing/array_hash_map.cs

@@ -0,0 +1,164 @@
+/**
+ * File: array_hash_map.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_hashing
+{
+
+    /* 键值对 int->String */
+    class Entry
+    {
+        public int key;
+        public String val;
+        public Entry(int key, String val)
+        {
+            this.key = key;
+            this.val = val;
+        }
+    }
+
+    /* 基于数组简易实现的哈希表 */
+    class ArrayHashMap
+    {
+        private List<Entry?> bucket;
+        public ArrayHashMap()
+        {
+            // 初始化一个长度为 100 的桶（数组）
+            bucket = new ();
+            for (int i = 0; i < 100; i++)
+            {
+                bucket.Add(null);
+            }
+        }
+
+        /* 哈希函数 */
+        private int hashFunc(int key)
+        {
+            int index = key % 100;
+            return index;
+        }
+
+        /* 查询操作 */
+        public String? get(int key)
+        {
+            int index = hashFunc(key);
+            Entry? pair = bucket[index];
+            if (pair == null) return null;
+            return pair.val;
+        }
+
+        /* 添加操作 */
+        public void put(int key, String val)
+        {
+            Entry pair = new Entry(key, val);
+            int index = hashFunc(key);
+            bucket[index]=pair;
+        }
+
+        /* 删除操作 */
+        public void remove(int key)
+        {
+            int index = hashFunc(key);
+            // 置为 null ，代表删除
+            bucket[index]=null;
+        }
+
+        /* 获取所有键值对 */
+        public List<Entry> entrySet()
+        {
+            List<Entry> entrySet = new ();
+            foreach (Entry? pair in bucket)
+            {
+                if (pair != null)
+                    entrySet.Add(pair);
+            }
+            return entrySet;
+        }
+
+        /* 获取所有键 */
+        public List<int> keySet()
+        {
+            List<int> keySet = new ();
+            foreach (Entry? pair in bucket)
+            {
+                if (pair != null)
+                    keySet.Add(pair.key);
+            }
+            return keySet;
+        }
+
+        /* 获取所有值 */
+        public List<String> valueSet()
+        {
+            List<String> valueSet = new ();
+            foreach (Entry? pair in bucket)
+            {
+                if (pair != null)
+                    valueSet.Add(pair.val);
+            }
+            return valueSet;
+        }
+
+        /* 打印哈希表 */
+        public void print()
+        {
+            foreach (Entry kv in entrySet())
+            {
+                Console.WriteLine(kv.key + " -> " + kv.val);
+            }
+        }
+    }
+
+
+    public class array_hash_map
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化哈希表 */
+            ArrayHashMap map = new ArrayHashMap();
+
+            /* 添加操作 */
+            // 在哈希表中添加键值对 (key, value)
+            map.put(12836, "小哈");
+            map.put(15937, "小啰");
+            map.put(16750, "小算");
+            map.put(13276, "小法");
+            map.put(10583, "小鸭");
+            Console.WriteLine("\n添加完成后，哈希表为\nKey -> Value");
+            map.print();
+
+            /* 查询操作 */
+            // 向哈希表输入键 key ，得到值 value
+            String? name = map.get(15937);
+            Console.WriteLine("\n输入学号 15937 ，查询到姓名 " + name);
+
+            /* 删除操作 */
+            // 在哈希表中删除键值对 (key, value)
+            map.remove(10583);
+            Console.WriteLine("\n删除 10583 后，哈希表为\nKey -> Value");
+            map.print();
+
+            /* 遍历哈希表 */
+            Console.WriteLine("\n遍历键值对 Key->Value");
+            foreach (Entry kv in map.entrySet())
+            {
+                Console.WriteLine(kv.key + " -> " + kv.val);
+            }
+            Console.WriteLine("\n单独遍历键 Key");
+            foreach (int key in map.keySet())
+            {
+                Console.WriteLine(key);
+            }
+            Console.WriteLine("\n单独遍历值 Value");
+            foreach (String val in map.valueSet())
+            {
+                Console.WriteLine(val);
+            }
+        }
+    }
+}

codes/csharp/chapter_hashing/hash_map.cs

@@ -0,0 +1,57 @@
+
+/**
+ * File: hash_map.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_hashing
+{
+
+    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, "小鸭");
+            Console.WriteLine("\n添加完成后，哈希表为\nKey -> Value");
+            PrintUtil.printHashMap(map);
+
+            /* 查询操作 */
+            // 向哈希表输入键 key ，得到值 value
+            String name = map[15937];
+            Console.WriteLine("\n输入学号 15937 ，查询到姓名 " + name);
+
+            /* 删除操作 */
+            // 在哈希表中删除键值对 (key, value)
+            map.Remove(10583);
+            Console.WriteLine("\n删除 10583 后，哈希表为\nKey -> Value");
+            PrintUtil.printHashMap(map);
+
+            /* 遍历哈希表 */
+            Console.WriteLine("\n遍历键值对 Key->Value");
+            foreach (var kv in map) {
+                Console.WriteLine(kv.Key + " -> " + kv.Value);
+            }
+            Console.WriteLine("\n单独遍历键 Key");
+            foreach (int key in map.Keys) {
+                Console.WriteLine(key);
+            }
+            Console.WriteLine("\n单独遍历值 Value");
+            foreach (String val in map.Values) {
+                Console.WriteLine(val);
+            }
+        }
+    }
+}

codes/csharp/chapter_searching/binary_search.cs

@@ -0,0 +1,68 @@
+/**
+ * File: binary_search.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_searching
+{
+    public class binary_search
+    {
+        /* 二分查找（双闭区间） */
+        static int binarySearch(int[] nums, int target)
+        {
+            // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+            int i = 0, j = nums.Length - 1;
+            // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+            while (i <= j)
+            {
+                int m = (i + j) / 2;       // 计算中点索引 m
+                if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j] 中
+                    i = m + 1;
+                else if (nums[m] > target) // 此情况说明 target 在区间 [i, m-1] 中
+                    j = m - 1;
+                else                       // 找到目标元素，返回其索引
+                    return m;
+            }
+            // 未找到目标元素，返回 -1
+            return -1;
+        }
+
+        /* 二分查找（左闭右开） */
+        static int binarySearch1(int[] nums, int target)
+        {
+            // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+            int i = 0, j = nums.Length;
+            // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+            while (i < j)
+            {
+                int m = (i + j) / 2;       // 计算中点索引 m
+                if (nums[m] < target)      // 此情况说明 target 在区间 [m+1, j) 中
+                    i = m + 1;
+                else if (nums[m] > target) // 此情况说明 target 在区间 [i, m) 中
+                    j = m;
+                else                       // 找到目标元素，返回其索引
+                    return m;
+            }
+            // 未找到目标元素，返回 -1
+            return -1;
+        }
+
+        [Test]
+        public void Test()
+        {
+            int target = 6;
+            int[] nums = { 1, 3, 6, 8, 12, 15, 23, 67, 70, 92 };
+
+            /* 二分查找（双闭区间） */
+            int index = binarySearch(nums, target);
+            Console.WriteLine("目标元素 6 的索引 = " + index);
+
+            /* 二分查找（左闭右开） */
+            index = binarySearch1(nums, target);
+            Console.WriteLine("目标元素 6 的索引 = " + index);
+        }
+    }
+}

codes/csharp/chapter_searching/hashing_search.cs

@@ -0,0 +1,60 @@
+/**
+ * File: hashing_search.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_searching
+{
+    public class hashing_search
+    {
+        /* 哈希查找（数组） */
+        static int hashingSearch(Dictionary<int, int> map, int target)
+        {
+            // 哈希表的 key: 目标元素，value: 索引
+            // 若哈希表中无此 key ，返回 -1
+            return map.GetValueOrDefault(target, -1);
+        }
+
+        /* 哈希查找（链表） */
+        static ListNode? hashingSearch1(Dictionary<int, ListNode> map, int target)
+        {
+
+            // 哈希表的 key: 目标结点值，value: 结点对象
+            // 若哈希表中无此 key ，返回 null
+            return map.GetValueOrDefault(target);
+        }
+
+        [Test]
+        public void Test()
+        {
+            int target = 3;
+
+            /* 哈希查找（数组） */
+            int[] nums = { 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 };
+            // 初始化哈希表
+            Dictionary<int, int> map = new();
+            for (int i = 0; i < nums.Length; i++)
+            {
+                map[nums[i]] = i;  // key: 元素，value: 索引
+            }
+            int index = hashingSearch(map, target);
+            Console.WriteLine("目标元素 3 的索引 = " + index);
+
+            /* 哈希查找（链表） */
+            ListNode? head = ListNode.ArrToLinkedList(nums);
+            // 初始化哈希表
+            Dictionary<int, ListNode> map1 = new();
+            while (head != null)
+            {
+                map1[head.val] = head;  // key: 结点值，value: 结点
+                head = head.next;
+            }
+            ListNode? node = hashingSearch1(map1, target);
+            Console.WriteLine("目标结点值 3 的对应结点对象为 " + node);
+        }
+    }
+}

codes/csharp/chapter_searching/linear_search.cs

@@ -0,0 +1,59 @@
+/**
+ * File: linear_search.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_searching
+{
+    public class linear_search
+    {
+        /* 线性查找（数组） */
+        static int linearSearch(int[] nums, int target)
+        {
+            // 遍历数组
+            for (int i = 0; i < nums.Length; i++)
+            {
+                // 找到目标元素，返回其索引
+                if (nums[i] == target)
+                    return i;
+            }
+            // 未找到目标元素，返回 -1
+            return -1;
+        }
+
+        /* 线性查找（链表） */
+        static ListNode? linearSearch(ListNode head, int target)
+        {
+            // 遍历链表
+            while (head != null)
+            {
+                // 找到目标结点，返回之
+                if (head.val == target)
+                    return head;
+                head = head.next;
+            }
+            // 未找到目标结点，返回 null
+            return null;
+        }
+
+        [Test]
+        public void Test()
+        {
+            int target = 3;
+
+            /* 在数组中执行线性查找 */
+            int[] nums = { 1, 5, 3, 2, 4, 7, 5, 9, 10, 8 };
+            int index = linearSearch(nums, target);
+            Console.WriteLine("目标元素 3 的索引 = " + index);
+
+            /* 在链表中执行线性查找 */
+            ListNode head = ListNode.ArrToLinkedList(nums);
+            ListNode? node = linearSearch(head, target);
+            Console.WriteLine("目标结点值 3 的对应结点对象为 " + node);
+        }
+    }
+}

codes/csharp/chapter_sorting/bubble_sort.cs

@@ -0,0 +1,68 @@
+/**
+ * File: bubble_sort.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_sorting
+{
+    public class bubble_sort
+    {
+        /* 冒泡排序 */
+        static void bubbleSort(int[] nums)
+        {
+            // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+            for (int i = nums.Length - 1; i > 0; i--)
+            {
+                // 内循环：冒泡操作
+                for (int j = 0; j < i; j++)
+                {
+                    if (nums[j] > nums[j + 1])
+                    {
+                        // 交换 nums[j] 与 nums[j + 1]
+                        int tmp = nums[j];
+                        nums[j] = nums[j + 1];
+                        nums[j + 1] = tmp;
+                    }
+                }
+            }
+        }
+
+        /* 冒泡排序（标志优化）*/
+        static void bubbleSortWithFlag(int[] nums)
+        {
+            // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+            for (int i = nums.Length - 1; i > 0; i--)
+            {
+                bool flag = false; // 初始化标志位
+                // 内循环：冒泡操作
+                for (int j = 0; j < i; j++)
+                {
+                    if (nums[j] > nums[j + 1])
+                    {
+                        // 交换 nums[j] 与 nums[j + 1]
+                        int tmp = nums[j];
+                        nums[j] = nums[j + 1];
+                        nums[j + 1] = tmp;
+                        flag = true;  // 记录交换元素
+                    }
+                }
+                if (!flag) break;     // 此轮冒泡未交换任何元素，直接跳出
+            }
+        }
+
+        [Test]
+        public void Test()
+        {
+            int[] nums = { 4, 1, 3, 1, 5, 2 };
+            bubbleSort(nums);
+            Console.WriteLine("冒泡排序完成后  nums = " + string.Join(",",nums));
+
+            int[] nums1 = { 4, 1, 3, 1, 5, 2 };
+            bubbleSortWithFlag(nums1);
+            Console.WriteLine("冒泡排序完成后 nums1 = " + string.Join(",", nums));
+        }
+    }
+}

codes/csharp/chapter_sorting/insertion_sort.cs

@@ -0,0 +1,38 @@
+/**
+ * File: insertion_sort.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_sorting
+{
+    public class insertion_sort
+    {
+        /* 插入排序 */
+        static void insertionSort(int[] nums)
+        {
+            // 外循环：base = nums[1], nums[2], ..., nums[n-1]
+            for (int i = 1; i < nums.Length; i++)
+            {
+                int bas = nums[i], j = i - 1;
+                // 内循环：将 base 插入到左边的正确位置
+                while (j >= 0 && nums[j] > bas)
+                {
+                    nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
+                    j--;
+                }
+                nums[j + 1] = bas;         // 2. 将 base 赋值到正确位置
+            }
+        }
+
+        [Test]
+        public void Test()
+        {
+            int[] nums = { 4, 1, 3, 1, 5, 2 };
+            insertionSort(nums);
+            Console.WriteLine("插入排序完成后 nums = " + string.Join(",", nums));
+        }
+    }
+}

codes/csharp/chapter_sorting/merge_sort.cs

@@ -0,0 +1,65 @@
+/**
+ * File: merge_sort.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_sorting
+{
+    public class merge_sort
+    {
+        /**
+         * 合并左子数组和右子数组
+         * 左子数组区间 [left, mid]
+         * 右子数组区间 [mid + 1, right]
+         */
+        static void merge(int[] nums, int left, int mid, int right)
+        {
+            // 初始化辅助数组
+            int[] tmp = 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;
+            // 通过覆盖原数组 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++];
+            }
+        }
+
+        /* 归并排序 */
+        static 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);
+        }
+
+        [Test]
+        public void Test()
+        {
+            /* 归并排序 */
+            int[] nums = { 7, 3, 2, 6, 0, 1, 5, 4 };
+            mergeSort(nums, 0, nums.Length - 1);
+            Console.WriteLine("归并排序完成后 nums = " + string.Join(",", nums));
+        }
+    }
+}

codes/csharp/chapter_sorting/quick_sort.cs

@@ -0,0 +1,183 @@
+/**
+ * File: quick_sort.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_sorting
+{
+    class QuickSort
+    {
+        /* 元素交换 */
+        static void swap(int[] nums, int i, int j)
+        {
+            int tmp = nums[i];
+            nums[i] = nums[j];
+            nums[j] = tmp;
+        }
+
+        /* 哨兵划分 */
+        static 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;             // 返回基准数的索引
+        }
+
+        /* 快速排序 */
+        public static 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);
+        }
+    }
+
+    /* 快速排序类（中位基准数优化） */
+    class QuickSortMedian
+    {
+        /* 元素交换 */
+        static void swap(int[] nums, int i, int j)
+        {
+            int tmp = nums[i];
+            nums[i] = nums[j];
+            nums[j] = tmp;
+        }
+
+        /* 选取三个元素的中位数 */
+        static 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;
+        }
+
+        /* 哨兵划分（三数取中值） */
+        static int partition(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;             // 返回基准数的索引
+        }
+
+        /* 快速排序 */
+        public static 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);
+        }
+    }
+
+    /* 快速排序类（尾递归优化） */
+    class QuickSortTailCall
+    {
+        /* 元素交换 */
+        static void swap(int[] nums, int i, int j)
+        {
+            int tmp = nums[i];
+            nums[i] = nums[j];
+            nums[j] = tmp;
+        }
+
+        /* 哨兵划分 */
+        static 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; // 返回基准数的索引
+        }
+
+        /* 快速排序（尾递归优化） */
+        public static void quickSort(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]
+                }
+                else
+                {
+                    quickSort(nums, pivot + 1, right); // 递归排序右子数组
+                    right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
+                }
+            }
+        }
+    }
+
+    public class quick_sort
+    {
+        [Test]
+        public void Test()
+        {
+            /* 快速排序 */
+            int[] nums = { 2, 4, 1, 0, 3, 5 };
+            QuickSort.quickSort(nums, 0, nums.Length - 1);
+            Console.WriteLine("快速排序完成后 nums = " + string.Join(",", nums));
+
+            /* 快速排序（中位基准数优化） */
+            int[] nums1 = { 2, 4, 1, 0, 3, 5 };
+            QuickSortMedian.quickSort(nums1, 0, nums1.Length - 1);
+            Console.WriteLine("快速排序（中位基准数优化）完成后 nums1 = " + string.Join(",", nums1));
+
+            /* 快速排序（尾递归优化） */
+            int[] nums2 = { 2, 4, 1, 0, 3, 5 };
+            QuickSortTailCall.quickSort(nums2, 0, nums2.Length - 1);
+            Console.WriteLine("快速排序（尾递归优化）完成后 nums2 = " + string.Join(",", nums2));
+        }
+    }
+}

codes/csharp/chapter_stack_and_queue/array_queue.cs

@@ -0,0 +1,133 @@
+/**
+ * File: array_queue.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_stack_and_queue
+{
+
+    /* 基于环形数组实现的队列 */
+    class ArrayQueue
+    {
+        private int[] nums;     // 用于存储队列元素的数组
+        private int front = 0;  // 头指针，指向队首
+        private int rear = 0;   // 尾指针，指向队尾 + 1
+
+        public ArrayQueue(int capacity)
+        {
+            // 初始化数组
+            nums = new int[capacity];
+        }
+
+        /* 获取队列的容量 */
+        public int capacity()
+        {
+            return nums.Length;
+        }
+
+        /* 获取队列的长度 */
+        public int size()
+        {
+            int capacity = this.capacity();
+            // 由于将数组看作为环形，可能 rear < front ，因此需要取余数
+            return (capacity + rear - front) % capacity;
+        }
+
+        /* 判断队列是否为空 */
+        public bool isEmpty()
+        {
+            return rear - front == 0;
+        }
+
+        /* 入队 */
+        public void offer(int num)
+        {
+            if (size() == capacity())
+            {
+                Console.WriteLine("队列已满");
+                return;
+            }
+            // 尾结点后添加 num
+            nums[rear] = num;
+            // 尾指针向后移动一位，越过尾部后返回到数组头部
+            rear = (rear + 1) % capacity();
+        }
+
+        /* 出队 */
+        public int poll()
+        {
+            int num = peek();
+            // 队头指针向后移动一位，若越过尾部则返回到数组头部
+            front = (front + 1) % capacity();
+            return num;
+        }
+
+        /* 访问队首元素 */
+        public int peek()
+        {
+            if (isEmpty())
+                throw new Exception();
+            return nums[front];
+        }
+
+        /* 返回数组 */
+        public int[] toArray()
+        {
+            int size = this.size();
+            int capacity = this.capacity();
+            // 仅转换有效长度范围内的列表元素
+            int[] res = new int[size];
+            for (int i = 0, j = front; i < size; i++, j++)
+            {
+                res[i] = nums[j % capacity];
+            }
+            return res;
+        }
+    }
+
+    public class array_queue
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化队列 */
+            int capacity = 10;
+            ArrayQueue queue = new ArrayQueue(capacity);
+
+            /* 元素入队 */
+            queue.offer(1);
+            queue.offer(3);
+            queue.offer(2);
+            queue.offer(5);
+            queue.offer(4);
+            Console.WriteLine("队列 queue = " + string.Join(",", queue.toArray()));
+
+            /* 访问队首元素 */
+            int peek = queue.peek();
+            Console.WriteLine("队首元素 peek = " + peek);
+
+            /* 元素出队 */
+            int poll = queue.poll();
+            Console.WriteLine("出队元素 poll = " + poll + "，出队后 queue = " + string.Join(",", queue.toArray()));
+
+            /* 获取队列的长度 */
+            int size = queue.size();
+            Console.WriteLine("队列长度 size = " + size);
+
+            /* 判断队列是否为空 */
+            bool isEmpty = queue.isEmpty();
+            Console.WriteLine("队列是否为空 = " + isEmpty);
+
+            /* 测试环形数组 */
+            for (int i = 0; i < 10; i++)
+            {
+                queue.offer(i);
+                queue.poll();
+                Console.WriteLine("第 " + i + " 轮入队 + 出队后 queue = " + string.Join(",", queue.toArray()));
+            }
+        }
+    }
+}

codes/csharp/chapter_stack_and_queue/array_stack.cs

@@ -0,0 +1,98 @@
+/**
+ * File: array_stack.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_stack_and_queue
+{
+
+    /* 基于数组实现的栈 */
+    class ArrayStack
+    {
+        private List<int> stack;
+        public ArrayStack()
+        {
+            // 初始化列表（动态数组）
+            stack = new();
+        }
+
+        /* 获取栈的长度 */
+        public int size()
+        {
+            return stack.Count();
+        }
+
+        /* 判断栈是否为空 */
+        public bool isEmpty()
+        {
+            return size() == 0;
+        }
+
+        /* 入栈 */
+        public void push(int num)
+        {
+            stack.Add(num);
+        }
+
+        /* 出栈 */
+        public int pop()
+        {
+            if (isEmpty())
+                throw new Exception();
+            var val = peek();
+            stack.RemoveAt(size() - 1);
+            return val;
+        }
+
+        /* 访问栈顶元素 */
+        public int peek()
+        {
+            if (isEmpty())
+                throw new Exception();
+            return stack[size() - 1];
+        }
+
+        /* 将 List 转化为 Array 并返回 */
+        public int[] toArray()
+        {
+            return stack.ToArray();
+        }
+    }
+
+    public class array_stack
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化栈 */
+            ArrayStack stack = new ArrayStack();
+
+            /* 元素入栈 */
+            stack.push(1);
+            stack.push(3);
+            stack.push(2);
+            stack.push(5);
+            stack.push(4);
+            Console.WriteLine("栈 stack = " + String.Join(",", stack.toArray()));
+
+            /* 访问栈顶元素 */
+            int peek = stack.peek();
+            Console.WriteLine("栈顶元素 peek = " + peek);
+
+            /* 元素出栈 */
+            int pop = stack.pop();
+            Console.WriteLine("出栈元素 pop = " + pop + "，出栈后 stack = " + String.Join(",", stack.toArray()));
+
+            /* 获取栈的长度 */
+            int size = stack.size();
+            Console.WriteLine("栈的长度 size = " + size);
+
+            /* 判断是否为空 */
+            bool isEmpty = stack.isEmpty();
+            Console.WriteLine("栈是否为空 = " + isEmpty);
+        }
+    }
+}

codes/csharp/chapter_stack_and_queue/linkedlist_queue.cs

@@ -0,0 +1,124 @@
+/**
+ * File: linkedlist_queue.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_stack_and_queue
+{
+    /* 基于链表实现的队列 */
+    class LinkedListQueue
+    {
+        private ListNode? front, rear;  // 头结点 front ，尾结点 rear 
+        private int queSize = 0;
+
+        public LinkedListQueue()
+        {
+            front = null;
+            rear = null;
+        }
+
+        /* 获取队列的长度 */
+        public int size()
+        {
+            return queSize;
+        }
+
+        /* 判断队列是否为空 */
+        public bool isEmpty()
+        {
+            return size() == 0;
+        }
+
+        /* 入队 */
+        public void offer(int num)
+        {
+            // 尾结点后添加 num
+            ListNode node = new ListNode(num);
+            // 如果队列为空，则令头、尾结点都指向该结点
+            if (front == null)
+            {
+                front = node;
+                rear = node;
+                // 如果队列不为空，则将该结点添加到尾结点后
+            }
+            else if (rear != null)
+            {
+                rear.next = node;
+                rear = node;
+            }
+            queSize++;
+        }
+
+        /* 出队 */
+        public int poll()
+        {
+            int num = peek();
+            // 删除头结点
+            front = front?.next;
+            queSize--;
+            return num;
+        }
+
+        /* 访问队首元素 */
+        public int peek()
+        {
+            if (size() == 0 || front == null)
+                throw new Exception();
+            return front.val;
+        }
+
+        /* 将链表转化为 Array 并返回 */
+        public int[] toArray()
+        {
+            if (front == null)
+                return Array.Empty<int>();
+
+            ListNode node = front;
+            int[] res = new int[size()];
+            for (int i = 0; i < res.Length; i++)
+            {
+                res[i] = node.val;
+                node = node.next;
+            }
+            return res;
+        }
+    }
+
+    public class linkedlist_queue
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化队列 */
+            LinkedListQueue queue = new LinkedListQueue();
+
+            /* 元素入队 */
+            queue.offer(1);
+            queue.offer(3);
+            queue.offer(2);
+            queue.offer(5);
+            queue.offer(4);
+            Console.WriteLine("队列 queue = " + String.Join(",", queue.toArray()));
+
+            /* 访问队首元素 */
+            int peek = queue.peek();
+            Console.WriteLine("队首元素 peek = " + peek);
+
+            /* 元素出队 */
+            int poll = queue.poll();
+            Console.WriteLine("出队元素 poll = " + poll + "，出队后 queue = " + String.Join(",", queue.toArray()));
+
+            /* 获取队列的长度 */
+            int size = queue.size();
+            Console.WriteLine("队列长度 size = " + size);
+
+            /* 判断队列是否为空 */
+            bool isEmpty = queue.isEmpty();
+            Console.WriteLine("队列是否为空 = " + isEmpty);
+        }
+    }
+}

codes/csharp/chapter_stack_and_queue/linkedlist_stack.cs

@@ -0,0 +1,113 @@
+/**
+ * File: linkedlist_stack.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_stack_and_queue
+{
+    class LinkedListStack
+    {
+        private ListNode? stackPeek;  // 将头结点作为栈顶
+        private int stkSize = 0;   // 栈的长度
+
+        public LinkedListStack()
+        {
+            stackPeek = null;
+        }
+
+        /* 获取栈的长度 */
+        public int size()
+        {
+            return stkSize;
+        }
+
+        /* 判断栈是否为空 */
+        public bool isEmpty()
+        {
+            return size() == 0;
+        }
+
+        /* 入栈 */
+        public void push(int num)
+        {
+            ListNode node = new ListNode(num);
+            node.next = stackPeek;
+            stackPeek = node;
+            stkSize++;
+        }
+
+        /* 出栈 */
+        public int pop()
+        {
+            if (stackPeek == null)
+                throw new Exception();
+
+            int num = peek();
+            stackPeek = stackPeek.next;
+            stkSize--;
+            return num;
+        }
+
+        /* 访问栈顶元素 */
+        public int peek()
+        {
+            if (size() == 0 || stackPeek==null)
+                throw new Exception();
+            return stackPeek.val;
+        }
+
+        /* 将 List 转化为 Array 并返回 */
+        public int[] toArray()
+        {
+            if (stackPeek == null)
+                return Array.Empty<int>();
+
+            ListNode node = stackPeek;
+            int[] res = new int[size()];
+            for (int i = res.Length - 1; i >= 0; i--)
+            {
+                res[i] = node.val;
+                node = node.next;
+            }
+            return res;
+        }
+    }
+
+    public class linkedlist_stack
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化栈 */
+            LinkedListStack stack = new LinkedListStack();
+
+            /* 元素入栈 */
+            stack.push(1);
+            stack.push(3);
+            stack.push(2);
+            stack.push(5);
+            stack.push(4);
+            Console.WriteLine("栈 stack = " + String.Join(",",stack.toArray()));
+
+            /* 访问栈顶元素 */
+            int peek = stack.peek();
+            Console.WriteLine("栈顶元素 peek = " + peek);
+
+            /* 元素出栈 */
+            int pop = stack.pop();
+            Console.WriteLine("出栈元素 pop = " + pop + "，出栈后 stack = " + String.Join(",",stack.toArray()));
+
+            /* 获取栈的长度 */
+            int size = stack.size();
+            Console.WriteLine("栈的长度 size = " + size);
+
+            /* 判断是否为空 */
+            bool isEmpty = stack.isEmpty();
+            Console.WriteLine("栈是否为空 = " + isEmpty);
+        }
+    }
+}

codes/csharp/chapter_stack_and_queue/queue.cs

@@ -0,0 +1,45 @@
+/**
+ * File: queue.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_stack_and_queue
+{
+    public class queue
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化队列 */
+            Queue<int> queue = new();
+
+            /* 元素入队 */
+            queue.Enqueue(1);
+            queue.Enqueue(3);
+            queue.Enqueue(2);
+            queue.Enqueue(5);
+            queue.Enqueue(4);
+            Console.WriteLine("队列 queue = " + String.Join(",", queue.ToArray()));
+
+            /* 访问队首元素 */
+            int peek = queue.Peek();
+            Console.WriteLine("队首元素 peek = " + peek);
+
+            /* 元素出队 */
+            int poll = queue.Dequeue();
+            Console.WriteLine("出队元素 poll = " + poll + "，出队后 queue = " + String.Join(",", queue.ToArray()));
+
+            /* 获取队列的长度 */
+            int size = queue.Count();
+            Console.WriteLine("队列长度 size = " + size);
+
+            /* 判断队列是否为空 */
+            bool isEmpty = queue.Count() == 0;
+            Console.WriteLine("队列是否为空 = " + isEmpty);
+        }
+    }
+
+}

codes/csharp/chapter_stack_and_queue/stack.cs

@@ -0,0 +1,45 @@
+/**
+ * File: stack.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using NUnit.Framework;
+
+namespace hello_algo.chapter_stack_and_queue
+{
+    public class stack
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化栈 */
+            Stack<int> stack = new();
+
+            /* 元素入栈 */
+            stack.Push(1);
+            stack.Push(3);
+            stack.Push(2);
+            stack.Push(5);
+            stack.Push(4);
+            // 请注意，stack.ToArray() 得到的是倒序序列，即索引 0 为栈顶
+            Console.WriteLine("栈 stack = " + string.Join(",", stack.ToArray()));
+
+            /* 访问栈顶元素 */
+            int peek = stack.Peek();
+            Console.WriteLine("栈顶元素 peek = " + peek);
+
+            /* 元素出栈 */
+            int pop = stack.Pop();
+            Console.WriteLine("出栈元素 pop = " + pop + "，出栈后 stack = " + string.Join(",", stack.ToArray()));
+
+            /* 获取栈的长度 */
+            int size = stack.Count();
+            Console.WriteLine("栈的长度 size = " + size);
+
+            /* 判断是否为空 */
+            bool isEmpty = stack.Count() == 0;
+            Console.WriteLine("栈是否为空 = " + isEmpty);
+        }
+    }
+}

codes/csharp/chapter_tree/avl_tree.cs

@@ -0,0 +1,260 @@
+/**
+ * File: avl_tree.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_tree
+{
+    // Tree class
+    class AVLTree
+    {
+        public TreeNode? root; // 根节点
+
+        /* 获取结点高度 */
+        public int height(TreeNode? node)
+        {
+            // 空结点高度为 -1 ，叶结点高度为 0
+            return node == null ? -1 : node.height;
+        }
+
+        /* 更新结点高度 */
+        private void updateHeight(TreeNode node)
+        {
+            // 结点高度等于最高子树高度 + 1
+            node.height = Math.Max(height(node.left), height(node.right)) + 1;
+        }
+
+        /* 获取平衡因子 */
+        public int balanceFactor(TreeNode? node)
+        {
+            // 空结点平衡因子为 0
+            if (node == null) return 0;
+            // 结点平衡因子 = 左子树高度 - 右子树高度
+            return height(node.left) - height(node.right);
+        }
+
+        /* 右旋操作 */
+        TreeNode? rightRotate(TreeNode? node)
+        {
+            TreeNode? child = node.left;
+            TreeNode? grandChild = child?.right;
+            // 以 child 为原点，将 node 向右旋转
+            child.right = node;
+            node.left = grandChild;
+            // 更新结点高度
+            updateHeight(node);
+            updateHeight(child);
+            // 返回旋转后子树的根节点
+            return child;
+        }
+
+        /* 左旋操作 */
+        TreeNode? leftRotate(TreeNode? node)
+        {
+            TreeNode? child = node.right;
+            TreeNode? grandChild = child?.left;
+            // 以 child 为原点，将 node 向左旋转
+            child.left = node;
+            node.right = grandChild;
+            // 更新结点高度
+            updateHeight(node);
+            updateHeight(child);
+            // 返回旋转后子树的根节点
+            return child;
+        }
+
+        /* 执行旋转操作，使该子树重新恢复平衡 */
+        TreeNode? rotate(TreeNode? node)
+        {
+            // 获取结点 node 的平衡因子
+            int balanceFactorInt = balanceFactor(node);
+            // 左偏树
+            if (balanceFactorInt > 1)
+            {
+                if (balanceFactor(node.left) >= 0)
+                {
+                    // 右旋
+                    return rightRotate(node);
+                }
+                else
+                {
+                    // 先左旋后右旋
+                    node.left = leftRotate(node?.left);
+                    return rightRotate(node);
+                }
+            }
+            // 右偏树
+            if (balanceFactorInt < -1)
+            {
+                if (balanceFactor(node.right) <= 0)
+                {
+                    // 左旋
+                    return leftRotate(node);
+                }
+                else
+                {
+                    // 先右旋后左旋
+                    node.right = rightRotate(node?.right);
+                    return leftRotate(node);
+                }
+            }
+            // 平衡树，无需旋转，直接返回
+            return node;
+        }
+
+        /* 插入结点 */
+        public TreeNode? insert(int val)
+        {
+            root = insertHelper(root, val);
+            return root;
+        }
+
+        /* 递归插入结点（辅助函数） */
+        private TreeNode? insertHelper(TreeNode? node, int val)
+        {
+            if (node == null) return new TreeNode(val);
+            /* 1. 查找插入位置，并插入结点 */
+            if (val < node.val)
+                node.left = insertHelper(node.left, val);
+            else if (val > node.val)
+                node.right = insertHelper(node.right, val);
+            else
+                return node;     // 重复结点不插入，直接返回
+            updateHeight(node);  // 更新结点高度
+            /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+            node = rotate(node);
+            // 返回子树的根节点
+            return node;
+        }
+
+        /* 删除结点 */
+        public TreeNode? remove(int val)
+        {
+            root = removeHelper(root, val);
+            return root;
+        }
+
+        /* 递归删除结点（辅助函数） */
+        private TreeNode? removeHelper(TreeNode? node, int val)
+        {
+            if (node == null) return null;
+            /* 1. 查找结点，并删除之 */
+            if (val < node.val)
+                node.left = removeHelper(node.left, val);
+            else if (val > node.val)
+                node.right = removeHelper(node.right, val);
+            else
+            {
+                if (node.left == null || node.right == null)
+                {
+                    TreeNode? child = node.left != null ? node.left : node.right;
+                    // 子结点数量 = 0 ，直接删除 node 并返回
+                    if (child == null)
+                        return null;
+                    // 子结点数量 = 1 ，直接删除 node
+                    else
+                        node = child;
+                }
+                else
+                {
+                    // 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+                    TreeNode? temp = minNode(node.right);
+                    node.right = removeHelper(node.right, temp.val);
+                    node.val = temp.val;
+                }
+            }
+            updateHeight(node);  // 更新结点高度
+            /* 2. 执行旋转操作，使该子树重新恢复平衡 */
+            node = rotate(node);
+            // 返回子树的根节点
+            return node;
+        }
+
+        /* 获取最小结点 */
+        private TreeNode? minNode(TreeNode? node)
+        {
+            if (node == null) return node;
+            // 循环访问左子结点，直到叶结点时为最小结点，跳出
+            while (node.left != null)
+            {
+                node = node.left;
+            }
+            return node;
+        }
+
+        /* 查找结点 */
+        public TreeNode? search(int val)
+        {
+            TreeNode? cur = root;
+            // 循环查找，越过叶结点后跳出
+            while (cur != null)
+            {
+                // 目标结点在 root 的右子树中
+                if (cur.val < val)
+                    cur = cur.right;
+                // 目标结点在 root 的左子树中
+                else if (cur.val > val)
+                    cur = cur.left;
+                // 找到目标结点，跳出循环
+                else
+                    break;
+            }
+            // 返回目标结点
+            return cur;
+        }
+    }
+
+    public class avl_tree
+    {
+        static void testInsert(AVLTree tree, int val)
+        {
+            tree.insert(val);
+            Console.WriteLine("\n插入结点 " + val + " 后，AVL 树为");
+            PrintUtil.PrintTree(tree.root);
+        }
+
+        static void testRemove(AVLTree tree, int val)
+        {
+            tree.remove(val);
+            Console.WriteLine("\n删除结点 " + val + " 后，AVL 树为");
+            PrintUtil.PrintTree(tree.root);
+        }
+
+        [Test]
+        public void Test()
+        {
+            /* 初始化空 AVL 树 */
+            AVLTree avlTree = new AVLTree();
+
+            /* 插入结点 */
+            // 请关注插入结点后，AVL 树是如何保持平衡的
+            testInsert(avlTree, 1);
+            testInsert(avlTree, 2);
+            testInsert(avlTree, 3);
+            testInsert(avlTree, 4);
+            testInsert(avlTree, 5);
+            testInsert(avlTree, 8);
+            testInsert(avlTree, 7);
+            testInsert(avlTree, 9);
+            testInsert(avlTree, 10);
+            testInsert(avlTree, 6);
+
+            /* 插入重复结点 */
+            testInsert(avlTree, 7);
+
+            /* 删除结点 */
+            // 请关注删除结点后，AVL 树是如何保持平衡的
+            testRemove(avlTree, 8); // 删除度为 0 的结点
+            testRemove(avlTree, 5); // 删除度为 1 的结点
+            testRemove(avlTree, 4); // 删除度为 2 的结点
+
+            /* 查询结点 */
+            TreeNode? node = avlTree.search(7);
+            Console.WriteLine("\n查找到的结点对象为 " + node + "，结点值 = " + node?.val);
+        }
+    }
+}

codes/csharp/chapter_tree/binary_search_tree.cs

@@ -0,0 +1,186 @@
+/**
+ * File: binary_search_tree.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_tree
+{
+    class BinarySearchTree
+    {
+        TreeNode? root;
+
+        public BinarySearchTree(int[] nums) {
+            Array.Sort(nums); // 排序数组
+            root = buildTree(nums, 0, nums.Length - 1);  // 构建二叉搜索树
+        }
+
+        /* 获取二叉树根结点 */
+        public TreeNode? getRoot() {
+            return root;
+        }
+
+        /* 构建二叉搜索树 */
+        public TreeNode? buildTree(int[] nums, int i, int j) {
+            if (i > j) return null;
+            // 将数组中间结点作为根结点
+            int mid = (i + j) / 2;
+            TreeNode root = new TreeNode(nums[mid]);
+            // 递归建立左子树和右子树
+            root.left = buildTree(nums, i, mid - 1);
+            root.right = buildTree(nums, mid + 1, j);
+            return root;
+        }
+
+        /// <summary>
+        /// 查找结点
+        /// </summary>
+        /// <param name="num"></param>
+        /// <returns></returns>
+        public TreeNode? search(int num)
+        {
+            TreeNode? cur = root;
+            // 循环查找，越过叶结点后跳出
+            while (cur != null)
+            {
+                // 目标结点在 root 的右子树中
+                if (cur.val < num) cur = cur.right;
+                // 目标结点在 root 的左子树中
+                else if (cur.val > num) cur = cur.left;
+                // 找到目标结点，跳出循环
+                else break;
+            }
+            // 返回目标结点
+            return cur;
+        }
+
+        /* 插入结点 */
+        public TreeNode? insert(int num)
+        {
+            // 若树为空，直接提前返回
+            if (root == null) return null;
+            TreeNode? cur = root, pre = null;
+            // 循环查找，越过叶结点后跳出
+            while (cur != null)
+            {
+                // 找到重复结点，直接返回
+                if (cur.val == num) return null;
+                pre = cur;
+                // 插入位置在 root 的右子树中
+                if (cur.val < num) cur = cur.right;
+                // 插入位置在 root 的左子树中
+                else cur = cur.left;
+            }
+
+            // 插入结点 val
+            TreeNode node = new TreeNode(num);
+            if (pre != null)
+            {
+                if (pre.val < num) pre.right = node;
+                else pre.left = node;
+            }
+            return node;
+        }
+
+
+        /* 删除结点 */
+        public TreeNode? remove(int num)
+        {
+            // 若树为空，直接提前返回
+            if (root == null) return null;
+            TreeNode? cur = root, pre = null;
+            // 循环查找，越过叶结点后跳出
+            while (cur != null)
+            {
+                // 找到待删除结点，跳出循环
+                if (cur.val == num) break;
+                pre = cur;
+                // 待删除结点在 root 的右子树中
+                if (cur.val < num) cur = cur.right;
+                // 待删除结点在 root 的左子树中
+                else cur = cur.left;
+            }
+            // 若无待删除结点，则直接返回
+            if (cur == null || pre == null) return null;
+            // 子结点数量 = 0 or 1
+            if (cur.left == null || cur.right == null)
+            {
+                // 当子结点数量 = 0 / 1 时， child = null / 该子结点
+                TreeNode? child = cur.left != null ? cur.left : cur.right;
+                // 删除结点 cur
+                if (pre.left == cur)
+                {
+                    pre.left = child;
+                }
+                else
+                {
+                    pre.right = child;
+                }
+
+            }
+            // 子结点数量 = 2
+            else
+            {
+                // 获取中序遍历中 cur 的下一个结点
+                TreeNode? nex = min(cur.right);
+                if (nex != null)
+                {
+                    int tmp = nex.val;
+                    // 递归删除结点 nex
+                    remove(nex.val);
+                    // 将 nex 的值复制给 cur
+                    cur.val = tmp;
+                }
+            }
+            return cur;
+        }
+
+        /* 获取最小结点 */
+        private TreeNode? min(TreeNode? root)
+        {
+            if (root == null) return root;
+            // 循环访问左子结点，直到叶结点时为最小结点，跳出
+            while (root.left != null)
+            {
+                root = root.left;
+            }
+            return root;
+        }
+    }
+
+    public class binary_search_tree
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化二叉搜索树 */
+            int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+            BinarySearchTree bst = new BinarySearchTree(nums);
+            Console.WriteLine("\n初始化的二叉树为\n");
+            PrintUtil.PrintTree(bst.getRoot());
+
+            /* 查找结点 */
+            TreeNode? node = bst.search(5);
+            Console.WriteLine("\n查找到的结点对象为 " + node + "，结点值 = " + node.val);
+
+            /* 插入结点 */
+            node = bst.insert(16);
+            Console.WriteLine("\n插入结点 16 后，二叉树为\n");
+            PrintUtil.PrintTree(bst.getRoot());
+
+            /* 删除结点 */
+            bst.remove(1);
+            Console.WriteLine("\n删除结点 1 后，二叉树为\n");
+            PrintUtil.PrintTree(bst.getRoot());
+            bst.remove(2);
+            Console.WriteLine("\n删除结点 2 后，二叉树为\n");
+            PrintUtil.PrintTree(bst.getRoot());
+            bst.remove(4);
+            Console.WriteLine("\n删除结点 4 后，二叉树为\n");
+            PrintUtil.PrintTree(bst.getRoot());
+        }
+    }
+}

codes/csharp/chapter_tree/binary_tree.cs

@@ -0,0 +1,46 @@
+/**
+ * File: binary_tree.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_tree
+{
+
+    public class binary_tree
+    {
+        [Test]
+        public void Test()
+        {
+            /* 初始化二叉树 */
+            // 初始化结点
+            TreeNode n1 = new TreeNode(1);
+            TreeNode n2 = new TreeNode(2);
+            TreeNode n3 = new TreeNode(3);
+            TreeNode n4 = new TreeNode(4);
+            TreeNode n5 = new TreeNode(5);
+            // 构建引用指向（即指针）
+            n1.left = n2;
+            n1.right = n3;
+            n2.left = n4;
+            n2.right = n5;
+            Console.WriteLine("\n初始化二叉树\n");
+            PrintUtil.PrintTree(n1);
+
+            /* 插入与删除结点 */
+            TreeNode P = new TreeNode(0);
+            // 在 n1 -> n2 中间插入结点 P
+            n1.left = P;
+            P.left = n2;
+            Console.WriteLine("\n插入结点 P 后\n");
+            PrintUtil.PrintTree(n1);
+            // 删除结点 P
+            n1.left = n2;
+            Console.WriteLine("\n删除结点 P 后\n");
+            PrintUtil.PrintTree(n1);
+        }
+    }
+}

codes/csharp/chapter_tree/binary_tree_bfs.cs

@@ -0,0 +1,53 @@
+/**
+ * File: binary_tree_bfs.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_tree
+{
+    public class binary_tree_bfs
+    {
+
+        /// <summary>
+        /// 层序遍历
+        /// </summary>
+        /// <param name="root"></param>
+        /// <returns></returns>
+        public List<int> hierOrder(TreeNode root)
+        {
+            // 初始化队列，加入根结点
+            Queue<TreeNode> queue = new();
+            queue.Enqueue(root);
+            // 初始化一个列表，用于保存遍历序列
+            List<int> list = new();
+            while (queue.Count != 0)
+            {
+                TreeNode node = queue.Dequeue(); // 队列出队
+                list.Add(node.val);              // 保存结点值
+                if (node.left != null)
+                    queue.Enqueue(node.left);    // 左子结点入队
+                if (node.right != null)
+                    queue.Enqueue(node.right);   // 右子结点入队
+            }
+            return list;
+        }
+
+        [Test]
+        public void Test()
+        {
+            /* 初始化二叉树 */
+            // 这里借助了一个从数组直接生成二叉树的函数
+            TreeNode? root = TreeNode.ArrToTree(new int?[] { 
+                1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null});
+            Console.WriteLine("\n初始化二叉树\n");
+            PrintUtil.PrintTree(root);
+
+            List<int> list = hierOrder(root);
+            Console.WriteLine("\n层序遍历的结点打印序列 = " + string.Join(",", list.ToArray()));
+        }
+    }
+}

codes/csharp/chapter_tree/binary_tree_dfs.cs

@@ -0,0 +1,78 @@
+/**
+ * File: binary_tree_bfs.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+using hello_algo.include;
+using NUnit.Framework;
+
+namespace hello_algo.chapter_tree
+{
+    public class binary_tree_dfs
+    {
+        List<int> list = new();
+
+        /// <summary>
+        /// 前序遍历
+        /// </summary>
+        /// <param name="root"></param>
+        void preOrder(TreeNode? root)
+        {
+            if (root == null) return;
+            // 访问优先级：根结点 -> 左子树 -> 右子树
+            list.Add(root.val);
+            preOrder(root.left);
+            preOrder(root.right);
+        }
+
+        /// <summary>
+        /// 中序遍历
+        /// </summary>
+        /// <param name="root"></param>
+        void inOrder(TreeNode? root)
+        {
+            if (root == null) return;
+            // 访问优先级：左子树 -> 根结点 -> 右子树
+            inOrder(root.left);
+            list.Add(root.val);
+            inOrder(root.right);
+        }
+
+        /// <summary>
+        /// 后序遍历
+        /// </summary>
+        /// <param name="root"></param>
+        void postOrder(TreeNode? root)
+        {
+            if (root == null) return;
+            // 访问优先级：左子树 -> 右子树 -> 根结点
+            postOrder(root.left);
+            postOrder(root.right);
+            list.Add(root.val);
+        }
+
+        [Test]
+        public void Test()
+        {
+            /* 初始化二叉树 */
+            // 这里借助了一个从数组直接生成二叉树的函数
+            TreeNode? root = TreeNode.ArrToTree(new int?[] { 
+                1, 2, 3, 4, 5, 6, 7, null, null, null, null, null, null, null, null});
+            Console.WriteLine("\n初始化二叉树\n");
+            PrintUtil.PrintTree(root);
+
+            list.Clear();
+            preOrder(root);
+            Console.WriteLine("\n前序遍历的结点打印序列 = " + string.Join(",", list.ToArray()));
+
+            list.Clear();
+            inOrder(root);
+            Console.WriteLine("\n中序遍历的结点打印序列 = " + string.Join(",", list.ToArray()));
+
+            list.Clear();
+            postOrder(root);
+            Console.WriteLine("\n后序遍历的结点打印序列 = " + string.Join(",", list.ToArray()));
+        }
+    }
+}

codes/csharp/include/ListNode.cs

@@ -10,7 +10,7 @@ namespace hello_algo.include
     public class ListNode
     {
         public int val;
-        public ListNode next;
+        public ListNode? next;
 
         /// <summary>
         /// Generate a linked list with an array
@@ -26,7 +26,7 @@ namespace hello_algo.include
         /// </summary>
         /// <param name="arr"></param>
         /// <returns></returns>
-        public static ListNode ArrToLinkedList(int[] arr)
+        public static ListNode? ArrToLinkedList(int[] arr)
         {
             ListNode dum = new ListNode(0);
             ListNode head = dum;
@@ -44,7 +44,7 @@ namespace hello_algo.include
         /// <param name="head"></param>
         /// <param name="val"></param>
         /// <returns></returns>
-        public static ListNode GetListNode(ListNode head, int val)
+        public static ListNode? GetListNode(ListNode? head, int val)
         {
             while (head != null && head.val != val)
             {

codes/csharp/include/PrintUtil.cs

@@ -0,0 +1,124 @@
+/**
+ * File: PrintUtil.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.include
+{
+    public class Trunk
+    {
+        public Trunk? prev;
+        public String str;
+
+        public Trunk(Trunk? prev, String str)
+        {
+            this.prev = prev;
+            this.str = str;
+        }
+    };
+
+    public class PrintUtil
+    {
+        /**
+         * Print a linked list
+         * @param head
+         */
+        public static void PrintLinkedList(ListNode head)
+        {
+            List<String> list = new();
+            while (head != null)
+            {
+                list.Add(head.val.ToString());
+                head = head.next;
+            }
+            Console.Write(String.Join(" -> ", list));
+        }
+
+        /**
+         * The interface of the tree printer
+         * This tree printer is borrowed from TECHIE DELIGHT
+         * https://www.techiedelight.com/c-program-print-binary-tree/
+         * @param root
+         */
+        public static void PrintTree(TreeNode? root)
+        {
+            PrintTree(root, null, false);
+        }
+
+        /**
+         * Print a binary tree
+         * @param root
+         * @param prev
+         * @param isLeft
+         */
+        public static void PrintTree(TreeNode? root, Trunk? prev, bool isLeft)
+        {
+            if (root == null)
+            {
+                return;
+            }
+
+            String prev_str = "    ";
+            Trunk trunk = new Trunk(prev, prev_str);
+
+            PrintTree(root.right, trunk, true);
+
+            if (prev == null)
+            {
+                trunk.str = "———";
+            }
+            else if (isLeft)
+            {
+                trunk.str = "/———";
+                prev_str = "   |";
+            }
+            else
+            {
+                trunk.str = "\\———";
+                prev.str = prev_str;
+            }
+
+            showTrunks(trunk);
+            Console.WriteLine(" " + root.val);
+
+            if (prev != null)
+            {
+                prev.str = prev_str;
+            }
+            trunk.str = "   |";
+
+            PrintTree(root.left, trunk, false);
+        }
+
+        /**
+         * Helper function to print branches of the binary tree
+         * @param p
+         */
+        public static void showTrunks(Trunk? p)
+        {
+            if (p == null)
+            {
+                return;
+            }
+
+            showTrunks(p.prev);
+            Console.Write(p.str);
+        }
+
+        /**
+         * Print a hash map
+         * @param <K>
+         * @param <V>
+         * @param map
+         */
+        public static void printHashMap<K, V>(Dictionary<K, V> map) where K : notnull
+        {
+            foreach (var kv in map.Keys)
+            {
+                Console.WriteLine(kv.ToString() + " -> " + map[kv]?.ToString());
+            }
+        }
+    }
+
+}

codes/csharp/include/TreeNode.cs

@@ -0,0 +1,98 @@
+/**
+ * File: TreeNode.cs
+ * Created Time: 2022-12-23
+ * Author: haptear (haptear@hotmail.com)
+ */
+
+namespace hello_algo.include
+{
+    public class TreeNode
+    {
+        public int val;        // 结点值
+        public int height;     // 结点高度
+        public TreeNode? left;  // 左子结点引用
+        public TreeNode? right; // 右子结点引用
+
+        public TreeNode(int x)
+        {
+            val = x;
+        }
+
+        /**
+         * Generate a binary tree with an array
+         * @param arr
+         * @return
+         */
+        public static TreeNode? ArrToTree(int?[] arr)
+        {
+            if (arr.Length == 0 || arr[0] == null)
+                return null;
+
+            TreeNode root = new TreeNode((int) arr[0]);
+            Queue<TreeNode> queue = new Queue<TreeNode>();
+            queue.Enqueue(root);
+            int i = 1;
+            while (queue.Count!=0)
+            {
+                TreeNode node = queue.Dequeue();
+                if (arr[i] != null)
+                {
+                    node.left = new TreeNode((int) arr[i]);
+                    queue.Enqueue(node.left);
+                }
+                i++;
+                if (arr[i] != null)
+                {
+                    node.right = new TreeNode((int) arr[i]);
+                    queue.Enqueue(node.right);
+                }
+                i++;
+            }
+            return root;
+        }
+
+        /**
+         * Serialize a binary tree to a list
+         * @param root
+         * @return
+         */
+        public static List<int?> TreeToList(TreeNode root)
+        {
+            List<int?> list = new();
+            if (root == null) return list;
+            Queue<TreeNode?> queue = new();
+            while (queue.Count != 0)
+            {
+                TreeNode? node = queue.Dequeue();
+                if (node != null)
+                {
+                    list.Add(node.val);
+                    queue.Enqueue(node.left);
+                    queue.Enqueue(node.right);
+                }
+                else
+                {
+                    list.Add(null);
+                }
+            }
+            return list;
+        }
+
+        /**
+         * Get a tree node with specific value in a binary tree
+         * @param root
+         * @param val
+         * @return
+         */
+        public static TreeNode? GetTreeNode(TreeNode? root, int val)
+        {
+            if (root == null)
+                return null;
+            if (root.val == val)
+                return root;
+            TreeNode? left = GetTreeNode(root.left, val);
+            TreeNode? right = GetTreeNode(root.right, val);
+            return left != null ? left : right;
+        }
+    }
+}

codes/go/chapter_array_and_linkedlist/my_list.go

@@ -79,16 +79,19 @@ func (l *MyList) insert(num, index int) {
 }
 
 /* 删除元素 */
-func (l *MyList) remove(index int) {
+func (l *MyList) remove(index int) int {
 	if index >= l.numsSize {
 		panic("索引越界")
 	}
+	num := l.nums[index]
 	// 索引 i 之后的元素都向前移动一位
 	for j := index; j < l.numsSize-1; j++ {
 		l.nums[j] = l.nums[j+1]
 	}
 	// 更新元素数量
 	l.numsSize--
+	// 返回被删除元素
+	return num
 }
 
 /* 列表扩容 */
@@ -103,4 +106,4 @@ func (l *MyList) extendCapacity() {
 func (l *MyList) toArray() []int {
 	// 仅转换有效长度范围内的列表元素
 	return l.nums[:l.numsSize]
-}
+}

codes/go/chapter_computational_complexity/space_complexity.go

@@ -42,7 +42,7 @@ func printTree(root *TreeNode) {
 	printTree(root.right)
 }
 
-/* 函数（或称方法）*/
+/* 函数 */
 func function() int {
 	// do something...
 	return 0

codes/go/chapter_sorting/merge_sort/merge_sort.go

@@ -21,15 +21,15 @@ func merge(nums []int, left, mid, right int) {
 	i, j := left_start, right_start
 	// 通过覆盖原数组 nums 来合并左子数组和右子数组
 	for k := left; k <= right; k++ {
-		// 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+		// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
 		if i > left_end {
 			nums[k] = tmp[j]
 			j++
-			// 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+			// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
 		} else if j > right_end || tmp[i] <= tmp[j] {
 			nums[k] = tmp[i]
 			i++
-			// 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+			// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
 		} else {
 			nums[k] = tmp[j]
 			j++

codes/java/chapter_sorting/merge_sort.java

@@ -25,13 +25,13 @@ public class merge_sort {
         int i = leftStart, j = rightStart;                
         // 通过覆盖原数组 nums 来合并左子数组和右子数组
         for (int k = left; k <= right; k++) {
-            // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
             if (i > leftEnd)
                 nums[k] = tmp[j++];
-            // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
             else if (j > rightEnd || tmp[i] <= tmp[j])
                 nums[k] = tmp[i++];
-            // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
             else
                 nums[k] = tmp[j++];
         }

codes/java/chapter_stack_and_queue/array_queue.java

@@ -63,13 +63,6 @@ class ArrayQueue {
         return nums[front];
     }
 
-    /* 访问索引 index 处元素 */
-    int get(int index) {
-        if (index >= size())
-            throw new IndexOutOfBoundsException();
-        return nums[(front + index) % capacity()];
-    }
-
     /* 返回数组 */
     public int[] toArray() {
         int size = size();

codes/java/chapter_stack_and_queue/array_stack.java

@@ -45,13 +45,6 @@ class ArrayStack {
         return stack.get(size() - 1);
     }
 
-    /* 访问索引 index 处元素 */
-    public int get(int index) {
-        if (index >= size())
-            throw new IndexOutOfBoundsException();
-        return stack.get(index);
-    }
-
     /* 将 List 转化为 Array 并返回 */
     public Object[] toArray() {
         return stack.toArray();
@@ -75,10 +68,6 @@ public class array_stack {
         int peek = stack.peek();
         System.out.println("栈顶元素 peek = " + peek);
 
-        /* 访问索引 index 处元素 */
-        int num = stack.get(3);
-        System.out.println("栈索引 3 处的元素为 num = " + num);
-
         /* 元素出栈 */
         int pop = stack.pop();
         System.out.println("出栈元素 pop = " + pop + "，出栈后 stack = " + Arrays.toString(stack.toArray()));

codes/javascript/chapter_hashing/array_hash_map.js

@@ -0,0 +1,129 @@
+/*
+ * File: array_hash_map.js
+ * Created Time: 2022-12-26
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* 键值对 Number -> String */
+class Entry {
+    constructor(key, val) {
+        this.key = key;
+        this.val = val;
+    }
+}
+
+/* 基于数组简易实现的哈希表 */
+class ArrayHashMap {
+    #bucket;
+    constructor() {
+        // 初始化一个长度为 100 的桶（数组）
+        this.#bucket = new Array(100).fill(null);
+    }
+
+    /* 哈希函数 */
+    #hashFunc(key) {
+        return key % 100;
+    }
+
+    /* 查询操作 */
+    get(key) {
+        let index = this.#hashFunc(key);
+        let entry = this.#bucket[index];
+        if (entry === null) return null;
+        return entry.val;
+    }
+
+    /* 添加操作 */
+    set(key, val) {
+        let index = this.#hashFunc(key);
+        this.#bucket[index] = new Entry(key, val);
+    }
+
+    /* 删除操作 */
+    delete(key) {
+        let index = this.#hashFunc(key);
+        // 置为 null ，代表删除
+        this.#bucket[index] = null;
+    }
+
+    /* 获取所有键值对 */
+    entries() {
+        let arr = [];
+        for (let i = 0; i < this.#bucket.length; i++) {
+            if (this.#bucket[i]) {
+                arr.push(this.#bucket[i]);
+            }
+        }
+        return arr;
+    }
+
+    /* 获取所有键 */
+    keys() {
+        let arr = [];
+        for (let i = 0; i < this.#bucket.length; i++) {
+            if (this.#bucket[i]) {
+                arr.push(this.#bucket[i]?.key);
+            }
+        }
+        return arr;
+    }
+
+    /* 获取所有值 */
+    values() {
+        let arr = [];
+        for (let i = 0; i < this.#bucket.length; i++) {
+            if (this.#bucket[i]) {
+                arr.push(this.#bucket[i]?.val);
+            }
+        }
+        return arr;
+    }
+
+    /* 打印哈希表 */
+    print() {
+        let entrySet = this.entries();
+        for (const entry of entrySet) {
+            if (!entry) continue;
+            console.info(`${entry.key} -> ${entry.val}`);
+        }
+    }
+}
+
+/* Driver Code */
+/* 初始化哈希表 */
+const map = new ArrayHashMap();
+/* 添加操作 */
+// 在哈希表中添加键值对 (key, value)
+map.set(12836, '小哈');
+map.set(15937, '小啰');
+map.set(16750, '小算');
+map.set(13276, '小法');
+map.set(10583, '小鸭');
+console.info('\n添加完成后，哈希表为\nKey -> Value');
+map.print();
+
+/* 查询操作 */
+// 向哈希表输入键 key ，得到值 value
+let name = map.get(15937);
+console.info('\n输入学号 15937 ，查询到姓名 ' + name);
+
+/* 删除操作 */
+// 在哈希表中删除键值对 (key, value)
+map.delete(10583);
+console.info('\n删除 10583 后，哈希表为\nKey -> Value');
+map.print();
+
+/* 遍历哈希表 */
+console.info('\n遍历键值对 Key->Value');
+for (const entry of map.entries()) {
+    if (!entry) continue;
+    console.info(entry.key + ' -> ' + entry.val);
+}
+console.info('\n单独遍历键 Key');
+for (const key of map.keys()) {
+    console.info(key);
+}
+console.info('\n单独遍历值 Value');
+for (const val of map.values()) {
+    console.info(val);
+}

codes/javascript/chapter_hashing/hash_map.js

@@ -0,0 +1,44 @@
+/*
+ * File: hash_map.js
+ * Created Time: 2022-12-26
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+/* Driver Code */
+/* 初始化哈希表 */
+const map = new Map();
+
+/* 添加操作 */
+// 在哈希表中添加键值对 (key, value)
+map.set(12836, '小哈');
+map.set(15937, '小啰');
+map.set(16750, '小算');
+map.set(13276, '小法');
+map.set(10583, '小鸭');
+console.info('\n添加完成后，哈希表为\nKey -> Value');
+console.info(map);
+
+/* 查询操作 */
+// 向哈希表输入键 key ，得到值 value
+let name = map.get(15937);
+console.info('\n输入学号 15937 ，查询到姓名 ' + name);
+
+/* 删除操作 */
+// 在哈希表中删除键值对 (key, value)
+map.delete(10583);
+console.info('\n删除 10583 后，哈希表为\nKey -> Value');
+console.info(map);
+
+/* 遍历哈希表 */
+console.info('\n遍历键值对 Key->Value');
+for (const [k, v] of map.entries()) {
+    console.info(k + ' -> ' + v);
+}
+console.info('\n单独遍历键 Key');
+for (const k of map.keys()) {
+    console.info(k);
+}
+console.info('\n单独遍历值 Value');
+for (const v of map.values()) {
+    console.info(v);
+}

codes/javascript/chapter_searching/binary_search.js

@@ -0,0 +1,53 @@
+/**
+ * File: binary_search.js
+ * Created Time: 2022-12-22
+ * Author: JoseHung (szhong@link.cuhk.edu.hk)
+ */
+
+/* 二分查找（双闭区间） */
+function binarySearch(nums, target) {
+    // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+    let i = 0, j = nums.length - 1;
+    // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+    while (i <= j) {
+        let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
+        if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j] 中
+            i = m + 1;
+        else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m-1] 中
+            j = m - 1;
+        else
+            return m;                  // 找到目标元素，返回其索引
+    }
+    // 未找到目标元素，返回 -1
+    return -1;
+}
+
+/* 二分查找（左闭右开） */
+function binarySearch1(nums, target) {
+    // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+    let i = 0, j = nums.length;
+    // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+    while (i < j) {
+        let m = parseInt((i + j) / 2); // 计算中点索引 m ，在 JS 中需使用 parseInt 函数取整
+        if (nums[m] < target)          // 此情况说明 target 在区间 [m+1, j) 中
+            i = m + 1;
+        else if (nums[m] > target)     // 此情况说明 target 在区间 [i, m) 中
+            j = m;
+        else                           // 找到目标元素，返回其索引
+            return m;
+    }
+    // 未找到目标元素，返回 -1
+    return -1;
+}
+
+/* Driver Code */
+var target = 6;
+var nums = [1, 3, 6, 8, 12, 15, 23, 67, 70, 92];
+
+/* 二分查找（双闭区间） */
+var index = binarySearch(nums, target);
+console.log("目标元素 6 的索引 = " + index);
+
+/* 二分查找（左闭右开） */
+index = binarySearch1(nums, target);
+console.log("目标元素 6 的索引 = " + index);

codes/javascript/chapter_searching/linear_search.js

@@ -0,0 +1,48 @@
+/**
+ * File: linear-search.js
+ * Created Time: 2022-12-22
+ * Author: JoseHung (szhong@link.cuhk.edu.hk)
+ */
+
+const ListNode = require("../include/ListNode");
+
+/* 线性查找（数组） */
+function linearSearchArray(nums, target) {
+    // 遍历数组
+    for (let i = 0; i < nums.length; i++) {
+        // 找到目标元素，返回其索引
+        if (nums[i] === target) {
+            return i;
+        }
+    }
+    // 未找到目标元素，返回 -1
+    return -1; 
+}
+
+/* 线性查找（链表）*/
+function linearSearchLinkedList(head, target) {
+    // 遍历链表
+    while(head) {
+        // 找到目标结点，返回之
+        if(head.val === target) {
+            return head;
+        }
+        head = head.next;
+    }
+    // 未找到目标结点，返回 null
+    return null;
+}
+
+/* Driver Code */
+var target = 3;
+
+/* 在数组中执行线性查找 */
+var nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
+var index = linearSearchArray(nums, target);
+console.log("目标元素 3 的索引 = " + index);
+
+/* 在链表中执行线性查找 */
+var linkedList = new ListNode();
+var head = linkedList.arrToLinkedList(nums);
+var node = linearSearchLinkedList(head, target);
+console.log("目标结点值 3 的对应结点对象为 " + node);

codes/javascript/chapter_sorting/merge_sort.js

@@ -20,13 +20,13 @@ function merge(nums, left, mid, right) {
     let i = leftStart, j = rightStart;                
     // 通过覆盖原数组 nums 来合并左子数组和右子数组
     for (let k = left; k <= right; k++) {
-        // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+        // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
         if (i > leftEnd) {
             nums[k] = tmp[j++];
-        // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+        // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
         } else if (j > rightEnd || tmp[i] <= tmp[j]) {
             nums[k] = tmp[i++];
-        // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
         } else {
             nums[k] = tmp[j++];
         }

codes/javascript/chapter_stack_and_queue/array_queue.js

@@ -56,13 +56,6 @@ class ArrayQueue {
         return this.#queue[this.#front];
     }
 
-    /* 访问指定索引元素 */
-    get(index) {
-        if (index >= this.size)
-            throw new Error("索引越界");
-        return this.#queue[(this.#front + index) % this.capacity];
-    }
-
     /* 返回 Array */
     toArray() {
         const siz = this.size;
@@ -95,10 +88,6 @@ console.log(queue.toArray());
 const peek = queue.peek();
 console.log("队首元素 peek = " + peek);
 
-/* 访问指定索引元素 */
-const num = queue.get(2);
-console.log("队列第 3 个元素为 num = " + num);
-
 /* 元素出队 */
 const poll = queue.poll();
 console.log("出队元素 poll = " + poll + "，出队后 queue = ");

codes/javascript/chapter_stack_and_queue/array_stack.js

@@ -41,13 +41,6 @@ class ArrayStack {
         return this.stack[this.stack.length - 1];
     }
 
-    /* 访问索引 index 处元素 */
-    get(index) {
-        if (index >= this.size)
-            throw new Error("索引越界");
-        return this.stack[index];
-    }
-
     /* 返回 Array */
     toArray() {
         return this.stack;
@@ -73,10 +66,6 @@ console.log(stack.toArray());
 const top = stack.top();
 console.log("栈顶元素 top = " + top);
 
-/* 访问索引 index 处元素 */
-const num = stack.get(3);
-console.log("栈索引 3 处的元素为 num = " + num);
-
 /* 元素出栈 */
 const pop = stack.pop();
 console.log("出栈元素 pop = " + pop + "，出栈后 stack = ");

codes/javascript/chapter_stack_and_queue/linkedlist_stack.js

@@ -0,0 +1,89 @@
+/**
+ * File: linkedlist_stack.js
+ * Created Time: 2022-12-22
+ * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
+ */
+
+const ListNode = require("../include/ListNode");
+
+/* 基于链表实现的栈 */
+class LinkedListStack {
+    #stackPeek;     // 将头结点作为栈顶
+    #stkSize = 0;   // 栈的长度
+
+    constructor() {
+        this.#stackPeek = null;
+    }
+
+    /* 获取栈的长度 */
+    get size() {
+        return this.#stkSize;
+    }
+
+    /* 判断栈是否为空 */
+    isEmpty() {
+        return this.size == 0;
+    }
+
+    /* 入栈 */
+    push(num) {
+        const node = new ListNode(num);
+        node.next = this.#stackPeek;
+        this.#stackPeek = node;
+        this.#stkSize++;
+    }
+
+    /* 出栈 */
+    pop() {
+        const num = this.peek();
+        this.#stackPeek = this.#stackPeek.next;
+        this.#stkSize--;
+        return num;
+    }
+
+    /* 访问栈顶元素 */
+    peek() {
+        if (!this.#stackPeek)
+            throw new Error("栈为空！");
+        return this.#stackPeek.val;
+    }
+
+    /* 将链表转化为 Array 并返回 */
+    toArray() {
+        let node = this.#stackPeek;
+        const res = new Array(this.size);
+        for (let i = res.length - 1; i >= 0; i--) {
+            res[i] = node.val;
+            node = node.next;
+        }
+        return res;
+    }
+}
+
+
+/* 初始化栈 */
+const stack = new LinkedListStack();
+
+/* 元素入栈 */
+stack.push(1);
+stack.push(3);
+stack.push(2);
+stack.push(5);
+stack.push(4);
+console.log("栈 stack = " + stack.toArray());
+
+/* 访问栈顶元素 */
+const peek = stack.peek();
+console.log("栈顶元素 peek = " + peek);
+
+/* 元素出栈 */
+const pop = stack.pop();
+console.log("出栈元素 pop = " + pop + "，出栈后 stack = " + stack.toArray());
+
+/* 获取栈的长度 */
+const size = stack.size;
+console.log("栈的长度 size = " + size);
+
+/* 判断是否为空 */
+const isEmpty = stack.isEmpty();
+console.log("栈是否为空 = " + isEmpty);

codes/javascript/include/ListNode.js

@@ -22,7 +22,7 @@ class ListNode {
      */
     arrToLinkedList(arr) {
         const dum = new ListNode(0);
-        const head = dum;
+        let head = dum;
         for (const val of arr) {
             head.next = new ListNode(val);
             head = head.next;

codes/python/chapter_array_and_linkedlist/array.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: array.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_array_and_linkedlist/linked_list.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: linked_list.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_array_and_linkedlist/list.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: list.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_array_and_linkedlist/my_list.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: my_list.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
@@ -55,11 +55,14 @@ class MyList:
     """ 删除元素 """
     def remove(self, index):
         assert index < self.__size, "索引越界"
+        num = self.nums[index]
         # 索引 i 之后的元素都向前移动一位
         for j in range(index, self.__size - 1):
             self.__nums[j] = self.__nums[j + 1]
         # 更新元素数量
         self.__size -= 1
+        # 返回被删除元素
+        return num
 
     """ 列表扩容 """
     def extend_capacity(self):

codes/python/chapter_computational_complexity/leetcode_two_sum.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: leetcode_two_sum.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_computational_complexity/space_complexity.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: space_complexity.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_computational_complexity/time_complexity.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: time_complexity.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_computational_complexity/worst_best_time_complexity.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: worst_best_time_complexity.py
 Created Time: 2022-11-25
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_searching/binary_search.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: binary_search.py
 Created Time: 2022-11-26
 Author: timi (xisunyy@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_searching/hashing_search.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: hashing_search.py
 Created Time: 2022-11-26
 Author: timi (xisunyy@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_searching/linear_search.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: linear_search.py
 Created Time: 2022-11-26
 Author: timi (xisunyy@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_sorting/bubble_sort.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: bubble_sort.py
 Created Time: 2022-11-25
 Author: timi (xisunyy@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_sorting/insertion_sort.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: insertion_sort.py
 Created Time: 2022-11-25
 Author: timi (xisunyy@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_sorting/merge_sort.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: merge_sort.py
 Created Time: 2022-11-25
 Author: timi (xisunyy@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
@@ -24,15 +24,15 @@ def merge(nums, left, mid, right):
     i, j = left_start, right_start
     # 通过覆盖原数组 nums 来合并左子数组和右子数组
     for k in range(left, right + 1):
-        # 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+        # 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
         if i > left_end:
             nums[k] = tmp[j]
             j += 1
-        # 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+        # 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
         elif j > right_end or tmp[i] <= tmp[j]:
             nums[k] = tmp[i]
             i += 1
-        # 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+        # 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
         else:
             nums[k] = tmp[j]
             j += 1

codes/python/chapter_sorting/quick_sort.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: quick_sort.py
 Created Time: 2022-11-25
 Author: timi (xisunyy@163.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_stack_and_queue/array_queue.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: array_queue.py
 Created Time: 2022-12-01
 Author: Peng Chen (pengchzn@gmail.com)
-'''
+"""
 
 import os.path as osp
 import sys
@@ -54,13 +54,6 @@ class ArrayQueue:
             return False
         return self.__nums[self.__front]
 
-    """ 访问指定位置元素 """
-    def get(self, index):
-        if index >= self.size():
-            print("索引越界")
-            return False
-        return self.__nums[(self.__front + index) % self.capacity()]
-
     """ 返回列表用于打印 """
     def to_list(self):
         res = [0] * self.size()
@@ -88,10 +81,6 @@ if __name__ == "__main__":
     peek = queue.peek()
     print("队首元素 peek =", peek)
 
-    """ 访问索引 index 处元素 """
-    num = queue.get(3)
-    print("队列索引 3 处的元素为 num =", num)
-
     """ 元素出队 """
     poll = queue.poll()
     print("出队元素 poll =", poll)

codes/python/chapter_stack_and_queue/array_stack.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: array_stack.py
 Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
@@ -34,11 +34,6 @@ class ArrayStack:
     def peek(self):
         assert not self.is_empty(), "栈为空"
         return self.__stack[-1]
-
-    """ 访问索引 index 处元素 """
-    def get(self, index):
-        assert index < self.size(), "索引越界"
-        return self.__stack[index]
     
     """ 返回列表用于打印 """
     def to_list(self):
@@ -62,10 +57,6 @@ if __name__ == "__main__":
     peek = stack.peek()
     print("栈顶元素 peek =", peek)
 
-    """ 访问索引 index 处元素 """
-    num = stack.get(3)
-    print("栈索引 3 处的元素为 num =", num)
-
     """ 元素出栈 """
     pop = stack.pop()
     print("出栈元素 pop =", pop)

codes/python/chapter_stack_and_queue/deque.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: deque.py
 Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
-'''
+"""
 
 import os.path as osp
 import sys

codes/python/chapter_stack_and_queue/linkedlist_queue.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: linkedlist_queue.py
 Created Time: 2022-12-01
 Author: Peng Chen (pengchzn@gmail.com)
-'''
+"""
 
 import os.path as osp
 import sys

codes/python/chapter_stack_and_queue/linkedlist_stack.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: linkedlist_stack.py
 Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_stack_and_queue/queue.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: queue.py
 Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
-'''
+"""
 
 import os.path as osp
 import sys

codes/python/chapter_stack_and_queue/stack.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: stack.py
 Created Time: 2022-11-29
 Author: Peng Chen (pengchzn@gmail.com)
-'''
+"""
 
 import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))

codes/python/chapter_tree/avl_tree.py

@@ -0,0 +1,208 @@
+"""
+File: avl_tree.py
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
+
+import sys, os.path as osp
+import typing
+
+sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
+from include import *
+
+
+class AVLTree:
+    def __init__(self, root: typing.Optional[TreeNode] = None):
+        self.root = root
+
+    """ 获取结点高度 """
+    def height(self, node: typing.Optional[TreeNode]) -> int:
+        # 空结点高度为 -1 ，叶结点高度为 0
+        if node is not None:
+            return node.height
+        return -1
+
+    """ 更新结点高度 """
+    def __update_height(self, node: TreeNode):
+        # 结点高度等于最高子树高度 + 1
+        node.height = max([self.height(node.left), self.height(node.right)]) + 1
+
+    """ 获取平衡因子 """
+    def balance_factor(self, node: TreeNode) -> int:
+        # 空结点平衡因子为 0
+        if node is None:
+            return 0
+        # 结点平衡因子 = 左子树高度 - 右子树高度
+        return self.height(node.left) - self.height(node.right)
+
+    """ 右旋操作 """
+    def __right_rotate(self, node: TreeNode) -> TreeNode:
+        child = node.left
+        grand_child = child.right
+        # 以 child 为原点，将 node 向右旋转
+        child.right = node
+        node.left = grand_child
+        # 更新结点高度
+        self.__update_height(node)
+        self.__update_height(child)
+        # 返回旋转后子树的根节点
+        return child
+
+    """ 左旋操作 """
+    def __left_rotate(self, node: TreeNode) -> TreeNode:
+        child = node.right
+        grand_child = child.left
+        # 以 child 为原点，将 node 向左旋转
+        child.left = node
+        node.right = grand_child
+        # 更新结点高度
+        self.__update_height(node)
+        self.__update_height(child)
+        # 返回旋转后子树的根节点
+        return child
+
+    """ 执行旋转操作，使该子树重新恢复平衡 """
+    def __rotate(self, node: TreeNode) -> TreeNode:
+        # 获取结点 node 的平衡因子
+        balance_factor = self.balance_factor(node)
+        # 左偏树
+        if balance_factor > 1:
+            if self.balance_factor(node.left) >= 0:
+                # 右旋
+                return self.__right_rotate(node)
+            else:
+                # 先左旋后右旋
+                node.left = self.__left_rotate(node.left)
+                return self.__right_rotate(node)
+        # 右偏树
+        elif balance_factor < -1:
+            if self.balance_factor(node.right) <= 0:
+                # 左旋
+                return self.__left_rotate(node)
+            else:
+                # 先右旋后左旋
+                node.right = self.__right_rotate(node.right)
+                return self.__left_rotate(node)
+        # 平衡树，无需旋转，直接返回
+        return node
+
+    """ 插入结点 """
+    def insert(self, val) -> TreeNode:
+        self.root = self.__insert_helper(self.root, val)
+        return self.root
+
+    """ 递归插入结点（辅助函数）"""
+    def __insert_helper(self, node: typing.Optional[TreeNode], val: int) -> TreeNode:
+        if node is None:
+            return TreeNode(val)
+        # 1. 查找插入位置，并插入结点
+        if val < node.val:
+            node.left = self.__insert_helper(node.left, val)
+        elif val > node.val:
+            node.right = self.__insert_helper(node.right, val)
+        else:
+            # 重复结点不插入，直接返回
+            return node
+        # 更新结点高度
+        self.__update_height(node)
+        # 2. 执行旋转操作，使该子树重新恢复平衡
+        return self.__rotate(node)
+
+    """ 删除结点 """
+    def remove(self, val: int):
+        root = self.__remove_helper(self.root, val)
+        return root
+
+    """ 递归删除结点（辅助函数） """
+    def __remove_helper(self, node: typing.Optional[TreeNode], val: int) -> typing.Optional[TreeNode]:
+        if node is None:
+            return None
+        # 1. 查找结点，并删除之
+        if val < node.val:
+            node.left = self.__remove_helper(node.left, val)
+        elif val > node.val:
+            node.right = self.__remove_helper(node.right, val)
+        else:
+            if node.left is None or node.right is None:
+                child = node.left or node.right
+                # 子结点数量 = 0 ，直接删除 node 并返回
+                if child is None:
+                    return None
+                # 子结点数量 = 1 ，直接删除 node
+                else:
+                    node = child
+            else:  # 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
+                temp = self.__min_node(node.right)
+                node.right = self.__remove_helper(node.right, temp.val)
+                node.val = temp.val
+        # 更新结点高度
+        self.__update_height(node)
+        # 2. 执行旋转操作，使该子树重新恢复平衡
+        return self.__rotate(node)
+
+    """ 获取最小结点 """
+    def __min_node(self, node: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
+        if node is None:
+            return None
+        # 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while node.left is not None:
+            node = node.left
+        return node
+
+    """ 查找结点 """
+    def search(self, val: int):
+        cur = self.root
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 目标结点在 root 的右子树中
+            if cur.val < val:
+                cur = cur.right
+            # 目标结点在 root 的左子树中
+            elif cur.val > val:
+                cur = cur.left
+            # 找到目标结点，跳出循环
+            else:
+                break
+        # 返回目标结点
+        return cur
+
+
+""" Driver Code """
+if __name__ == "__main__":
+    def test_insert(tree: AVLTree, val: int):
+        tree.insert(val)
+        print("\n插入结点 {} 后，AVL 树为".format(val))
+        print_tree(tree.root)
+
+    def test_remove(tree: AVLTree, val: int):
+        tree.remove(val)
+        print("\n删除结点 {} 后，AVL 树为".format(val))
+        print_tree(tree.root)
+
+    # 初始化空 AVL 树
+    avl_tree = AVLTree()
+
+    # 插入结点
+    # 请关注插入结点后，AVL 树是如何保持平衡的
+    test_insert(avl_tree, 1)
+    test_insert(avl_tree, 2)
+    test_insert(avl_tree, 3)
+    test_insert(avl_tree, 4)
+    test_insert(avl_tree, 5)
+    test_insert(avl_tree, 8)
+    test_insert(avl_tree, 7)
+    test_insert(avl_tree, 9)
+    test_insert(avl_tree, 10)
+    test_insert(avl_tree, 6)
+
+    # 插入重复结点
+    test_insert(avl_tree, 7)
+
+    # 删除结点
+    # 请关注删除结点后，AVL 树是如何保持平衡的
+    test_remove(avl_tree, 8)  # 删除度为 0 的结点
+    test_remove(avl_tree, 5)  # 删除度为 1 的结点
+    test_remove(avl_tree, 4)  # 删除度为 2 的结点
+
+    result_node = avl_tree.search(7)
+    print("\n查找到的结点对象为 {}，结点值 = {}".format(result_node, result_node.val))

codes/python/chapter_tree/binary_search_tree.py

@@ -1,10 +1,167 @@
-'''
+"""
 File: binary_search_tree.py
-Created Time: 2022-11-25
-Author: Krahets (krahets@163.com)
-'''
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
 
 import sys, os.path as osp
+import typing
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+
+""" 二叉搜索树 """
+class BinarySearchTree:
+    def __init__(self, nums: typing.List[int]) -> None:
+        nums.sort()
+        self.__root = self.build_tree(nums, 0, len(nums) - 1)
+
+    """ 构建二叉搜索树 """
+    def build_tree(self, nums: typing.List[int], start_index: int, end_index: int) -> typing.Optional[TreeNode]:
+        if start_index > end_index:
+            return None
+
+        # 将数组中间结点作为根结点
+        mid = (start_index + end_index) // 2
+        root = TreeNode(nums[mid])
+        # 递归建立左子树和右子树
+        root.left = self.build_tree(nums=nums, start_index=start_index, end_index=mid - 1)
+        root.right = self.build_tree(nums=nums, start_index=mid + 1, end_index=end_index)
+        return root
+
+    @property
+    def root(self) -> typing.Optional[TreeNode]:
+        return self.__root
+
+    """ 查找结点 """
+    def search(self, num: int) -> typing.Optional[TreeNode]:
+        cur = self.root
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 目标结点在 root 的右子树中
+            if cur.val < num:
+                cur = cur.right
+            # 目标结点在 root 的左子树中
+            elif cur.val > num:
+                cur = cur.left
+            # 找到目标结点，跳出循环
+            else:
+                break
+        return cur
+
+    """ 插入结点 """
+    def insert(self, num: int) -> typing.Optional[TreeNode]:
+        root = self.root
+        # 若树为空，直接提前返回
+        if root is None:
+            return None
+
+        cur = root
+        pre = None
+
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 找到重复结点，直接返回
+            if cur.val == num:
+                return None
+            pre = cur
+
+            if cur.val < num:  # 插入位置在 root 的右子树中
+                cur = cur.right
+            else:  # 插入位置在 root 的左子树中
+                cur = cur.left
+
+        # 插入结点 val
+        node = TreeNode(num)
+        if pre.val < num:
+            pre.right = node
+        else:
+            pre.left = node
+        return node
+
+    """ 删除结点 """
+    def remove(self, num: int) -> typing.Optional[TreeNode]:
+        root = self.root
+        # 若树为空，直接提前返回
+        if root is None:
+            return None
+
+        cur = root
+        pre = None
+
+        # 循环查找，越过叶结点后跳出
+        while cur is not None:
+            # 找到待删除结点，跳出循环
+            if cur.val == num:
+                break
+            pre = cur
+            if cur.val < num:  # 待删除结点在 root 的右子树中
+                cur = cur.right
+            else:  # 待删除结点在 root 的左子树中
+                cur = cur.left
+
+        # 若无待删除结点，则直接返回
+        if cur is None:
+            return None
+
+        # 子结点数量 = 0 or 1
+        if cur.left is None or cur.right is None:
+            # 当子结点数量 = 0 / 1 时， child = null / 该子结点
+            child = cur.left or cur.right
+            # 删除结点 cur
+            if pre.left == cur:
+                pre.left = child
+            else:
+                pre.right = child
+        # 子结点数量 = 2
+        else:
+            # 获取中序遍历中 cur 的下一个结点
+            nex = self.min(cur.right)
+            tmp = nex.val
+            # 递归删除结点 nex
+            self.remove(nex.val)
+            # 将 nex 的值复制给 cur
+            cur.val = tmp
+        return cur
+
+    """ 获取最小结点 """
+    def min(self, root: typing.Optional[TreeNode]) -> typing.Optional[TreeNode]:
+        if root is None:
+            return root
+
+        # 循环访问左子结点，直到叶结点时为最小结点，跳出
+        while root.left is not None:
+            root = root.left
+        return root
+
+
+""" Driver Code """
+if __name__ == "__main__":
+    # 初始化二叉搜索树
+    nums = list(range(1, 16))
+    bst = BinarySearchTree(nums=nums)
+    print("\n初始化的二叉树为\n")
+    print_tree(bst.root)
+
+    # 查找结点
+    node = bst.search(5)
+    print("\n查找到的结点对象为: {}，结点值 = {}".format(node, node.val))
+
+    # 插入结点
+    ndoe = bst.insert(16)
+    print("\n插入结点 16 后，二叉树为\n")
+    print_tree(bst.root)
+
+    # 删除结点
+    bst.remove(1)
+    print("\n删除结点 1 后，二叉树为\n")
+    print_tree(bst.root)
+
+    bst.remove(2)
+    print("\n删除结点 2 后，二叉树为\n")
+    print_tree(bst.root)
+
+    bst.remove(4)
+    print("\n删除结点 4 后，二叉树为\n")
+    print_tree(bst.root)

codes/python/chapter_tree/binary_tree.py

@@ -1,10 +1,40 @@
-'''
+"""
 File: binary_tree.py
-Created Time: 2022-11-25
-Author: Krahets (krahets@163.com)
-'''
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
 
 import sys, os.path as osp
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+
+""" Driver Code """
+if __name__ == "__main__":
+    """ 初始化二叉树 """
+    # 初始化节点
+    n1 = TreeNode(val=1)
+    n2 = TreeNode(val=2)
+    n3 = TreeNode(val=3)
+    n4 = TreeNode(val=4)
+    n5 = TreeNode(val=5)
+    # 构建引用指向（即指针）
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    print("\n初始化二叉树\n")
+    print_tree(n1)
+
+    """ 插入与删除结点 """
+    P = TreeNode(0)
+    # 在 n1 -> n2 中间插入节点 P
+    n1.left = P
+    P.left = n2
+    print("\n插入结点 P 后\n")
+    print_tree(n1)
+    # 删除结点
+    n1.left = n2
+    print("\n删除结点 P 后\n");
+    print_tree(n1)

codes/python/chapter_tree/binary_tree_bfs.py

@@ -1,10 +1,42 @@
-'''
+"""
 File: binary_tree_bfs.py
-Created Time: 2022-11-25
-Author: Krahets (krahets@163.com)
-'''
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
 
 import sys, os.path as osp
+import typing
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+
+""" 层序遍历 """
+def hier_order(root: TreeNode):
+    # 初始化队列，加入根结点
+    queue = collections.deque()
+    queue.append(root)
+    # 初始化一个列表，用于保存遍历序列
+    res = []
+    while queue:
+        node = queue.popleft()       # 队列出队
+        res.append(node.val)         # 保存节点值
+        if node.left is not None:
+            queue.append(node.left)  # 左子结点入队
+        if node.right is not None:
+            queue.append(node.right) # 右子结点入队
+    return res
+
+
+""" Driver Code """
+if __name__ == "__main__":
+    # 初始化二叉树
+    # 这里借助了一个从数组直接生成二叉树的函数
+    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None])
+    print("\n初始化二叉树\n")
+    print_tree(root)
+
+    # 层序遍历
+    res = hier_order(root)
+    print("\n层序遍历的结点打印序列 = ", res)
+    assert res == [1, 2, 3, 4, 5, 6, 7]

codes/python/chapter_tree/binary_tree_dfs.py

@@ -1,10 +1,68 @@
-'''
+"""
 File: binary_tree_dfs.py
-Created Time: 2022-11-25
-Author: Krahets (krahets@163.com)
-'''
+Created Time: 2022-12-20
+Author: a16su (lpluls001@gmail.com)
+"""
 
 import sys, os.path as osp
+import typing
+
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+
+res = []
+
+""" 前序遍历 """
+def pre_order(root: typing.Optional[TreeNode]):
+    if root is None:
+        return
+    # 访问优先级：根结点 -> 左子树 -> 右子树
+    res.append(root.val)
+    pre_order(root=root.left)
+    pre_order(root=root.right)
+
+""" 中序遍历 """
+def in_order(root: typing.Optional[TreeNode]):
+    if root is None:
+        return
+    # 访问优先级：左子树 -> 根结点 -> 右子树
+    in_order(root=root.left)
+    res.append(root.val)
+    in_order(root=root.right)
+
+""" 后序遍历 """
+def post_order(root: typing.Optional[TreeNode]):
+    if root is None:
+        return
+    # 访问优先级：左子树 -> 右子树 -> 根结点
+    post_order(root=root.left)
+    post_order(root=root.right)
+    res.append(root.val)
+
+
+""" Driver Code """
+if __name__ == "__main__":
+    # 初始化二叉树
+    # 这里借助了一个从数组直接生成二叉树的函数
+    root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7, None, None, None, None, None, None, None, None])
+    print("\n初始化二叉树\n")
+    print_tree(root)
+
+    # 前序遍历
+    res.clear()
+    pre_order(root)
+    print("\n前序遍历的结点打印序列 = ", res)
+    assert res == [1, 2, 4, 5, 3, 6, 7]
+
+    # 中序遍历
+    res.clear()
+    in_order(root)
+    print("\n中序遍历的结点打印序列 = ", res)
+    assert res == [4, 2, 5, 1, 6, 3, 7]
+
+    # 后序遍历
+    res.clear()
+    post_order(root)
+    print("\n后序遍历的结点打印序列 = ", res)
+    assert res == [4, 5, 2, 6, 7, 3, 1]

codes/python/include/binary_tree.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: binary_tree.py
 Created Time: 2021-12-11
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 import collections
 
@@ -10,9 +10,19 @@ class TreeNode:
     """Definition for a binary tree node
     """    
     def __init__(self, val=0, left=None, right=None):
-        self.val = val
-        self.left = left
-        self.right = right
+        self.val = val      # 结点值
+        self.height = 0     # 结点高度
+        self.left = left    # 左子结点引用
+        self.right = right  # 右子结点引用
+
+    def __str__(self):
+        val = self.val
+        left_node_val = self.left.val if self.left else None
+        right_node_val = self.right.val if self.right else None
+        return "<TreeNode: {}, leftTreeNode: {}, rightTreeNode: {}>".format(val, left_node_val, right_node_val)
+
+    __repr__ = __str__
+
 
 def list_to_tree(arr):
     """Generate a binary tree with a list

codes/python/include/linked_list.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: linked_list.py
 Created Time: 2021-12-11
 Author: Krahets (krahets@163.com)
-'''
+"""
 
 class ListNode:
     """Definition for a singly-linked list node

codes/python/include/print_util.py

@@ -1,8 +1,8 @@
-'''
+"""
 File: print_util.py
 Created Time: 2021-12-11
 Author: Krahets (krahets@163.com), msk397 (machangxinq@gmail.com)
-'''
+"""
 
 import copy
 import queue

codes/swift/chapter_computational_complexity/time_complexity.swift

@@ -0,0 +1,170 @@
+/*
+ * File: time_complexity.swift
+ * Created Time: 2022-12-26
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+// 常数阶
+func constant(n: Int) -> Int {
+    var count = 0
+    let size = 100_000
+    for _ in 0 ..< size {
+        count += 1
+    }
+    return count
+}
+
+// 线性阶
+func linear(n: Int) -> Int {
+    var count = 0
+    for _ in 0 ..< n {
+        count += 1
+    }
+    return count
+}
+
+// 线性阶（遍历数组）
+func arrayTraversal(nums: [Int]) -> Int {
+    var count = 0
+    // 循环次数与数组长度成正比
+    for _ in nums {
+        count += 1
+    }
+    return count
+}
+
+// 平方阶
+func quadratic(n: Int) -> Int {
+    var count = 0
+    // 循环次数与数组长度成平方关系
+    for _ in 0 ..< n {
+        for _ in 0 ..< n {
+            count += 1
+        }
+    }
+    return count
+}
+
+// 平方阶（冒泡排序）
+func bubbleSort(nums: inout [Int]) -> Int {
+    var count = 0 // 计数器
+    // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    for i in sequence(first: nums.count - 1, next: { $0 > 0 ? $0 - 1 : nil }) {
+        // 内循环：冒泡操作
+        for j in 0 ..< i {
+            if nums[j] > nums[j + 1] {
+                // 交换 nums[j] 与 nums[j + 1]
+                let tmp = nums[j]
+                nums[j] = nums[j + 1]
+                nums[j + 1] = tmp
+                count += 3 // 元素交换包含 3 个单元操作
+            }
+        }
+    }
+    return count
+}
+
+// 指数阶（循环实现）
+func exponential(n: Int) -> Int {
+    var count = 0
+    var base = 1
+    // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+    for _ in 0 ..< n {
+        for _ in 0 ..< base {
+            count += 1
+        }
+        base *= 2
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count
+}
+
+// 指数阶（递归实现）
+func expRecur(n: Int) -> Int {
+    if n == 1 {
+        return 1
+    }
+    return expRecur(n: n - 1) + expRecur(n: n - 1) + 1
+}
+
+// 对数阶（循环实现）
+func logarithmic(n: Int) -> Int {
+    var count = 0
+    var n = n
+    while n > 1 {
+        n = n / 2
+        count += 1
+    }
+    return count
+}
+
+// 对数阶（递归实现）
+func logRecur(n: Int) -> Int {
+    if n <= 1 {
+        return 0
+    }
+    return logRecur(n: n / 2) + 1
+}
+
+// 线性对数阶
+func linearLogRecur(n: Double) -> Int {
+    if n <= 1 {
+        return 1
+    }
+    var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)
+    for _ in 0 ..< Int(n) {
+        count += 1
+    }
+    return count
+}
+
+// 阶乘阶（递归实现）
+func factorialRecur(n: Int) -> Int {
+    if n == 0 {
+        return 1
+    }
+    var count = 0
+    // 从 1 个分裂出 n 个
+    for _ in 0 ..< n {
+        count += factorialRecur(n: n - 1)
+    }
+    return count
+}
+
+func main() {
+    // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+    let n = 8
+    print("输入数据大小 n =", n)
+
+    var count = constant(n: n)
+    print("常数阶的计算操作数量 =", count)
+
+    count = linear(n: n)
+    print("线性阶的计算操作数量 =", count)
+    count = arrayTraversal(nums: Array(repeating: 0, count: n))
+    print("线性阶（遍历数组）的计算操作数量 =", count)
+
+    count = quadratic(n: n)
+    print("平方阶的计算操作数量 =", count)
+    var nums = Array(sequence(first: n, next: { $0 > 0 ? $0 - 1 : nil })) // [n,n-1,...,2,1]
+    count = bubbleSort(nums: &nums)
+    print("平方阶（冒泡排序）的计算操作数量 =", count)
+
+    count = exponential(n: n)
+    print("指数阶（循环实现）的计算操作数量 =", count)
+    count = expRecur(n: n)
+    print("指数阶（递归实现）的计算操作数量 =", count)
+
+    count = logarithmic(n: n)
+    print("对数阶（循环实现）的计算操作数量 =", count)
+    count = logRecur(n: n)
+    print("对数阶（递归实现）的计算操作数量 =", count)
+
+    count = linearLogRecur(n: Double(n))
+    print("线性对数阶（递归实现）的计算操作数量 =", count)
+
+    count = factorialRecur(n: n)
+    print("阶乘阶（递归实现）的计算操作数量 =", count)
+}
+
+main()

codes/swift/chapter_computational_complexity/worst_best_time_complexity.swift

@@ -0,0 +1,37 @@
+/*
+ * File: worst_best_time_complexity.swift
+ * Created Time: 2022-12-26
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+// 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱
+func randomNumbers(n: Int) -> [Int] {
+    // 生成数组 nums = { 1, 2, 3, ..., n }
+    var nums = Array(1 ... n)
+    // 随机打乱数组元素
+    nums.shuffle()
+    return nums
+}
+
+// 查找数组 nums 中数字 1 所在索引
+func findOne(nums: [Int]) -> Int {
+    for i in nums.indices {
+        if nums[i] == 1 {
+            return i
+        }
+    }
+    return -1
+}
+
+// Driver Code
+func main() {
+    for _ in 0 ..< 10 {
+        let n = 100
+        let nums = randomNumbers(n: n)
+        let index = findOne(nums: nums)
+        print("数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
+        print("数字 1 的索引为", index)
+    }
+}
+
+main()

codes/typescript/chapter_hashing/array_hash_map.ts

@@ -0,0 +1,136 @@
+/*
+ * File: array_hash_map.ts
+ * Created Time: 2022-12-20
+ * Author: Daniel (better.sunjian@gmail.com)
+ */
+
+/* 键值对 Number -> String */
+class Entry {
+    public key: number;
+    public val: string;
+
+    constructor(key: number, val: string) {
+        this.key = key;
+        this.val = val;
+    }
+}
+
+/* 基于数组简易实现的哈希表 */
+class ArrayHashMap {
+
+    private readonly bucket: (Entry | null)[];
+
+    constructor() {
+        // 初始化一个长度为 100 的桶（数组）
+        this.bucket = (new Array(100)).fill(null);
+    }
+
+    /* 哈希函数 */
+    private hashFunc(key: number): number {
+        return key % 100;
+    }
+
+    /* 查询操作 */
+    public get(key: number): string | null {
+        let index = this.hashFunc(key);
+        let entry = this.bucket[index];
+        if (entry === null) return null;
+        return entry.val;
+    }
+
+    /* 添加操作 */
+    public set(key: number, val: string) {
+        let index = this.hashFunc(key);
+        this.bucket[index] = new Entry(key, val);
+    }
+
+    /* 删除操作 */
+    public delete(key: number) {
+        let index = this.hashFunc(key);
+        // 置为 null ，代表删除
+        this.bucket[index] = null;
+    }
+
+    /* 获取所有键值对 */
+    public entries(): (Entry | null)[] {
+        let arr: (Entry | null)[] = [];
+        for (let i = 0; i < this.bucket.length; i++) {
+            if (this.bucket[i]) {
+                arr.push(this.bucket[i]);
+            }
+        }
+        return arr;
+    }
+
+    /* 获取所有键 */
+    public keys(): (number | undefined)[] {
+        let arr: (number | undefined)[] = [];
+        for (let i = 0; i < this.bucket.length; i++) {
+            if (this.bucket[i]) {
+                arr.push(this.bucket[i]?.key);
+            }
+        }
+        return arr;
+    }
+
+    /* 获取所有值 */
+    public values(): (string | undefined)[] {
+        let arr: (string | undefined)[] = [];
+        for (let i = 0; i < this.bucket.length; i++) {
+            if (this.bucket[i]) {
+                arr.push(this.bucket[i]?.val);
+            }
+        }
+        return arr;
+    }
+
+    /* 打印哈希表 */
+    public print() {
+        let entrySet = this.entries();
+        for (const entry of entrySet) {
+            if (!entry) continue;
+            console.info(`${entry.key} -> ${entry.val}`);
+        }
+    }
+}
+
+/* Driver Code */
+/* 初始化哈希表 */
+const map = new ArrayHashMap();
+/* 添加操作 */
+// 在哈希表中添加键值对 (key, value)
+map.set(12836, '小哈');
+map.set(15937, '小啰');
+map.set(16750, '小算');
+map.set(13276, '小法');
+map.set(10583, '小鸭');
+console.info('\n添加完成后，哈希表为\nKey -> Value');
+map.print();
+
+/* 查询操作 */
+// 向哈希表输入键 key ，得到值 value
+let name = map.get(15937);
+console.info('\n输入学号 15937 ，查询到姓名 ' + name);
+
+/* 删除操作 */
+// 在哈希表中删除键值对 (key, value)
+map.delete(10583);
+console.info('\n删除 10583 后，哈希表为\nKey -> Value');
+map.print();
+
+/* 遍历哈希表 */
+console.info('\n遍历键值对 Key->Value');
+for (const entry of map.entries()) {
+    if (!entry) continue;
+    console.info(entry.key + ' -> ' + entry.val);
+}
+console.info('\n单独遍历键 Key');
+for (const key of map.keys()) {
+    console.info(key);
+}
+console.info('\n单独遍历值 Value');
+for (const val of map.values()) {
+    console.info(val);
+}
+
+export {};

codes/typescript/chapter_hashing/hash_map.ts

@@ -0,0 +1,44 @@
+/*
+ * File: hash_map.ts
+ * Created Time: 2022-12-20
+ * Author: Daniel (better.sunjian@gmail.com)
+ */
+
+/* Driver Code */
+/* 初始化哈希表 */
+const map = new Map<number, string>();
+
+/* 添加操作 */
+// 在哈希表中添加键值对 (key, value)
+map.set(12836, '小哈');
+map.set(15937, '小啰');
+map.set(16750, '小算');
+map.set(13276, '小法');
+map.set(10583, '小鸭');
+console.info('\n添加完成后，哈希表为\nKey -> Value');
+console.info(map);
+
+/* 查询操作 */
+// 向哈希表输入键 key ，得到值 value
+let name = map.get(15937);
+console.info('\n输入学号 15937 ，查询到姓名 ' + name);
+
+/* 删除操作 */
+// 在哈希表中删除键值对 (key, value)
+map.delete(10583);
+console.info('\n删除 10583 后，哈希表为\nKey -> Value');
+console.info(map);
+
+/* 遍历哈希表 */
+console.info('\n遍历键值对 Key->Value');
+for (const [k, v] of map.entries()) {
+    console.info(k + ' -> ' + v);
+}
+console.info('\n单独遍历键 Key');
+for (const k of map.keys()) {
+    console.info(k);
+}
+console.info('\n单独遍历值 Value');
+for (const v of map.values()) {
+    console.info(v);
+}

codes/typescript/chapter_searching/binary_search.ts

@@ -0,0 +1,54 @@
+/*
+* File: binary_search.ts
+* Created Time: 2022-12-27
+* Author: Daniel (better.sunjian@gmail.com)
+*/
+
+/* 二分查找（双闭区间） */
+const binarySearch = function (nums: number[], target: number): number {
+    // 初始化双闭区间 [0, n-1] ，即 i, j 分别指向数组首元素、尾元素
+    let i = 0, j = nums.length - 1;
+    // 循环，当搜索区间为空时跳出（当 i > j 时为空）
+    while (i <= j) {
+        const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
+        if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j] 中
+            i = m + 1;
+        } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m-1] 中
+            j = m - 1;
+        } else {                       // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+    return -1; // 未找到目标元素，返回 -1
+}
+
+/* 二分查找（左闭右开） */
+const binarySearch1 = function (nums: number[], target: number): number {
+    // 初始化左闭右开 [0, n) ，即 i, j 分别指向数组首元素、尾元素+1
+    let i = 0, j = nums.length;
+    // 循环，当搜索区间为空时跳出（当 i = j 时为空）
+    while (i < j) {
+        const m = Math.floor(i + (j - i) / 2); // 计算中点索引 m
+        if (nums[m] < target) {        // 此情况说明 target 在区间 [m+1, j] 中
+            i = m + 1;
+        } else if (nums[m] > target) { // 此情况说明 target 在区间 [i, m] 中
+            j = m;
+        } else {                       // 找到目标元素，返回其索引
+            return m;
+        }
+    }
+    return -1; // 未找到目标元素，返回 -1
+}
+
+
+/* Driver Code */
+const target = 6;
+const nums = [ 1, 3, 6, 8, 12, 15, 23, 67, 70, 92 ];
+
+/* 二分查找（双闭区间） */
+let index = binarySearch(nums, target);
+console.info('目标元素 6 的索引 = %d', index);
+
+/* 二分查找（左闭右开） */
+index = binarySearch1(nums, target);
+console.info('目标元素 6 的索引 = %d', index);

codes/typescript/chapter_sorting/merge_sort.ts

@@ -20,13 +20,13 @@ function merge(nums: number[], left: number, mid: number, right: number): void {
     let i = leftStart, j = rightStart;
     // 通过覆盖原数组 nums 来合并左子数组和右子数组
     for (let k = left; k <= right; k++) {
-        // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+        // 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
         if (i > leftEnd) {
             nums[k] = tmp[j++];
-            // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+            // 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
         } else if (j > rightEnd || tmp[i] <= tmp[j]) {
             nums[k] = tmp[i++];
-            // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            // 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
         } else {
             nums[k] = tmp[j++];
         }

codes/typescript/chapter_stack_and_queue/array_queue.ts

@@ -57,13 +57,6 @@ class ArrayQueue {
         return this.queue[this.front];
     }
 
-    /* 访问指定索引元素 */
-    get(index: number): number {
-        if (index >= this.size)
-            throw new Error("索引越界");
-        return this.queue[(this.front + index) % this.capacity];
-    }
-
     /* 返回 Array */
     toArray(): number[] {
         const siz = this.size;
@@ -94,10 +87,6 @@ console.log(queue.toArray());
 const peek = queue.peek();
 console.log("队首元素 peek = " + peek);
 
-/* 访问指定索引元素 */
-const num = queue.get(2);
-console.log("队列第 3 个元素为 num = " + num);
-
 /* 元素出队 */
 const poll = queue.poll();
 console.log("出队元素 poll = " + poll + "，出队后 queue = ");

codes/typescript/chapter_stack_and_queue/array_stack.ts

@@ -41,13 +41,6 @@ class ArrayStack {
         return this.stack[this.stack.length - 1];
     }
 
-    /* 访问索引 index 处元素 */
-    get(index: number): number | undefined {
-        if (index >= this.size)
-            throw new Error('索引越界');
-        return this.stack[index];
-    }
-
     /* 返回 Array */
     toArray() {
         return this.stack;
@@ -73,10 +66,6 @@ console.log(stack.toArray());
 const top = stack.top();
 console.log("栈顶元素 top = " + top);
 
-/* 访问索引 index 处元素 */
-const num = stack.get(3);
-console.log("栈索引 3 处的元素为 num = " + num);
-
 /* 元素出栈 */
 const pop = stack.pop();
 console.log("出栈元素 pop = " + pop + "，出栈后 stack = ");

codes/typescript/chapter_stack_and_queue/linkedlist_stack.ts

@@ -0,0 +1,91 @@
+/**
+ * File: linkedlist_stack.ts
+ * Created Time: 2022-12-21
+ * Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
+ */
+
+import ListNode from "../module/ListNode"
+
+/* 基于链表实现的栈 */
+class LinkedListStack {
+    private stackPeek: ListNode | null;  // 将头结点作为栈顶
+    private stkSize: number = 0;         // 栈的长度
+
+    constructor() {
+        this.stackPeek = null;
+    }
+
+    /* 获取栈的长度 */
+    get size(): number {
+        return this.stkSize;
+    }
+
+    /* 判断栈是否为空 */
+    isEmpty(): boolean {
+        return this.size == 0;
+    }
+
+    /* 入栈 */
+    push(num: number): void {
+        const node = new ListNode(num);
+        node.next = this.stackPeek;
+        this.stackPeek = node;
+        this.stkSize++;
+    }
+
+    /* 出栈 */
+    pop(): number {
+        const num = this.peek();
+        if (!this.stackPeek)
+            throw new Error("栈为空");
+        this.stackPeek = this.stackPeek.next;
+        this.stkSize--;
+        return num;
+    }
+
+    /* 访问栈顶元素 */
+    peek(): number {
+        if (!this.stackPeek)
+            throw new Error("栈为空");
+        return this.stackPeek.val;
+    }
+
+    /* 将链表转化为 Array 并返回 */
+    toArray(): number[] {
+        let node = this.stackPeek;
+        const res = new Array<number>(this.size);
+        for (let i = res.length - 1; i >= 0; i--) {
+            res[i] = node!.val;
+            node = node!.next;
+        }
+        return res;
+    }
+}
+
+
+/* 初始化栈 */
+const stack = new LinkedListStack();
+
+/* 元素入栈 */
+stack.push(1);
+stack.push(3);
+stack.push(2);
+stack.push(5);
+stack.push(4);
+console.log("栈 stack = " + stack.toArray());
+
+/* 访问栈顶元素 */
+const peek = stack.peek();
+console.log("栈顶元素 peek = " + peek);
+
+/* 元素出栈 */
+const pop = stack.pop();
+console.log("出栈元素 pop = " + pop + "，出栈后 stack = " + stack.toArray());
+
+/* 获取栈的长度 */
+const size = stack.size;
+console.log("栈的长度 size = " + size);
+
+/* 判断是否为空 */
+const isEmpty = stack.isEmpty();
+console.log("栈是否为空 = " + isEmpty);

docs/chapter_array_and_linkedlist/array.md

@@ -75,9 +75,6 @@ comments: true
     /* 初始化数组 */
     int[] arr = new int[5]; // { 0, 0, 0, 0, 0 }
     int[] nums = { 1, 3, 2, 5, 4 };
-    
-    var arr2=new int[5]; // { 0, 0, 0, 0, 0 }
-    var nums2=new int[]{1,2,3,4,5};
     ```
 
 ## 数组优点
@@ -314,7 +311,7 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
     }
     ```
 
-**数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是 “紧挨着的” ，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
+**数组中插入或删除元素效率低下。** 假设我们想要在数组中间某位置插入一个元素，由于数组元素在内存中是“紧挨着的”，它们之间没有空间再放任何数据。因此，我们不得不将此索引之后的所有元素都向后移动一位，然后再把元素赋值给该索引。删除元素也是类似，需要把此索引之后的元素都向前移动一位。总体看有以下缺点：
 
 - **时间复杂度高：** 数组的插入和删除的平均时间复杂度均为 $O(N)$ ，其中 $N$ 为数组长度。
 - **丢失元素：** 由于数组的长度不可变，因此在插入元素后，超出数组长度范围的元素会被丢失。
@@ -712,6 +709,6 @@ elementAddr = firtstElementAddr + elementLength * elementIndex
 
 **随机访问。** 如果我们想要随机抽取一些样本，那么可以用数组存储，并生成一个随机序列，根据索引实现样本的随机抽取。
 
-**二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的 “翻开中间，排除一半” 的方式，来实现一个查电子字典的算法。
+**二分查找。** 例如前文查字典的例子，我们可以将字典中的所有字按照拼音顺序存储在数组中，然后使用与日常查纸质字典相同的“翻开中间，排除一半”的方式，来实现一个查电子字典的算法。
 
 **深度学习。** 神经网络中大量使用了向量、矩阵、张量之间的线性代数运算，这些数据都是以数组的形式构建的。数组是神经网络编程中最常使用的数据结构。

docs/chapter_array_and_linkedlist/linked_list.md

@@ -91,7 +91,7 @@ comments: true
 === "C#"
 
     ```csharp title=""
-    // 链表结点类
+    /* 链表结点类 */
     class ListNode
     {
         int val;         // 结点值
@@ -208,13 +208,13 @@ comments: true
 === "C#"
 
     ```csharp title=""
-    // 初始化链表 1 -> 3 -> 2 -> 5 -> 4 
-    // 初始化各结点
-    n0 = new ListNode(1);
-    n1 = new ListNode(3);
-    n2 = new ListNode(2);
-    n3 = new ListNode(5);
-    n4 = new ListNode(4);
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个结点 
+    ListNode n0 = new ListNode(1);
+    ListNode n1 = new ListNode(3);
+    ListNode n2 = new ListNode(2);
+    ListNode n3 = new ListNode(5);
+    ListNode n4 = new ListNode(4);
     // 构建引用指向
     n0.next = n1;
     n1.next = n2;
@@ -613,7 +613,7 @@ comments: true
         int val;         // 结点值
         ListNode *next;  // 指向后继结点的指针（引用）
         ListNode *prev;  // 指向前驱结点的指针（引用）
-        ListNode(int x) : val(x), next(nullptr) {}  // 构造函数
+        ListNode(int x) : val(x), next(nullptr), prev(nullptr) {}  // 构造函数
     };
     ```
 
@@ -644,8 +644,8 @@ comments: true
         prev;
         constructor(val, next) {
             this.val = val  ===  undefined ? 0 : val;        // 结点值
-            this.next = next  ===  undefined ? null : next;  // 指向后继结点的引用
-            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱结点的引用
+            this.next = next  ===  undefined ? null : next;  // 指向后继结点的指针（引用）
+            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱结点的指针（引用）
         }
     }
     ```
@@ -660,8 +660,8 @@ comments: true
         prev: ListNode | null;
         constructor(val?: number, next?: ListNode | null, prev?: ListNode | null) {
             this.val = val  ===  undefined ? 0 : val;        // 结点值
-            this.next = next  ===  undefined ? null : next;  // 指向后继结点的引用
-            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱结点的引用
+            this.next = next  ===  undefined ? null : next;  // 指向后继结点的指针（引用）
+            this.prev = prev  ===  undefined ? null : prev;  // 指向前驱结点的指针（引用）
         }
     }
     ```
@@ -675,7 +675,7 @@ comments: true
 === "C#"
 
     ```csharp title=""
-    // 双向链表结点类 
+    /* 双向链表结点类 */
     class ListNode {
         int val;        // 结点值
         ListNode next;  // 指向后继结点的指针（引用）

docs/chapter_array_and_linkedlist/list.md

@@ -10,13 +10,15 @@ comments: true
 
 ## 列表常用操作
 
-**初始化列表。** 我们通常使用 `Integer[]` 包装类和 `Arrays.asList()` 作为中转，来初始化一个带有初始值的列表。
+**初始化列表。** 我们通常会使用到“无初始值”和“有初始值”的两种初始化方法。
 
 === "Java"
 
     ```java title="list.java"
     /* 初始化列表 */
-    // 注意数组的元素类型是 int[] 的包装类 Integer[]
+    // 无初始值
+    List<Integer> list1 = new ArrayList<>();
+    // 有初始值（注意数组的元素类型需为 int[] 的包装类 Integer[]）
     Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 };
     List<Integer> list = new ArrayList<>(Arrays.asList(numbers));
     ```
@@ -25,6 +27,10 @@ comments: true
 
     ```cpp title="list.cpp"
     /* 初始化列表 */
+    // 需注意，C++ 中 vector 即是本文描述的 list
+    // 无初始值
+    vector<int> list1;
+    // 有初始值
     vector<int> list = { 1, 3, 2, 5, 4 };
     ```
 
@@ -32,6 +38,9 @@ comments: true
 
     ```python title="list.py"
     """ 初始化列表 """
+    # 无初始值
+    list1 = []
+    # 有初始值
     list = [1, 3, 2, 5, 4]
     ```
 
@@ -39,6 +48,9 @@ comments: true
 
     ```go title="list_test.go"
     /* 初始化列表 */
+    // 无初始值
+    list1 := []int
+    // 有初始值
     list := []int{1, 3, 2, 5, 4}
     ```
 
@@ -46,6 +58,9 @@ comments: true
 
     ```js title="list.js"
     /* 初始化列表 */
+    // 无初始值
+    const list1 = [];
+    // 有初始值
     const list = [1, 3, 2, 5, 4];
     ```
 
@@ -53,6 +68,9 @@ comments: true
 
     ```typescript title="list.ts"
     /* 初始化列表 */
+    // 无初始值
+    const list1: number[] = [];
+    // 有初始值
     const list: number[] = [1, 3, 2, 5, 4];
     ```
 
@@ -65,7 +83,12 @@ comments: true
 === "C#"
 
     ```csharp title="list.cs"
-
+    /* 初始化列表 */
+    // 无初始值
+    List<int> list1 = new ();
+    // 有初始值（注意数组的元素类型需为 int[] 的包装类 Integer[]）
+    int[] numbers = new int[] { 1, 3, 2, 5, 4 };
+    List<int> list = numbers.ToList();
     ```
 
 **访问与更新元素。** 列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
@@ -114,20 +137,20 @@ comments: true
 
     ```js title="list.js"
     /* 访问元素 */
-    const num = list[1];
+    const num = list[1];  // 访问索引 1 处的元素
 
     /* 更新元素 */
-    list[1] = 0;
+    list[1] = 0;  // 将索引 1 处的元素更新为 0
     ```
 
 === "TypeScript"
 
     ```typescript title="list.ts"
     /* 访问元素 */
-    const num: number = list[1];
+    const num: number = list[1];  // 访问索引 1 处的元素
 
     /* 更新元素 */
-    list[1] = 0;
+    list[1] = 0;  // 将索引 1 处的元素更新为 0
     ```
 
 === "C"
@@ -139,7 +162,11 @@ comments: true
 === "C#"
 
     ```csharp title="list.cs"
+    /* 访问元素 */
+    int num = list[1];  // 访问索引 1 处的元素
 
+    /* 更新元素 */
+    list[1] = 0;  // 将索引 1 处的元素更新为 0
     ```
 
 **在列表中添加、插入、删除元素。** 相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
@@ -273,7 +300,21 @@ comments: true
 === "C#"
 
     ```csharp title="list.cs"
+    /* 清空列表 */
+    list.Clear();
 
+    /* 尾部添加元素 */
+    list.Add(1);
+    list.Add(3);
+    list.Add(2);
+    list.Add(5);
+    list.Add(4);
+
+    /* 中间插入元素 */
+    list.Insert(3, 6);
+
+    /* 删除元素 */
+    list.RemoveAt(3);
     ```
 
 **遍历列表。** 与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
@@ -335,9 +376,9 @@ comments: true
 
     /* 直接遍历列表元素 */
     count = 0
-	for range list {
-		count++
-	}
+    for range list {
+        count++
+    }
     ```
 
 === "JavaScript"
@@ -381,7 +422,19 @@ comments: true
 === "C#"
 
     ```csharp title="list.cs"
+    /* 通过索引遍历列表 */
+    int count = 0;
+    for (int i = 0; i < list.Count(); i++)
+    {
+        count++;
+    }
 
+    /* 直接遍历列表元素 */
+    count = 0;
+    foreach (int n in list)
+    {
+        count++;
+    }
     ```
 
 **拼接两个列表。** 再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
@@ -424,7 +477,7 @@ comments: true
     ```js title="list.js"
     /* 拼接两个列表 */
     const list1 = [6, 8, 7, 10, 9];
-    list.push(...list1);
+    list.push(...list1);  // 将列表 list1 拼接到 list 之后
     ```
 
 === "TypeScript"
@@ -432,7 +485,7 @@ comments: true
     ```typescript title="list.ts"
     /* 拼接两个列表 */
     const list1: number[] = [6, 8, 7, 10, 9];
-    list.push(...list1);
+    list.push(...list1);  // 将列表 list1 拼接到 list 之后
     ```
 
 === "C"
@@ -444,7 +497,9 @@ comments: true
 === "C#"
 
     ```csharp title="list.cs"
-
+    /* 拼接两个列表 */
+    List<int> list1 = new() { 6, 8, 7, 10, 9 };
+    list.AddRange(list1);  // 将列表 list1 拼接到 list 之后
     ```
 
 **排序列表。** 排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
@@ -481,7 +536,7 @@ comments: true
 
     ```js title="list.js"
     /* 排序列表 */  
-    list.sort((a, b) => a - b);
+    list.sort((a, b) => a - b);  // 排序后，列表元素从小到大排列
     ```
 
 === "TypeScript"
@@ -500,7 +555,8 @@ comments: true
 === "C#"
 
     ```csharp title="list.cs"
-
+    /* 排序列表 */
+    list.Sort(); // 排序后，列表元素从小到大排列
     ```
 
 ## 列表简易实现 *
@@ -1066,5 +1122,101 @@ comments: true
 === "C#"
 
     ```csharp title="my_list.cs"
+    class MyList
+    {
+        private int[] nums;           // 数组（存储列表元素）
+        private int capacity = 10;    // 列表容量
+        private int size = 0;         // 列表长度（即当前元素数量）
+        private int extendRatio = 2;  // 每次列表扩容的倍数
 
+        /* 构造函数 */
+        public MyList()
+        {
+            nums = new int[capacity];
+        }
+
+        /* 获取列表长度（即当前元素数量）*/
+        public int Size()
+        {
+            return size;
+        }
+
+        /* 获取列表容量 */
+        public int Capacity()
+        {
+            return capacity;
+        }
+
+        /* 访问元素 */
+        public int Get(int index)
+        {
+            // 索引如果越界则抛出异常，下同
+            if (index >= size)
+                throw new IndexOutOfRangeException("索引越界");
+            return nums[index];
+        }
+
+        /* 更新元素 */
+        public void Set(int index, int num)
+        {
+            if (index >= size)
+                throw new IndexOutOfRangeException("索引越界");
+            nums[index] = num;
+        }
+
+        /* 尾部添加元素 */
+        public void Add(int num)
+        {
+            // 元素数量超出容量时，触发扩容机制
+            if (size == Capacity())
+                ExtendCapacity();
+            nums[size] = num;
+            // 更新元素数量
+            size++;
+        }
+
+        /* 中间插入元素 */
+        public void Insert(int index, int num)
+        {
+            if (index >= size)
+                throw new IndexOutOfRangeException("索引越界");
+            // 元素数量超出容量时，触发扩容机制
+            if (size == Capacity())
+                ExtendCapacity();
+            // 将索引 index 以及之后的元素都向后移动一位
+            for (int j = size - 1; j >= index; j--)
+            {
+                nums[j + 1] = nums[j];
+            }
+            nums[index] = num;
+            // 更新元素数量
+            size++;
+        }
+
+        /* 删除元素 */
+        public int Remove(int index)
+        {
+            if (index >= size)
+                throw new IndexOutOfRangeException("索引越界");
+            int num = nums[index];
+            // 将索引 index 之后的元素都向前移动一位
+            for (int j = index; j < size - 1; j++)
+            {
+                nums[j] = nums[j + 1];
+            }
+            // 更新元素数量
+            size--;
+            // 返回被删除元素
+            return num;
+        }
+
+        /* 列表扩容 */
+        public void ExtendCapacity()
+        {
+            // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+            System.Array.Resize(ref nums, Capacity() * extendRatio);
+            // 更新列表容量
+            capacity = nums.Length;
+        }
+    }
     ```

docs/chapter_computational_complexity/performance_evaluation.md

@@ -16,7 +16,7 @@ comments: true
 - **时间效率** ，即算法的运行速度的快慢。
 - **空间效率** ，即算法占用的内存空间大小。
 
-数据结构与算法追求 “运行得快、内存占用少” ，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
+数据结构与算法追求“运行得快、内存占用少”，而如何去评价算法效率则是非常重要的问题，因为只有知道如何评价算法，才能去做算法之间的对比分析，以及优化算法设计。
 
 ## 效率评估方法
 
@@ -38,6 +38,6 @@ comments: true
 
 ## 复杂度分析的重要性
 
-复杂度分析给出一把评价算法效率的 “标尺” ，告诉我们执行某个算法需要多少时间和空间资源，也让我们可以开展不同算法之间的效率对比。
+复杂度分析给出一把评价算法效率的“标尺”，告诉我们执行某个算法需要多少时间和空间资源，也让我们可以开展不同算法之间的效率对比。
 
 计算复杂度是个数学概念，对于初学者可能比较抽象，学习难度相对较高。从这个角度出发，其并不适合作为第一章内容。但是，当我们讨论某个数据结构或者算法的特点时，难以避免需要分析它的运行速度和空间使用情况。**因此，在展开学习数据结构与算法之前，建议读者先对计算复杂度建立起初步的了解，并且能够完成简单案例的复杂度分析**。

docs/chapter_computational_complexity/space_complexity.md

@@ -38,7 +38,7 @@ comments: true
         Node(int x) { val = x; }
     }
     
-    /* 函数（或称方法） */
+    /* 函数 */
     int function() {
         // do something...
         return 0;
@@ -63,7 +63,7 @@ comments: true
         Node(int x) : val(x), next(nullptr) {}
     };
 
-    /* 函数（或称方法） */
+    /* 函数 */
     int func() {
         // do something...
         return 0;
@@ -87,7 +87,7 @@ comments: true
             self.val = x      # 结点值
             self.next = None  # 指向下一结点的指针（引用）
 
-    """ 函数（或称方法） """
+    """ 函数 """
     def function():
         # do something...
         return 0
@@ -113,7 +113,7 @@ comments: true
         return &Node{val: val}
     }
     
-    /* 函数（或称方法）*/
+    /* 函数 */
     func function() int {
         // do something...
         return 0
@@ -149,14 +149,36 @@ comments: true
 === "C#"
 
     ```csharp title=""
+    /* 类 */
+    class Node
+    {
+        int val;
+        Node next;
+        Node(int x) { val = x; }
+    }
 
+    /* 函数 */
+    int function()
+    {
+        // do something...
+        return 0;
+    }
+
+    int algorithm(int n)          // 输入数据
+    {
+        int a = 0;                // 暂存数据（常量）
+        int b = 0;                // 暂存数据（变量）
+        Node node = new Node(0);  // 暂存数据（对象）
+        int c = function();       // 栈帧空间（调用函数）
+        return a + b + c;         // 输出数据
+    }
     ```
 
 ## 推算方法
 
-空间复杂度的推算方法和时间复杂度总体类似，只是从统计 “计算操作数量” 变为统计 “使用空间大小” 。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。
+空间复杂度的推算方法和时间复杂度总体类似，只是从统计“计算操作数量”变为统计“使用空间大小”。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。
 
-**最差空间复杂度中的 “最差” 有两层含义**，分别为输入数据的最差分布、算法运行中的最差时间点。
+**最差空间复杂度中的“最差”有两层含义**，分别为输入数据的最差分布、算法运行中的最差时间点。
 
 - **以最差输入数据为准。** 当 $n < 10$ 时，空间复杂度为 $O(1)$ ；但是当 $n > 10$ 时，初始化的数组 `nums` 使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
 - **以算法运行过程中的峰值内存为准。** 程序在执行最后一行之前，使用 $O(1)$ 空间；当初始化数组 `nums` 时，程序使用 $O(n)$ 空间；因此最差空间复杂度为 $O(n)$ ；
@@ -228,7 +250,15 @@ comments: true
 === "C#"
 
     ```csharp title=""
-
+    void algorithm(int n)
+    {
+        int a = 0;                   // O(1)
+        int[] b = new int[10000];    // O(1)
+        if (n > 10)
+        {
+            int[] nums = new int[n]; // O(n)
+        }
+    }
     ```
 
 **在递归函数中，需要注意统计栈帧空间。** 例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
@@ -330,13 +360,31 @@ comments: true
 === "C"
 
     ```c title=""
-
+    
     ```
 
 === "C#"
 
     ```csharp title=""
-
+    int function()
+    {
+        // do something
+        return 0;
+    }
+    /* 循环 O(1) */
+    void loop(int n)
+    {
+        for (int i = 0; i < n; i++)
+        {
+            function();
+        }
+    }
+    /* 递归 O(n) */
+    int recur(int n)
+    {
+        if (n == 1) return 1;
+        return recur(n - 1);
+    }
     ```
 
 ## 常见类型
@@ -467,7 +515,25 @@ $$
 === "C#"
 
     ```csharp title="space_complexity.cs"
-
+    /* 常数阶 */
+    void constant(int n)
+    {
+        // 常量、变量、对象占用 O(1) 空间
+        int a = 0;
+        int b = 0;
+        int[] nums = new int[10000];
+        ListNode node = new ListNode(0);
+        // 循环中的变量占用 O(1) 空间
+        for (int i = 0; i < n; i++)
+        {
+            int c = 0;
+        }
+        // 循环中的函数占用 O(1) 空间
+        for (int i = 0; i < n; i++)
+        {
+            function();
+        }
+    }
     ```
 
 ### 线性阶 $O(n)$
@@ -540,7 +606,7 @@ $$
             nodes = append(nodes, newNode(i))
         }
         // 长度为 n 的哈希表占用 O(n) 空间
-	    m := make(map[int]string, n)
+        m := make(map[int]string, n)
         for i := 0; i < n; i++ {
             m[i] = strconv.Itoa(i)
         }
@@ -568,7 +634,24 @@ $$
 === "C#"
 
     ```csharp title="space_complexity.cs"
-
+    /* 线性阶 */
+    void linear(int n)
+    {
+        // 长度为 n 的数组占用 O(n) 空间
+        int[] nums = new int[n];
+        // 长度为 n 的列表占用 O(n) 空间
+        List<ListNode> nodes = new();
+        for (int i = 0; i < n; i++)
+        {
+            nodes.Add(new ListNode(i));
+        }
+        // 长度为 n 的哈希表占用 O(n) 空间
+        Dictionary<int, String> map = new();
+        for (int i = 0; i < n; i++)
+        {
+            map.Add(i, i.ToString());
+        }
+    }
     ```
 
 以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
@@ -639,7 +722,13 @@ $$
 === "C#"
 
     ```csharp title="space_complexity.cs"
-
+    /* 线性阶（递归实现） */
+    void linearRecur(int n)
+    {
+        Console.WriteLine("递归 n = " + n);
+        if (n == 1) return;
+        linearRecur(n - 1);
+    }
     ```
 
 ![space_complexity_recursive_linear](space_complexity.assets/space_complexity_recursive_linear.png)
@@ -729,6 +818,23 @@ $$
 === "C#"
 
     ```csharp title="space_complexity.cs"
+    /* 平方阶 */
+    void quadratic(int n)
+    {
+        // 矩阵占用 O(n^2) 空间
+        int[,] numMatrix = new int[n, n];
+        // 二维列表占用 O(n^2) 空间
+        List<List<int>> numList = new();
+        for (int i = 0; i < n; i++)
+        {
+            List<int> tmp = new();
+            for (int j = 0; j < n; j++)
+            {
+                tmp.Add(0);
+            }
+            numList.Add(tmp);
+        }
+    }
 
     ```
 
@@ -777,8 +883,8 @@ $$
         if n <= 0 {
             return 0
         }
+        // 数组 nums 长度为 n, n-1, ..., 2, 1
         nums := make([]int, n)
-        fmt.Printf("递归 n = %d 中的 nums 长度 = %d \n", n, len(nums))
         return spaceQuadraticRecur(n - 1)
     }
     ```
@@ -804,6 +910,14 @@ $$
 === "C#"
 
     ```csharp title="space_complexity.cs"
+    /* 平方阶（递归实现） */
+    int quadraticRecur(int n)
+    {
+        if (n <= 0) return 0;
+        // 数组 nums 长度为 n, n-1, ..., 2, 1
+        int[] nums = new int[n];
+        return quadraticRecur(n - 1);
+    }
 
     ```
 
@@ -889,7 +1003,15 @@ $$
 === "C#"
 
     ```csharp title="space_complexity.cs"
-
+    /* 指数阶（建立满二叉树） */
+    TreeNode? buildTree(int n)
+    {
+        if (n == 0) return null;
+        TreeNode root = new TreeNode(0);
+        root.left = buildTree(n - 1);
+        root.right = buildTree(n - 1);
+        return root;
+    }
     ```
 
 ![space_complexity_exponential](space_complexity.assets/space_complexity_exponential.png)