Update the chapter of time complexity.

codes/go/chapter_computational_complexity/time_complexity_types.go

@@ -0,0 +1,134 @@
+// File: time_complexity_types.go
+// Created Time: 2022-12-13
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_computational_complexity
+
+// constant 常数阶
+func constant(n int) int {
+	count := 0
+	var size = 100000
+	for i := 0; i < size; i++ {
+		count++
+	}
+	return count
+}
+
+// linear 线性阶
+func linear(n int) int {
+	count := 0
+	for i := 0; i < n; i++ {
+		count++
+	}
+	return count
+}
+
+// arrayTraversal 线性阶（遍历数组）
+func arrayTraversal(nums []int) int {
+	count := 0
+	// 循环次数与数组长度成正比
+	for range nums {
+		count++
+	}
+	return count
+}
+
+// quadratic 平方阶
+func quadratic(n int) int {
+	count := 0
+	// 循环次数与数组长度成平方关系
+	for i := 0; i < n; i++ {
+		for j := 0; j < n; j++ {
+			count++
+		}
+	}
+	return count
+}
+
+// bubbleSort 平方阶（冒泡排序）
+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
+}
+
+// exponential 指数阶（循环实现）
+func exponential(n int) int {
+	count := 0
+	base := 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
+}
+
+// expRecur 指数阶（递归实现）
+func expRecur(n int) int {
+	if n == 1 {
+		return 1
+	}
+	return expRecur(n - 1) + expRecur(n - 1) + 1
+}
+
+// logarithmic 对数阶（循环实现）
+func logarithmic(n float32) int {
+	count := 0
+	for n > 1 {
+		n = n / 2
+		count++
+	}
+	return count
+}
+
+// logRecur 对数阶（递归实现）
+func logRecur(n float32) int {
+	if n <= 1 {
+		return 0
+	}
+	return logRecur(n / 2) + 1
+}
+
+// 线性对数阶
+func linearLogRecur(n float32) int {
+	if n <= 1 {
+		return 1
+	}
+	count := linearLogRecur(n / 2) + linearLogRecur(n / 2)
+	for i := 0; float32(i) < n; i++ {
+		count++
+	}
+	return count
+}
+
+// factorialRecur 阶乘阶（递归实现）
+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_types_test.go

@@ -0,0 +1,49 @@
+// File: time_complexity_types_test.go
+// Created Time: 2022-12-13
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_computational_complexity
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestRunCount(t *testing.T) {
+	// ======= Test Case =======
+	n := 8
+	fmt.Println("输入数据大小 n =", n)
+
+	// ====== Driver Code ======
+	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  // [n,n-1,...,2,1]
+	}
+	count = bubbleSort(nums)
+	fmt.Println("平方阶（冒泡排序）的计算操作数量 =", count)
+
+	count = exponential(n)
+	fmt.Println("指数阶（循环实现）的计算操作数量 =", count)
+	count = expRecur(n)
+	fmt.Println("指数阶（递归实现）的计算操作数量 =", count)
+
+	count = logarithmic(float32(n))
+	fmt.Println("对数阶（循环实现）的计算操作数量 =", count)
+	count = logRecur(float32(n))
+	fmt.Println("对数阶（递归实现）的计算操作数量 =", count)
+	count = linearLogRecur(float32(n))
+	fmt.Println("线性对数阶（递归实现）的计算操作数量 =", count)
+
+	count = factorialRecur(n)
+	fmt.Println("阶乘阶（递归实现）的计算操作数量 =", count)
+}

codes/go/chapter_computational_complexity/worst_best_time_complexity.go

@@ -0,0 +1,31 @@
+// File: worst_best_time_complexity.go
+// Created Time: 2022-12-13
+// Author: cathay (cathaycchen@gmail.com)
+
+package chapter_computational_complexity
+
+import "math/rand"
+
+// randomNumbers 生成一个数组，元素为 { 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
+}
+
+// findOne 查找数组 nums 中数字 1 所在索引
+func findOne(nums []int) int {
+	for i := 0; i < len(nums); i++ {
+		if nums[i] == 1 {
+			return i
+		}
+	}
+	return -1
+}

codes/go/chapter_computational_complexity/worst_best_time_complexity_test.go

@@ -0,0 +1,20 @@
+// Copyright 2022 Cathay.  All rights reserved.
+// Use of this source code is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package chapter_computational_complexity
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestWorstBestTimeComplexity(t *testing.T) {
+	for i := 0; i < 10; i++ {
+		n := 100
+		nums := randomNumbers(n)
+		index := findOne(nums)
+		fmt.Println("打乱后的数组为", nums)
+		fmt.Println("数字 1 的索引为", index)
+	}
+}