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

docs/chapter_computational_complexity/space_complexity.md

@@ -102,7 +102,30 @@ comments: true
 === "Go"
 
     ```go title=""
+    /* 结构体 */
+    type Node struct {
+        val  int
+        next *Node
+    }
+    
+    /* 创建 Node 结构体 */
+    func newNode(val int) *Node {
+        return &Node{val: val}
+    }
+    
+    /* 函数（或称方法）*/
+    func function() int {
+        // do something...
+        return 0
+    }
 
+    func algorithm(n int) int { // 输入数据
+        const a = 0             // 暂存数据（常量）
+        b := 0                  // 暂存数据（变量）
+        newNode(0)              // 暂存数据（对象）
+        c := function()         // 栈帧空间（调用函数）
+        return a + b + c        // 输出数据
+    }
     ```
 
 === "JavaScript"
@@ -173,7 +196,15 @@ comments: true
 === "Go"
 
     ```go title=""
-
+    func algorithm(n int) {
+        a := 0                         // O(1)
+        b := make([]int, 10000)        // O(1)
+        var nums []int
+        if n > 10 {
+            nums = make([]int, 10000)  // O(n)
+        }
+        fmt.Println(a, b, nums)
+    }
     ```
 
 === "JavaScript"
@@ -263,7 +294,25 @@ comments: true
 === "Go"
 
     ```go title=""
-
+    func function() int {
+        // do something
+        return 0
+    }
+    
+    /* 循环 O(1) */
+    func loop(n int) {
+        for i := 0; i < n; i++ {
+            function()
+        }
+    }
+    
+    /* 递归 O(n) */
+    func recur(n int) {
+        if n == 1 {
+            return
+        }
+        recur(n - 1)
+    }
     ```
 
 === "JavaScript"
@@ -377,7 +426,24 @@ $$
 === "Go"
 
     ```go title="space_complexity.go"
-
+    /* 常数阶 */
+    func spaceConstant(n int) {
+        // 常量、变量、对象占用 O(1) 空间
+        const a = 0
+        b := 0
+        nums := make([]int, 10000)
+        ListNode := newNode(0)
+        // 循环中的变量占用 O(1) 空间
+        var c int
+        for i := 0; i < n; i++ {
+            c = 0
+        }
+        // 循环中的函数占用 O(1) 空间
+        for i := 0; i < n; i++ {
+            function()
+        }
+        fmt.Println(a, b, nums, c, ListNode)
+    }
     ```
 
 === "JavaScript"
@@ -464,7 +530,21 @@ $$
 === "Go"
 
     ```go title="space_complexity.go"
-
+    /* 线性阶 */
+    func spaceLinear(n int) {
+        // 长度为 n 的数组占用 O(n) 空间
+        _ = make([]int, n)
+        // 长度为 n 的列表占用 O(n) 空间
+        var nodes []*Node
+        for i := 0; i < n; i++ {
+            nodes = append(nodes, newNode(i))
+        }
+        // 长度为 n 的哈希表占用 O(n) 空间
+	    m := make(map[int]string, n)
+        for i := 0; i < n; i++ {
+            m[i] = strconv.Itoa(i)
+        }
+    }
     ```
 
 === "JavaScript"
@@ -528,7 +608,14 @@ $$
 === "Go"
 
     ```go title="space_complexity.go"
-
+    /* 线性阶（递归实现） */
+    func spaceLinearRecur(n int) {
+        fmt.Println("递归 n =", n)
+        if n == 1 {
+            return
+        }
+        spaceLinearRecur(n - 1)
+    }
     ```
 
 === "JavaScript"
@@ -611,7 +698,14 @@ $$
 === "Go"
 
     ```go title="space_complexity.go"
-
+    /* 平方阶 */
+    func spaceQuadratic(n int) {
+        // 矩阵占用 O(n^2) 空间
+        numMatrix := make([][]int, n)
+        for i := 0; i < n; i++ {
+            numMatrix[i] = make([]int, n)
+        }
+    }
     ```
 
 === "JavaScript"
@@ -678,7 +772,15 @@ $$
 === "Go"
 
     ```go title="space_complexity.go"
-
+    /* 平方阶（递归实现） */
+    func spaceQuadraticRecur(n int) int {
+        if n <= 0 {
+            return 0
+        }
+        nums := make([]int, n)
+        fmt.Printf("递归 n = %d 中的 nums 长度 = %d \n", n, len(nums))
+        return spaceQuadraticRecur(n - 1)
+    }
     ```
 
 === "JavaScript"
@@ -754,7 +856,16 @@ $$
 === "Go"
 
     ```go title="space_complexity.go"
-
+    /* 指数阶（建立满二叉树） */
+    func buildTree(n int) *TreeNode {
+        if n == 0 {
+            return nil
+        }
+        root := newTreeNode(0)
+        root.left = buildTree(n - 1)
+        root.right = buildTree(n - 1)
+        return root
+    }
     ```
 
 === "JavaScript"

docs/chapter_sorting/intro_to_sort.md

@@ -22,7 +22,7 @@ comments: true
 - 「稳定排序」在完成排序后，**不改变** 相等元素在数组中的相对顺序。
 - 「非稳定排序」在完成排序后，相等素在数组中的相对位置 **可能被改变**。
 
-假设我们有一个存储学生信息当表格，第 1, 2 列粉笔是姓名和年龄。那么在以下示例中，「非稳定排序」会导致输入数据的有序性丢失。因此「稳定排序」是很好的特性，**在多级排序中是必须的**。
+假设我们有一个存储学生信息当表格，第 1, 2 列分别是姓名和年龄。那么在以下示例中，「非稳定排序」会导致输入数据的有序性丢失。因此「稳定排序」是很好的特性，**在多级排序中是必须的**。
 
 ```shell
 # 输入数据是按照姓名排序好的