feat: add Swift codes for space complexity article

codes/swift/chapter_computational_complexity/space_complexity.swift

@@ -0,0 +1,172 @@
+/*
+ * File: space_complexity.swift
+ * Created Time: 2023-01-01
+ * Author: nuomi1 (nuomi1@qq.com)
+ */
+
+class ListNode {
+    var val: Int
+    var next: ListNode?
+
+    init(x: Int) {
+        val = x
+    }
+}
+
+class TreeNode {
+    var val: Int // 结点值
+    var height: Int // 结点高度
+    var left: TreeNode? // 左子结点引用
+    var right: TreeNode? // 右子结点引用
+
+    init(x: Int) {
+        val = x
+        height = 0
+    }
+}
+
+enum PrintUtil {
+    private class Trunk {
+        var prev: Trunk?
+        var str: String
+
+        init(prev: Trunk?, str: String) {
+            self.prev = prev
+            self.str = str
+        }
+    }
+
+    static func printTree(root: TreeNode?) {
+        printTree(root: root, prev: nil, isLeft: false)
+    }
+
+    private static func printTree(root: TreeNode?, prev: Trunk?, isLeft: Bool) {
+        if root == nil {
+            return
+        }
+
+        var prevStr = "    "
+        let trunk = Trunk(prev: prev, str: prevStr)
+
+        printTree(root: root?.right, prev: trunk, isLeft: true)
+
+        if prev == nil {
+            trunk.str = "———"
+        } else if isLeft {
+            trunk.str = "/———"
+            prevStr = "   |"
+        } else {
+            trunk.str = "\\———"
+            prev?.str = prevStr
+        }
+
+        showTrunks(p: trunk)
+        print(" \(root!.val)")
+
+        if prev != nil {
+            prev?.str = prevStr
+        }
+        trunk.str = "   |"
+
+        printTree(root: root?.left, prev: trunk, isLeft: false)
+    }
+
+    private static func showTrunks(p: Trunk?) {
+        if p == nil {
+            return
+        }
+
+        showTrunks(p: p?.prev)
+        print(p!.str, terminator: "")
+    }
+}
+
+// 函数
+@discardableResult
+func function() -> Int {
+    // do something
+    return 0
+}
+
+// 常数阶
+func constant(n: Int) {
+    // 常量、变量、对象占用 O(1) 空间
+    let a = 0
+    var b = 0
+    let nums = Array(repeating: 0, count: 10000)
+    let node = ListNode(x: 0)
+    // 循环中的变量占用 O(1) 空间
+    for _ in 0 ..< n {
+        let c = 0
+    }
+    // 循环中的函数占用 O(1) 空间
+    for _ in 0 ..< n {
+        function()
+    }
+}
+
+// 线性阶
+func linear(n: Int) {
+    // 长度为 n 的数组占用 O(n) 空间
+    let nums = Array(repeating: 0, count: n)
+    // 长度为 n 的列表占用 O(n) 空间
+    let nodes = (0 ..< n).map { ListNode(x: $0) }
+    // 长度为 n 的哈希表占用 O(n) 空间
+    let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, "\($0)") })
+}
+
+// 线性阶（递归实现）
+func linearRecur(n: Int) {
+    print("递归 n = \(n)")
+    if n == 1 {
+        return
+    }
+    linearRecur(n: n - 1)
+}
+
+// 平方阶
+func quadratic(n: Int) {
+    // 二维列表占用 O(n^2) 空间
+    let numList = Array(repeating: Array(repeating: 0, count: n), count: n)
+}
+
+// 平方阶（递归实现）
+@discardableResult
+func quadraticRecur(n: Int) -> Int {
+    if n <= 0 {
+        return 0
+    }
+    // 数组 nums 长度为 n, n-1, ..., 2, 1
+    let nums = Array(repeating: 0, count: n)
+    print("递归 n = \(n) 中的 nums 长度 = \(nums.count)")
+    return quadraticRecur(n: n - 1)
+}
+
+// 指数阶（建立满二叉树）
+func buildTree(n: Int) -> TreeNode? {
+    if n == 0 {
+        return nil
+    }
+    let root = TreeNode(x: 0)
+    root.left = buildTree(n: n - 1)
+    root.right = buildTree(n: n - 1)
+    return root
+}
+
+// Driver Code
+func main() {
+    let n = 5
+    // 常数阶
+    constant(n: n)
+    // 线性阶
+    linear(n: n)
+    linearRecur(n: n)
+    // 平方阶
+    quadratic(n: n)
+    quadraticRecur(n: n)
+    // 指数阶
+    let root = buildTree(n: n)
+    PrintUtil.printTree(root: root)
+}
+
+main()

docs/chapter_computational_complexity/space_complexity.md

@@ -174,6 +174,34 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    // 类
+    class Node {
+        var val: Int
+        var next: Node?
+
+        init(x: Int) {
+            val = x
+        }
+    }
+
+    // 函数
+    func function() -> Int {
+        // do something...
+        return 0
+    }
+
+    func algorithm(n: Int) -> Int { // 输入数据
+        let a = 0 // 暂存数据（常量）
+        var b = 0 // 暂存数据（变量）
+        let node = Node(x: 0) // 暂存数据（对象）
+        let c = function() // 栈帧空间（调用函数）
+        return a + b + c // 输出数据
+    }
+    ```
+
 ## 推算方法
 
 空间复杂度的推算方法和时间复杂度总体类似，只是从统计“计算操作数量”变为统计“使用空间大小”。与时间复杂度不同的是，**我们一般只关注「最差空间复杂度」**。这是因为内存空间是一个硬性要求，我们必须保证在所有输入数据下都有足够的内存空间预留。
@@ -261,6 +289,18 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    func algorithm(n: Int) {
+        let a = 0 // O(1)
+        let b = Array(repeating: 0, count: 10000) // O(1)
+        if n > 10 {
+            let nums = Array(repeating: 0, count: n) // O(n)
+        }
+    }
+    ```
+
 **在递归函数中，需要注意统计栈帧空间。** 例如函数 `loop()`，在循环中调用了 $n$ 次 `function()` ，每轮中的 `function()` 都返回并释放了栈帧空间，因此空间复杂度仍为 $O(1)$ 。而递归函数 `recur()` 在运行中会同时存在 $n$ 个未返回的 `recur()` ，从而使用 $O(n)$ 的栈帧空间。
 
 === "Java"
@@ -387,6 +427,31 @@ comments: true
     }
     ```
 
+=== "Swift"
+
+    ```swift title=""
+    @discardableResult
+    func function() -> Int {
+        // do something
+        return 0
+    }
+
+    // 循环 O(1)
+    func loop(n: Int) {
+        for _ in 0 ..< n {
+            function()
+        }
+    }
+
+    // 递归 O(n)
+    func recur(n: Int) {
+        if n == 1 {
+            return
+        }
+        recur(n: n - 1)
+    }
+    ```
+
 ## 常见类型
 
 设输入数据大小为 $n$ ，常见的空间复杂度类型有（从低到高排列）
@@ -536,6 +601,27 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 常数阶
+    func constant(n: Int) {
+        // 常量、变量、对象占用 O(1) 空间
+        let a = 0
+        var b = 0
+        let nums = Array(repeating: 0, count: 10000)
+        let node = ListNode(x: 0)
+        // 循环中的变量占用 O(1) 空间
+        for _ in 0 ..< n {
+            let c = 0
+        }
+        // 循环中的函数占用 O(1) 空间
+        for _ in 0 ..< n {
+            function()
+        }
+    }
+    ```
+
 ### 线性阶 $O(n)$
 
 线性阶常见于元素数量与 $n$ 成正比的数组、链表、栈、队列等。
@@ -654,6 +740,20 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 线性阶
+    func linear(n: Int) {
+        // 长度为 n 的数组占用 O(n) 空间
+        let nums = Array(repeating: 0, count: n)
+        // 长度为 n 的列表占用 O(n) 空间
+        let nodes = (0 ..< n).map { ListNode(x: $0) }
+        // 长度为 n 的哈希表占用 O(n) 空间
+        let map = Dictionary(uniqueKeysWithValues: (0 ..< n).map { ($0, "\($0)") })
+    }
+    ```
+
 以下递归函数会同时存在 $n$ 个未返回的 `algorithm()` 函数，使用 $O(n)$ 大小的栈帧空间。
 
 === "Java"
@@ -731,6 +831,19 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 线性阶（递归实现）
+    func linearRecur(n: Int) {
+        print("递归 n = \(n)")
+        if n == 1 {
+            return
+        }
+        linearRecur(n: n - 1)
+    }
+    ```
+
 ![space_complexity_recursive_linear](space_complexity.assets/space_complexity_recursive_linear.png)
 
 <p align="center"> Fig. 递归函数产生的线性阶空间复杂度 </p>
@@ -838,6 +951,16 @@ $$
 
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 平方阶
+    func quadratic(n: Int) {
+        // 二维列表占用 O(n^2) 空间
+        let numList = Array(repeating: Array(repeating: 0, count: n), count: n)
+    }
+    ```
+
 在以下递归函数中，同时存在 $n$ 个未返回的 `algorithm()` ，并且每个函数中都初始化了一个数组，长度分别为 $n, n-1, n-2, ..., 2, 1$ ，平均长度为 $\frac{n}{2}$ ，因此总体使用 $O(n^2)$ 空间。
 
 === "Java"
@@ -921,6 +1044,20 @@ $$
 
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 平方阶（递归实现）
+    func quadraticRecur(n: Int) -> Int {
+        if n <= 0 {
+            return 0
+        }
+        // 数组 nums 长度为 n, n-1, ..., 2, 1
+        let nums = Array(repeating: 0, count: n)
+        return quadraticRecur(n: n - 1)
+    }
+    ```
+
 ![space_complexity_recursive_quadratic](space_complexity.assets/space_complexity_recursive_quadratic.png)
 
 <p align="center"> Fig. 递归函数产生的平方阶空间复杂度 </p>
@@ -1014,6 +1151,21 @@ $$
     }
     ```
 
+=== "Swift"
+
+    ```swift title="space_complexity.swift"
+    // 指数阶（建立满二叉树）
+    func buildTree(n: Int) -> TreeNode? {
+        if n == 0 {
+            return nil
+        }
+        let root = TreeNode(x: 0)
+        root.left = buildTree(n: n - 1)
+        root.right = buildTree(n: n - 1)
+        return root
+    }
+    ```
+
 ![space_complexity_exponential](space_complexity.assets/space_complexity_exponential.png)
 
 <p align="center"> Fig. 满二叉树下的指数阶空间复杂度 </p>