Merge pull request krahets#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 ([email protected])
+
+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 ([email protected])
+
+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 ([email protected])
+
+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 ([email protected])
+
+/*
+	合并左子数组和右子数组
+	左子数组区间 [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 ([email protected])
+
+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)
+}