Merge branch 'master' of github.com:krahets/hello-algo

2026-04-05 11:41:22 +08:00 · 2023-01-10 01:49:34 +08:00
parent b7e09c4c1d 251471430c
commit a86bdeb7cd
7 changed files with 358 additions and 8 deletions
--- a/docs/chapter_array_and_linkedlist/list.md
+++ b/docs/chapter_array_and_linkedlist/list.md
@@ -94,7 +94,11 @@ comments: true
 === "Swift"

    ```swift title="list.swift"
-
+    /* 初始化列表 */
+    // 无初始值
+    let list1: [Int] = []
+    // 有初始值
+    var list = [1, 3, 2, 5, 4]
    ```

 **访问与更新元素**。列表的底层数据结构是数组，因此可以在 $O(1)$ 时间内访问与更新元素，效率很高。
@@ -178,7 +182,11 @@ comments: true
 === "Swift"

    ```swift title="list.swift"
+    /* 访问元素 */
+    let num = list[1] // 访问索引 1 处的元素

+    /* 更新元素 */
+    list[1] = 0 // 将索引 1 处的元素更新为 0
    ```

 **在列表中添加、插入、删除元素**。相对于数组，列表可以自由地添加与删除元素。在列表尾部添加元素的时间复杂度为 $O(1)$ ，但是插入与删除元素的效率仍与数组一样低，时间复杂度为 $O(N)$ 。
@@ -332,7 +340,21 @@ comments: true
 === "Swift"

    ```swift title="list.swift"
+    /* 清空列表 */
+    list.removeAll()

+    /* 尾部添加元素 */
+    list.append(1)
+    list.append(3)
+    list.append(2)
+    list.append(5)
+    list.append(4)
+
+    /* 中间插入元素 */
+    list.insert(6, at: 3) // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    list.remove(at: 3) // 删除索引 3 处的元素
    ```

 **遍历列表**。与数组一样，列表可以使用索引遍历，也可以使用 `for-each` 直接遍历。
@@ -458,7 +480,17 @@ comments: true
 === "Swift"

    ```swift title="list.swift"
+    /* 通过索引遍历列表 */
+    var count = 0
+    for _ in list.indices {
+        count += 1
+    }

+    /* 直接遍历列表元素 */
+    count = 0
+    for _ in list {
+        count += 1
+    }
    ```

 **拼接两个列表**。再创建一个新列表 `list1` ，我们可以将其中一个列表拼接到另一个的尾部。
@@ -529,7 +561,9 @@ comments: true
 === "Swift"

    ```swift title="list.swift"
-
+    /* 拼接两个列表 */
+    let list1 = [6, 8, 7, 10, 9]
+    list.append(contentsOf: list1) // 将列表 list1 拼接到 list 之后
    ```

 **排序列表**。排序也是常用的方法之一，完成列表排序后，我们就可以使用在数组类算法题中经常考察的「二分查找」和「双指针」算法了。
@@ -592,7 +626,8 @@ comments: true
 === "Swift"

    ```swift title="list.swift"
-
+    /* 排序列表 */
+    list.sort() // 排序后，列表元素从小到大排列
    ```

 ## 列表简易实现 *
@@ -1263,6 +1298,106 @@ comments: true
 === "Swift"

    ```swift title="my_list.swift"
+    /* 列表类简易实现 */
+    class MyList {
+        private var nums: [Int] // 数组（存储列表元素）
+        private var _capacity = 10 // 列表容量
+        private var _size = 0 // 列表长度（即当前元素数量）
+        private let extendRatio = 2 // 每次列表扩容的倍数

+        /* 构造函数 */
+        init() {
+            nums = Array(repeating: 0, count: _capacity)
+        }
+
+        /* 获取列表长度（即当前元素数量）*/
+        func size() -> Int {
+            _size
+        }
+
+        /* 获取列表容量 */
+        func capacity() -> Int {
+            _capacity
+        }
+
+        /* 访问元素 */
+        func get(index: Int) -> Int {
+            // 索引如果越界则抛出错误，下同
+            if index >= _size {
+                fatalError("索引越界")
+            }
+            return nums[index]
+        }
+
+        /* 更新元素 */
+        func set(index: Int, num: Int) {
+            if index >= _size {
+                fatalError("索引越界")
+            }
+            nums[index] = num
+        }
+
+        /* 尾部添加元素 */
+        func add(num: Int) {
+            // 元素数量超出容量时，触发扩容机制
+            if _size == _capacity {
+                extendCapacity()
+            }
+            nums[_size] = num
+            // 更新元素数量
+            _size += 1
+        }
+
+        /* 中间插入元素 */
+        func insert(index: Int, num: Int) {
+            if index >= _size {
+                fatalError("索引越界")
+            }
+            // 元素数量超出容量时，触发扩容机制
+            if _size == _capacity {
+                extendCapacity()
+            }
+            // 将索引 index 以及之后的元素都向后移动一位
+            for j in sequence(first: _size - 1, next: { $0 >= index + 1 ? $0 - 1 : nil }) {
+                nums[j + 1] = nums[j]
+            }
+            nums[index] = num
+            // 更新元素数量
+            _size += 1
+        }
+
+        /* 删除元素 */
+        @discardableResult
+        func remove(index: Int) -> Int {
+            if index >= _size {
+                fatalError("索引越界")
+            }
+            let num = nums[index]
+            // 将索引 index 之后的元素都向前移动一位
+            for j in index ..< (_size - 1) {
+                nums[j] = nums[j + 1]
+            }
+            // 更新元素数量
+            _size -= 1
+            // 返回被删除元素
+            return num
+        }
+
+        /* 列表扩容 */
+        func extendCapacity() {
+            // 新建一个长度为 size 的数组，并将原数组拷贝到新数组
+            nums = nums + Array(repeating: 0, count: _capacity * (extendRatio - 1))
+            // 更新列表容量
+            _capacity = nums.count
+        }
+
+        /* 将列表转换为数组 */
+        func toArray() -> [Int] {
+            var nums = Array(repeating: 0, count: _size)
+            for i in 0 ..< _size {
+                nums[i] = get(index: i)
+            }
+            return nums
+        }
+    }
    ```
-
--- a/docs/chapter_computational_complexity/time_complexity.md
+++ b/docs/chapter_computational_complexity/time_complexity.md
@@ -1481,7 +1481,7 @@ $$
    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 i in sequence(first: nums.count - 1, next: { $0 > 0 + 1 ? $0 - 1 : nil }) {
            // 内循环：冒泡操作
            for j in 0 ..< i {
                if nums[j] > nums[j + 1] {
--- a/docs/chapter_stack_and_queue/stack.md
+++ b/docs/chapter_stack_and_queue/stack.md
@@ -906,5 +906,5 @@ comments: true

 ## 栈典型应用

- **浏览器中的后退与前进、软件中的撤销与反撤销**。每当我们打开新的网页，浏览器就讲上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
+- **浏览器中的后退与前进、软件中的撤销与反撤销**。每当我们打开新的网页，浏览器就将上一个网页执行入栈，这样我们就可以通过「后退」操作来回到上一页面，后退操作实际上是在执行出栈。如果要同时支持后退和前进，那么则需要两个栈来配合实现。
 - **程序内存管理**。每当调用函数时，系统就会在栈顶添加一个栈帧，用来记录函数的上下文信息。在递归函数中，向下递推会不断执行入栈，向上回溯阶段时出栈。