Merge branch 'krahets:master' into master

codes/go/chapter_computational_complexity/leetcode_two_sum.go

@@ -7,6 +7,7 @@ package chapter_computational_complexity
 // twoSumBruteForce
 func twoSumBruteForce(nums []int, target int) []int {
 	size := len(nums)
+	// 两层循环，时间复杂度 O(n^2)
 	for i := 0; i < size-1; i++ {
 		for j := i + 1; i < size; j++ {
 			if nums[i]+nums[j] == target {
@@ -19,7 +20,9 @@ func twoSumBruteForce(nums []int, target int) []int {
 
 // twoSumHashTable
 func twoSumHashTable(nums []int, target int) []int {
+	// 辅助哈希表，空间复杂度 O(n)
 	hashTable := map[int]int{}
+	// 单层循环，时间复杂度 O(n)
 	for idx, val := range nums {
 		if preIdx, ok := hashTable[target-val]; ok {
 			return []int{preIdx, idx}

codes/java/chapter_computational_complexity/leetcode_two_sum.java

@@ -8,9 +8,10 @@ package chapter_computational_complexity;
 
 import java.util.*;
 
-class solution_brute_force {
+class SolutionBruteForce {
     public int[] twoSum(int[] nums, int target) {
         int size = nums.length;
+        // 两层循环，时间复杂度 O(n^2)
         for (int i = 0; i < size - 1; i++) {
             for (int j = i + 1; j < size; j++) {
                 if (nums[i] + nums[j] == target)
@@ -21,10 +22,12 @@ class solution_brute_force {
     }
 }
 
-class solution_hash_map {
+class SolutionHashMap {
     public int[] twoSum(int[] nums, int target) {
         int size = nums.length;
+        // 辅助哈希表，空间复杂度 O(n)
         Map<Integer, Integer> dic = new HashMap<>();
+        // 单层循环，时间复杂度 O(n)
         for (int i = 0; i < size; i++) {
             if (dic.containsKey(target - nums[i])) {
                 return new int[] { dic.get(target - nums[i]), i };
@@ -43,11 +46,11 @@ public class leetcode_two_sum {
         
         // ====== Driver Code ======
         // 方法一
-        solution_brute_force slt1 = new solution_brute_force();
+        SolutionBruteForce slt1 = new SolutionBruteForce();
         int[] res = slt1.twoSum(nums, target);
         System.out.println(Arrays.toString(res));
         // 方法二
-        solution_hash_map slt2 = new solution_hash_map();
+        SolutionHashMap slt2 = new SolutionHashMap();
         res = slt2.twoSum(nums, target);
         System.out.println(Arrays.toString(res));
     }

codes/java/chapter_computational_complexity/space_complexity_types.java

@@ -100,7 +100,7 @@ public class space_complexity_types {
         quadratic(n);
         quadraticRecur(n);
         // 指数阶
-        TreeNode tree = buildTree(n);
-        PrintUtil.printTree(tree);
+        TreeNode root = buildTree(n);
+        PrintUtil.printTree(root);
     }
 }

codes/java/chapter_computational_complexity/time_complexity_types.java

@@ -29,7 +29,6 @@ public class time_complexity_types {
         int count = 0;
         // 循环次数与数组长度成正比
         for (int num : nums) {
-            // System.out.println(num);
             count++;
         }
         return count;
@@ -38,6 +37,7 @@ public class time_complexity_types {
     /* 平方阶 */
     static int quadratic(int n) {
         int count = 0;
+        // 循环次数与数组长度成平方关系
         for (int i = 0; i < n; i++) {
             for (int j = 0; j < n; j++) {
                 count++;
@@ -47,18 +47,22 @@ public class time_complexity_types {
     }
 
     /* 平方阶（冒泡排序） */
-    static void bubbleSort(int[] nums) {
-        int n = nums.length;
-        for (int i = 0; i < n - 1; i++) {
-            for (int j = 0; j < n - 1 - i; j++) {
+    static int bubbleSort(int[] nums) {
+        int count = 0;  // 计数器
+        // 外循环：待排序元素数量为 n-1, n-2, ..., 1
+        for (int i = nums.length - 1; i > 0; i--) {
+            // 内循环：冒泡操作
+            for (int j = 0; j < i; j++) {
                 if (nums[j] > nums[j + 1]) {
-                    // 交换 nums[j] 和 nums[j + 1]
+                    // 交换 nums[j] 与 nums[j + 1]
                     int tmp = nums[j];
                     nums[j] = nums[j + 1];
                     nums[j + 1] = tmp;
+                    count += 3;  // 元素交换包含 3 个单元操作
                 }
             }
         }
+        return count;
     }
 
     /* 指数阶（循环实现） */
@@ -135,6 +139,11 @@ public class time_complexity_types {
 
         count = quadratic(n);
         System.out.println("平方阶的计算操作数量 = " + count);
+        int[] nums = new int[n];
+        for (int i = 0; i < n; i++)
+            nums[i] = n - i;  // [n,n-1,...,2,1]
+        count = bubbleSort(nums);
+        System.out.println("平方阶（冒泡排序）的计算操作数量 = " + count);
 
         count = exponential(n);
         System.out.println("指数阶（循环实现）的计算操作数量 = " + count);

codes/python/chapter_array_and_linkedlist/array.py

@@ -57,6 +57,7 @@ def find(nums, target):
             return i
     return -1
 
+
 """ Driver Code """
 if __name__ == "__main__":
     """ 初始化数组 """

codes/python/chapter_array_and_linkedlist/linked_list.py

@@ -41,9 +41,8 @@ def find(head, target):
         index += 1
     return -1
 
-"""
-Driver Code
-"""
+
+""" Driver Code """
 if __name__ == "__main__":
     """ 初始化链表 """
     # 初始化各个结点 

codes/python/chapter_array_and_linkedlist/list.py

@@ -8,9 +8,8 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
-"""
-Driver Code
-"""
+
+""" Driver Code """
 if __name__ == "__main__":
     """ 初始化列表 """
     list = [1, 3, 2, 5, 4]

codes/python/chapter_array_and_linkedlist/my_list.py

@@ -8,7 +8,6 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
-
 """ 列表类简易实现 """
 class MyList:
     """ 构造函数 """
@@ -71,9 +70,7 @@ class MyList:
         return self._nums[:self._size]
 
 
-"""
-Driver Code
-"""
+""" Driver Code """
 if __name__ == "__main__":
     """ 初始化列表 """
     list = MyList()

codes/python/chapter_computational_complexity/leetcode_two_sum.py

@@ -8,3 +8,34 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+class SolutionBruteForce:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        for i in range(len(nums) - 1):
+            for j in range(i + 1, len(nums)):
+                if nums[i] + nums[j] == target:
+                    return i, j
+        return []
+
+class SolutionHashMap:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        dic = {}
+        for i in range(len(nums)):
+            if target - nums[i] in dic:
+                return dic[target - nums[i]], i
+            dic[nums[i]] = i
+        return []
+
+
+""" Driver Code """
+if __name__ == '__main__':
+    # ======= Test Case =======
+    nums = [ 2,7,11,15 ];
+    target = 9;
+    
+    # ====== Driver Code ======
+    # 方法一
+    res = SolutionBruteForce().twoSum(nums, target);
+    print(res)
+    # 方法二
+    res = SolutionHashMap().twoSum(nums, target);
+    print(res)

codes/python/chapter_computational_complexity/space_complexity_types.py

@@ -8,3 +8,71 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+""" 函数 """
+def function():
+    # do something
+    return 0
+
+""" 常数阶 """
+def constant(n):
+    # 常量、变量、对象占用 O(1) 空间
+    a = 0
+    nums = [0] * 10000
+    node = ListNode(0)
+    # 循环中的变量占用 O(1) 空间
+    for _ in range(n):
+         c = 0
+    # 循环中的函数占用 O(1) 空间
+    for _ in range(n):
+        function()
+
+""" 线性阶 """
+def linear(n):
+    # 长度为 n 的列表占用 O(n) 空间
+    nums = [0] * n
+    # 长度为 n 的哈希表占用 O(n) 空间
+    mapp = {}
+    for i in range(n):
+        mapp[i] = str(i)
+
+""" 线性阶（递归实现） """
+def linearRecur(n):
+    print("递归 n = ", n)
+    if n == 1: return
+    linearRecur(n - 1)
+
+""" 平方阶 """
+def quadratic(n):
+    # 二维列表占用 O(n^2) 空间
+    num_matrix = [[0] * n for _ in range(n)]
+
+""" 平方阶（递归实现） """
+def quadratic_recur(n):
+    if n <= 0: return 0
+    nums = [0] * n
+    print("递归 n = {} 中的 nums 长度 = {}".format(n, len(nums)))
+    return quadratic_recur(n - 1)
+
+""" 指数阶（建立满二叉树） """
+def build_tree(n):
+    if n == 0: return None
+    root = TreeNode(0)
+    root.left = build_tree(n - 1)
+    root.right = build_tree(n - 1)
+    return root
+
+
+""" Driver Code """
+if __name__ == "__main__":
+    n = 5
+    # 常数阶
+    constant(n)
+    # 线性阶
+    linear(n)
+    linearRecur(n)
+    # 平方阶
+    quadratic(n)
+    quadratic_recur(n)
+    # 指数阶
+    root = build_tree(n)
+    print_tree(root)

codes/python/chapter_computational_complexity/time_complexity_types.py

@@ -8,3 +8,133 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+""" 常数阶 """
+def constant(n):
+    count = 0
+    size = 100000
+    for _ in range(size):
+        count += 1
+    return count
+
+""" 线性阶 """
+def linear(n):
+    count = 0
+    for _ in range(n):
+        count += 1
+    return count
+
+""" 线性阶（遍历数组）"""
+def array_traversal(nums):
+    count = 0
+    # 循环次数与数组长度成正比
+    for num in nums:
+        count += 1
+    return count
+
+""" 平方阶 """
+def quadratic(n):
+    count = 0
+    # 循环次数与数组长度成平方关系
+    for i in range(n):
+        for j in range(n):
+            count += 1
+    return count
+
+""" 平方阶（冒泡排序）"""
+def bubble_sort(nums):
+    count = 0  # 计数器
+    # 外循环：待排序元素数量为 n-1, n-2, ..., 1
+    for i in range(len(nums) - 1, 0, -1):
+        # 内循环：冒泡操作
+        for j in range(i):
+            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
+
+""" 指数阶（循环实现）"""
+def exponential(n):
+    count, base = 0, 1
+    # cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1)
+    for _ in range(n):
+        for _ in range(base):
+            count += 1
+        base *= 2
+    # count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    return count
+
+""" 指数阶（递归实现）"""
+def exp_recur(n):
+    if n == 1: return 1
+    return exp_recur(n - 1) + exp_recur(n - 1) + 1
+
+""" 对数阶（循环实现）"""
+def logarithmic(n):
+    count = 0
+    while n > 1:
+        n = n / 2
+        count += 1
+    return count
+
+""" 对数阶（递归实现）"""
+def log_recur(n):
+    if n <= 1: return 0
+    return log_recur(n / 2) + 1
+
+""" 线性对数阶 """
+def linear_log_recur(n):
+    if n <= 1: return 1
+    count = linear_log_recur(n // 2) + \
+            linear_log_recur(n // 2)
+    for _ in range(n):
+        count += 1
+    return count
+
+""" 阶乘阶（递归实现）"""
+def factorial_recur(n):
+    if n == 0: return 1
+    count = 0
+    # 从 1 个分裂出 n 个
+    for _ in range(n):
+        count += factorial_recur(n - 1)
+    return count
+
+
+""" Driver Code """
+if __name__ == "__main__":
+    # 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势
+    n = 8
+    print("输入数据大小 n =", n)
+
+    count = constant(n)
+    print("常数阶的计算操作数量 =", count)
+
+    count = linear(n)
+    print("线性阶的计算操作数量 =", count)
+    count = array_traversal([0] * n)
+    print("线性阶（遍历数组）的计算操作数量 =", count)
+
+    count = quadratic(n)
+    print("平方阶的计算操作数量 =", count)
+    nums = [i for i in range(n, 0, -1)]  # [n,n-1,...,2,1]
+    count = bubble_sort(nums)
+    print("平方阶（冒泡排序）的计算操作数量 =", count)
+
+    count = exponential(n)
+    print("指数阶（循环实现）的计算操作数量 =", count)
+    count = exp_recur(n)
+    print("指数阶（递归实现）的计算操作数量 =", count)
+
+    count = logarithmic(n)
+    print("对数阶（循环实现）的计算操作数量 =", count)
+    count = log_recur(n)
+    print("对数阶（递归实现）的计算操作数量 =", count)
+
+    count = linear_log_recur(n)
+    print("线性对数阶（递归实现）的计算操作数量 =", count)
+
+    count = factorial_recur(n)
+    print("阶乘阶（递归实现）的计算操作数量 =", count)

codes/python/chapter_computational_complexity/worst_best_time_complexity.py

@@ -8,3 +8,27 @@ import sys, os.path as osp
 sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
 from include import *
 
+""" 生成一个数组，元素为: 1, 2, ..., n ，顺序被打乱 """
+def random_numbers(n):
+    # 生成数组 nums =: 1, 2, 3, ..., n 
+    nums = [i for i in range(1, n + 1)]
+    # 随机打乱数组元素
+    random.shuffle(nums)
+    return nums
+
+""" 查找数组 nums 中数字 1 所在索引 """
+def find_one(nums):
+    for i in range(len(nums)):
+        if nums[i] == 1:
+            return i
+    return -1
+
+
+""" Driver Code """
+if __name__ == "__main__":
+    for i in range(10):
+        n = 100
+        nums = random_numbers(n)
+        index = find_one(nums)
+        print("\n数组 [ 1, 2, ..., n ] 被打乱后 =", nums)
+        print("数字 1 的索引为", index)