完善所以c#相关的文档和代码

docs/chapter_array_and_linkedlist/array.md

@@ -74,9 +74,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};
     ```
 
 ## 数组优点

docs/chapter_array_and_linkedlist/linked_list.md

@@ -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;

docs/chapter_array_and_linkedlist/list.md

@@ -83,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)$ 时间内访问与更新元素，效率很高。
@@ -157,7 +162,11 @@ comments: true
 === "C#"
 
     ```csharp title="list.cs"
+    /* 访问元素 */
+    int num = list[1];
 
+    /* 更新元素 */
+    list[1]=0;
     ```
 
 **在列表中添加、插入、删除元素。** 相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
@@ -291,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.Remove(3);
     ```
 
 **遍历列表。** 与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
@@ -399,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` ，我们可以将其中一个列表拼接到另一个的尾部。
@@ -462,7 +497,9 @@ comments: true
 === "C#"
 
     ```csharp title="list.cs"
-
+    /* 拼接两个列表 */
+    List<int> list1 = new() { 6, 8, 7, 10, 9 };
+    list.AddRange(list1);
     ```
 
 **排序列表。** 排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
@@ -518,7 +555,8 @@ comments: true
 === "C#"
 
     ```csharp title="list.cs"
-
+    /* 排序列表 */
+    list.Sort(); // 排序后，列表元素从小到大排列
     ```
 
 ## 列表简易实现 *
@@ -1084,5 +1122,114 @@ 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;
+        }
+
+        /* 将列表转换为数组 */
+        public int[] toArray()
+        {
+            int size = Size();
+            // 仅转换有效长度范围内的列表元素
+            int[] nums = new int[size];
+            for (int i = 0; i < size; i++)
+            {
+                nums[i] = get(i);
+            }
+            return nums;
+        }
+    }
     ```