Merge pull request #99 from msk397/master

time complexity using go

codes/go/chapter_computational_complexity/time_complexity/time_complexity.go

@@ -0,0 +1,131 @@
+// File: quick_sort_test.go
+// Created Time: 2022-12-13
+// Author: msk397 (machangxinq@gmail.com)
+
+package time_complexity
+
+/* 常数阶 */
+func constant(n int) int {
+	count := 0
+	size := 100000
+	for i := 0; i < size; i++ {
+		count++
+	}
+	return count
+}
+
+/* 线性阶 */
+func linear(n int) int {
+	count := 0
+	for i := 0; i < n; i++ {
+		count++
+	}
+	return count
+}
+
+/* 线性阶（遍历数组） */
+func arrayTraversal(nums []int) int {
+	count := 0
+	// 循环次数与数组长度成正比
+	for range nums {
+		count++
+	}
+	return count
+}
+
+/* 平方阶 */
+func quadratic(n int) int {
+	count := 0
+	// 循环次数与数组长度成平方关系
+	for i := 0; i < n; i++ {
+		for j := 0; j < n; j++ {
+			count++
+		}
+	}
+	return count
+}
+
+/* 平方阶（冒泡排序） */
+func bubbleSort(nums []int) int {
+	count := 0 // 计数器
+	// 外循环：待排序元素数量为 n-1, n-2, ..., 1
+	for i := len(nums) - 1; i > 0; i-- {
+		// 内循环：冒泡操作
+		for j := 0; j < i; j++ {
+			if nums[j] > nums[j+1] {
+				// 交换 nums[j] 与 nums[j + 1]
+				tmp := nums[j]
+				nums[j] = nums[j+1]
+				nums[j+1] = tmp
+				count += 3 // 元素交换包含 3 个单元操作
+			}
+		}
+	}
+	return count
+}
+
+/* 指数阶（循环实现）*/
+func exponential(n int) int {
+	count, base := 0, 1
+	// cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+	for i := 0; i < n; i++ {
+		for j := 0; j < base; j++ {
+			count++
+		}
+		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-1) + expRecur(n-1) + 1
+}
+
+/* 对数阶（循环实现）*/
+func logarithmic(n float64) int {
+	count := 0
+	for n > 1 {
+		n = n / 2
+		count++
+	}
+	return count
+}
+
+/* 对数阶（递归实现）*/
+func logRecur(n float64) int {
+	if n <= 1 {
+		return 0
+	}
+	return logRecur(n/2) + 1
+}
+
+/* 线性对数阶 */
+func linearLogRecur(n float64) int {
+	if n <= 1 {
+		return 1
+	}
+	count := linearLogRecur(n/2) +
+		linearLogRecur(n/2)
+	for i := 0.0; i < n; i++ {
+		count++
+	}
+	return count
+}
+
+/* 阶乘阶（递归实现） */
+func factorialRecur(n int) int {
+	if n == 0 {
+		return 1
+	}
+	count := 0
+	// 从 1 个分裂出 n 个
+	for i := 0; i < n; i++ {
+		count += factorialRecur(n - 1)
+	}
+	return count
+}

codes/go/chapter_computational_complexity/time_complexity/time_complexity_test.go

@@ -0,0 +1,48 @@
+// File: quick_sort_test.go
+// Created Time: 2022-12-13
+// Author: msk397 (machangxinq@gmail.com)
+
+package time_complexity
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestTimeComplexity(t *testing.T) {
+	n := 8
+	fmt.Println("输入数据大小 n =", n)
+
+	count := constant(n)
+	fmt.Println("常数阶的计算操作数量 =", count)
+
+	count = linear(n)
+	fmt.Println("线性阶的计算操作数量 =", count)
+	count = arrayTraversal(make([]int, n))
+	fmt.Println("线性阶（遍历数组）的计算操作数量 =", count)
+
+	count = quadratic(n)
+	fmt.Println("平方阶的计算操作数量 =", count)
+	nums := make([]int, n)
+	for i := 0; i < n; i++ {
+		nums[i] = n - i
+	}
+	count = bubbleSort(nums)
+	fmt.Println("平方阶（冒泡排序）的计算操作数量 =", count)
+
+	count = exponential(n)
+	fmt.Println("指数阶（循环实现）的计算操作数量 =", count)
+	count = expRecur(n)
+	fmt.Println("指数阶（递归实现）的计算操作数量 =", count)
+
+	count = logarithmic(float64(n))
+	fmt.Println("对数阶（循环实现）的计算操作数量 =", count)
+	count = logRecur(float64(n))
+	fmt.Println("对数阶（递归实现）的计算操作数量 =", count)
+
+	count = linearLogRecur(float64(n))
+	fmt.Println("线性对数阶（递归实现）的计算操作数量 =", count)
+
+	count = factorialRecur(n)
+	fmt.Println("阶乘阶（递归实现）的计算操作数量 =", count)
+}

codes/go/chapter_computational_complexity/time_complexity/worst_best_time_complexity.go

@@ -0,0 +1,45 @@
+// File: worst_best_time_complexity.go
+// Created Time: 2022-12-13
+// Author: msk397 (machangxinq@gmail.com)
+
+package time_complexity
+
+import (
+	"fmt"
+	"math/rand"
+)
+
+/* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+func randomNumbers(n int) []int {
+	nums := make([]int, n)
+	// 生成数组 nums = { 1, 2, 3, ..., n }
+	for i := 0; i < n; i++ {
+		nums[i] = i + 1
+	}
+	// 随机打乱数组元素
+	rand.Shuffle(len(nums), func(i, j int) {
+		nums[i], nums[j] = nums[j], nums[i]
+	})
+	return nums
+}
+
+/* 查找数组 nums 中数字 1 所在索引 */
+func findOne(nums []int) int {
+	for i := 0; i < len(nums); i++ {
+		if nums[i] == 1 {
+			return i
+		}
+	}
+	return -1
+}
+
+/* Driver Code */
+func main() {
+	for i := 0; i < 10; i++ {
+		n := 100
+		nums := randomNumbers(n)
+		index := findOne(nums)
+		fmt.Println("\n数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
+		fmt.Println("数字 1 的索引为", index)
+	}
+}

codes/go/chapter_sorting/merge_sort/merge_sort.go

@@ -0,0 +1,53 @@
+package merge_sort
+// File: merge_sort.go
+// Created Time: 2022-12-13
+// Author: msk397 (machangxinq@gmail.com)
+
+/*
+	合并左子数组和右子数组
+	左子数组区间 [left, mid]
+	右子数组区间 [mid + 1, right]
+*/
+func merge(nums []int, left, mid, right int) {
+	// 初始化辅助数组 借助 copy模块
+	tmp := make([]int, right-left+1)
+	for i := left; i <= right; i++ {
+		tmp[i-left] = nums[i]
+	}
+	// 左子数组的起始索引和结束索引
+	left_start, left_end := left-left, mid-left
+	// 右子数组的起始索引和结束索引
+	right_start, right_end := mid+1-left, right-left
+	// i, j 分别指向左子数组、右子数组的首元素
+	i, j := left_start, right_start
+	// 通过覆盖原数组 nums 来合并左子数组和右子数组
+	for k := left; k <= right; k++ {
+		// 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+		if i > left_end {
+			nums[k] = tmp[j]
+			j++
+		// 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+		} else if j > right_end || tmp[i] <= tmp[j] {
+			nums[k] = tmp[i]
+			i++
+		// 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+		} else {
+			nums[k] = tmp[j]
+			j++
+		}
+	}
+}
+
+
+func mergeSort(nums []int, left, right int) {
+	// 终止条件
+	if left >= right {
+		return
+	}
+	// 划分阶段
+	mid := (left + right) / 2
+	mergeSort(nums, left, mid)
+	mergeSort(nums, mid+1, right)
+	// 合并阶段
+	merge(nums, left, mid, right)
+}

codes/go/chapter_sorting/merge_sort/merge_sort_test.go

@@ -0,0 +1,15 @@
+package merge_sort
+// File: merge_sort_test.go
+// Created Time: 2022-12-13
+// Author: msk397 (machangxinq@gmail.com)
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMergeSort(t *testing.T) {
+	nums := []int{7, 3, 2, 6, 0, 1, 5, 4}
+	mergeSort(nums, 0, len(nums)-1)
+	fmt.Println("归并排序完成后 nums = ", nums)
+}

docs/chapter_computational_complexity/time_complexity.md

@@ -64,7 +64,16 @@ $$
 === "Go"
 
     ```go title=""
-
+    // 在某运行平台下
+    func algorithm(n int) {
+        a := 2      // 1 ns
+        a = a + 1   // 1 ns
+        a = a * 2   // 10 ns
+        // 循环 n 次
+        for i := 0; i < n; i++ {    // 1 ns
+            fmt.Println(a)          // 5 ns
+        }
+    }
     ```
 
 === "JavaScript"
@@ -164,7 +173,22 @@ $$
 === "Go"
 
     ```go title=""
-
+    // 算法 A 时间复杂度：常数阶
+    func algorithm_A(n int) {
+        fmt.Println(0)
+    }
+    // 算法 B 时间复杂度：线性阶
+    func algorithm_B(n int) {
+        for i := 0; i < n; i++ {
+            fmt.Println(0)
+        }
+    }
+    // 算法 C 时间复杂度：常数阶
+    func algorithm_C(n int) {
+        for i := 0; i < 1000000; i++ {
+            fmt.Println(0)
+        }
+    }
     ```
 
 === "JavaScript"
@@ -249,13 +273,20 @@ $$
         # 循环 n 次
         for i in range(n):  # +1
             print(0)        # +1
-    }
     ```
 
 === "Go"
 
     ```go title=""
-
+    func algorithm(n int) {
+        a := 1		// +1
+        a = a + 1	// +1
+        a = a * 2	// +1
+        // 循环 n 次
+        for i := 0; i < n; i++ {	// +1
+            fmt.Println(a)	        // +1
+        }	
+    }
     ```
 
 === "JavaScript"
@@ -389,7 +420,20 @@ $$
 === "Go"
 
     ```go title=""
-
+    func algorithm(n int) {
+        a := 1      // +0（技巧 1）
+        a = a + n  // +0（技巧 1）
+        // +n（技巧 2）
+        for i := 0; i < 5 * n + 1; i++ {
+            fmt.Println(0)
+        }
+        // +n*n（技巧 3）
+        for i := 0; i < 2 * n; i++ {
+            for j := 0; j < n + 1; j++ {
+                fmt.Println(0)
+            }
+        }
+    }
     ```
 
 === "JavaScript"
@@ -500,7 +544,15 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 常数阶 */
+    func constant(n int) int {
+        count := 0
+        size := 100000
+        for i := 0; i < size; i++ {
+            count ++
+        }
+        return count
+    }
     ```
 
 === "JavaScript"
@@ -569,7 +621,14 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 线性阶 */
+    func linear(n int) int {
+        count := 0
+        for i := 0; i < n; i++ {
+            count++
+        }
+        return count
+    }
     ```
 
 === "JavaScript"
@@ -645,7 +704,15 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 线性阶（遍历数组） */
+    func arrayTraversal(nums []int) int {
+        count := 0
+        // 循环次数与数组长度成正比
+        for range nums {
+            count++
+        }
+        return count
+    }
     ```
 
 === "JavaScript"
@@ -724,7 +791,17 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 平方阶 */
+    func quadratic(n int) int {
+        count := 0
+        // 循环次数与数组长度成平方关系
+        for i := 0; i < n; i++ {
+            for j := 0; j < n; j++ {
+                count++
+            }
+        }
+        return count
+    }
     ```
 
 === "JavaScript"
@@ -829,7 +906,24 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+     /* 平方阶（冒泡排序） */
+     func bubbleSort(nums []int) int {
+        count := 0	// 计数器
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for i := len(nums) - 1; i > 0; i-- {
+            // 内循环：冒泡操作
+            for j := 0; j < i; j++ {
+                if nums[j] > nums[j+1] {
+                    // 交换 nums[j] 与 nums[j + 1]
+                    tmp := nums[j]
+                    nums[j] = nums[j+1]
+                    nums[j+1] = tmp
+                    count += 3 // 元素交换包含 3 个单元操作
+                }
+            }
+        }
+        return count
+    }
     ```
 
 === "JavaScript"
@@ -918,7 +1012,19 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 指数阶（循环实现）*/
+    func exponential(n int) int {
+        count, base := 0, 1
+        // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+        for i := 0; i < n; i++ {
+            for j := 0; j < base; j++ {
+                count++
+            }
+            base *= 2
+        }
+        // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+        return count
+    }
     ```
 
 === "JavaScript"
@@ -983,7 +1089,13 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 指数阶（递归实现）*/
+    func expRecur(n int) int {
+        if n == 1 {
+            return 1
+        }
+        return expRecur(n-1) + expRecur(n-1) + 1
+    }
     ```
 
 === "JavaScript"
@@ -1061,7 +1173,15 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 对数阶（循环实现）*/
+    func logarithmic(n float64) int {
+        count := 0
+        for n > 1 {
+            n = n / 2
+            count++
+        }
+        return count
+    }
     ```
 
 === "JavaScript"
@@ -1126,7 +1246,13 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 对数阶（递归实现）*/
+    func logRecur(n float64) int {
+        if n <= 1 {
+            return 0
+        }
+        return logRecur(n/2) + 1
+    }
     ```
 
 === "JavaScript"
@@ -1205,7 +1331,18 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 线性对数阶 */
+    func linearLogRecur(n float64) int {
+        if n <= 1 {
+            return 1
+        }
+        count := linearLogRecur(n/2) +
+            linearLogRecur(n/2)
+        for i := 0.0; i < n; i++ {
+            count++
+        }
+        return count
+    }
     ```
 
 === "JavaScript"
@@ -1292,7 +1429,18 @@ $$
 === "Go"
 
     ```go title="time_complexity_types.go"
-
+    /* 阶乘阶（递归实现） */
+    func factorialRecur(n int) int {
+        if n == 0 {
+            return 1
+        }
+        count := 0
+        // 从 1 个分裂出 n 个
+        for i := 0; i < n; i++ {
+            count += factorialRecur(n - 1)
+        }
+        return count
+    }
     ```
 
 === "JavaScript"
@@ -1447,7 +1595,40 @@ $$
 === "Go"
 
     ```go title="worst_best_time_complexity.go"
+    /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */
+    func randomNumbers(n int) []int {
+        nums := make([]int, n)
+        // 生成数组 nums = { 1, 2, 3, ..., n }
+        for i := 0; i < n; i++ {
+            nums[i] = i + 1
+        }
+        // 随机打乱数组元素
+        rand.Shuffle(len(nums), func(i, j int) {
+            nums[i], nums[j] = nums[j], nums[i]
+        })
+        return nums
+    }
 
+    /* 查找数组 nums 中数字 1 所在索引 */
+    func findOne(nums []int) int {
+        for i := 0; i < len(nums); i++ {
+            if nums[i] == 1 {
+                return i
+            }
+        }
+        return -1
+    }
+
+    /* Driver Code */
+    func main() {
+        for i := 0; i < 10; i++ {
+            n := 100
+            nums := randomNumbers(n)
+            index := findOne(nums)
+            fmt.Println("\n数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
+            fmt.Println("数字 1 的索引为", index)
+        }
+    }
     ```
 
 === "JavaScript"

docs/chapter_sorting/merge_sort.md

@@ -195,7 +195,54 @@ comments: true
 === "Go"
 
     ```go title="merge_sort.go"
-
+    /*
+        合并左子数组和右子数组
+        左子数组区间 [left, mid]
+        右子数组区间 [mid + 1, right]
+    */
+    func merge(nums []int, left, mid, right int) {
+        // 初始化辅助数组 借助 copy模块
+        tmp := make([]int, right-left+1)
+        for i := left; i <= right; i++ {
+            tmp[i-left] = nums[i]
+        }
+        // 左子数组的起始索引和结束索引
+        left_start, left_end := left-left, mid-left
+        // 右子数组的起始索引和结束索引
+        right_start, right_end := mid+1-left, right-left
+        // i, j 分别指向左子数组、右子数组的首元素
+        i, j := left_start, right_start
+        // 通过覆盖原数组 nums 来合并左子数组和右子数组
+        for k := left; k <= right; k++ {
+            // 若 “左子数组已全部合并完”，则选取右子数组元素，并且 j++
+            if i > left_end {
+                nums[k] = tmp[j]
+                j++
+            // 否则，若 “右子数组已全部合并完” 或 “左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
+            } else if j > right_end || tmp[i] <= tmp[j] {
+                nums[k] = tmp[i]
+                i++
+            // 否则，若 “左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
+            } else {
+                nums[k] = tmp[j]
+                j++
+            }
+        }
+    }
+    
+    /* 归并排序 */
+    func mergeSort(nums []int, left, right int) {
+        // 终止条件
+        if left >= right {
+            return
+        }
+        // 划分阶段
+        mid := (left + right) / 2
+        mergeSort(nums, left, mid)
+        mergeSort(nums, mid+1, right)
+        // 合并阶段
+        merge(nums, left, mid, right)
+    }
     ```
 
 === "JavaScript"