优化代码

Author: bjweimengshu

src/chapter3/part2/BinaryTreeTraversal.py

@@ -8,6 +8,10 @@ def __init__(self, data):
 
 
 def create_binary_tree(input_list=[]):
+    """
+    构建二叉树
+    :param input_list: 输入数列
+    """
     if input_list is None or len(input_list) == 0:
         return None
     data = input_list.pop(0)
@@ -20,6 +24,10 @@ def create_binary_tree(input_list=[]):
 
 
 def pre_order_traversal(node):
+    """
+    前序遍历
+    :param node: 二叉树节点
+    """
     if node is None:
         return
     print(node.data)
@@ -29,6 +37,10 @@ def pre_order_traversal(node):
 
 
 def in_order_traversal(node):
+    """
+    中序遍历
+    :param node: 二叉树节点
+    """
     if node is None:
         return
     in_order_traversal(node.left)
@@ -38,6 +50,10 @@ def in_order_traversal(node):
 
 
 def post_order_traversal(node):
+    """
+    后序遍历
+    :param node: 二叉树节点
+    """
     if node is None:
         return
     post_order_traversal(node.left)

src/chapter3/part3/HeapOperator.py

@@ -1,5 +1,9 @@
 
 def up_adjust(array=[]):
+    """
+    二叉堆的尾节点上浮操作
+    :param array: 原数组
+    """
     child_index = len(array) - 1
     parent_index = (child_index - 1) // 2
     # temp保存插入的叶子节点值，用于最后的赋值
@@ -13,6 +17,12 @@ def up_adjust(array=[]):
 
 
 def down_adjust(parent_index, length, array=[]):
+    """
+    二叉堆的节点下沉操作
+    :param parent_index: 待下沉的节点下标
+    :param length: 堆的长度范围
+    :param array: 原数组
+    """
     # temp保存父节点值，用于最后的赋值
     temp = array[parent_index]
     child_index = 2 * parent_index + 1
@@ -31,6 +41,10 @@ def down_adjust(parent_index, length, array=[]):
 
 
 def build_heap(array=[]):
+    """
+    二叉堆的构建操作
+    :param array: 原数组
+    """
     # 从最后一个非叶子节点开始，依次下沉调整
     for i in range((len(array)-2) // 2, -1, -1):
         down_adjust(i, len(array), array)

src/chapter4/part5/BucketSort.py

@@ -21,7 +21,7 @@ def bucket_sort(array=[]):
         bucket.append(array[i])
     # 4.对每个桶内部进行排序
     for i in range(0, len(bucket_list)):
-        # list采用了归并排序或归并的优化版本
+        # sort方法采用了时间复杂度O(nlogn)的排序算法
         bucket_list[i].sort()
     # 5.输出全部元素
     sorted_array = []

src/chapter5/part11/GoldMining.py

@@ -1,4 +1,11 @@
 def get_best_gold_mining(w, n, p=[], g=[]):
+    """
+    :param w: 工人数量
+    :param n: 可选金矿数量
+    :param p: 金矿开采所需工人数量
+    :param g: 金矿储量
+    :return: 最优收益
+    """
     if w == 0 or n == 0:
         return 0
     if w < p[n-1]:
@@ -7,6 +14,12 @@ def get_best_gold_mining(w, n, p=[], g=[]):
 
 
 def get_best_gold_mining_v2(w, p=[], g=[]):
+    """
+    :param w: 工人数量
+    :param p: 金矿开采所需工人数量
+    :param g: 金矿储量
+    :return: 最优收益
+    """
     result_table = [[0 for i in range(w+1)] for i in range(len(g)+1)]
     # 填充表格
     for i in range(1, len(g)+1):
@@ -20,6 +33,12 @@ def get_best_gold_mining_v2(w, p=[], g=[]):
 
 
 def get_best_gold_mining_v3(w, p=[], g=[]):
+    """
+    :param w: 工人数量
+    :param p: 金矿开采所需工人数量
+    :param g: 金矿储量
+    :return: 最优收益
+    """
     # 创建当前结果
     results = [0]*(w+1)
     # 填充一维数组

src/chapter5/part3/MinStack.py

@@ -1,35 +1,35 @@
 class MinStack:
     def __init__(self):
-        self.mainStack = []
-        self.minStack = []
+        self.main_stack = []
+        self.min_stack = []
 
     def push(self, element):
-        self.mainStack.append(element)
+        self.main_stack.append(element)
         # 如果辅助栈为空，或新元素小于等于辅助栈栈顶，则新元素压入辅助栈
-        if len(self.minStack) == 0 or element <= self.minStack[len(self.minStack)-1]:
-            self.minStack.append(element)
+        if len(self.min_stack) == 0 or element <= self.min_stack[len(self.min_stack) - 1]:
+            self.min_stack.append(element)
 
     def pop(self):
-        # 如果出栈元素和辅助栈栈顶元素值相等，辅助栈出栈
-        if self.mainStack[len(self.mainStack)-1] == self.minStack[len(self.minStack)-1]:
-            self.minStack.pop()
-        return self.mainStack.pop()
+        # 如果出栈元素和辅助栈栈顶元素值相等，辅助栈的栈顶元素出栈
+        if self.main_stack[len(self.main_stack) - 1] == self.min_stack[len(self.min_stack) - 1]:
+            self.min_stack.pop()
+        return self.main_stack.pop()
 
     def get_min(self):
-        if len(self.mainStack) == 0:
+        if len(self.main_stack) == 0:
             return None
-        return self.minStack[len(self.minStack)-1]
+        return self.min_stack[len(self.min_stack) - 1]
 
 
-myStack = MinStack()
-myStack.push(4)
-myStack.push(9)
-myStack.push(7)
-myStack.push(3)
-myStack.push(8)
-myStack.push(5)
-print(myStack.get_min())
-myStack.pop()
-myStack.pop()
-myStack.pop()
-print(myStack.get_min())
+my_stack = MinStack()
+my_stack.push(4)
+my_stack.push(9)
+my_stack.push(7)
+my_stack.push(3)
+my_stack.push(8)
+my_stack.push(5)
+print(my_stack.get_min())
+my_stack.pop()
+my_stack.pop()
+my_stack.pop()
+print(my_stack.get_min())

src/chapter5/part9/RemoveKDigits.py

@@ -11,10 +11,12 @@ def remove_k_digits(num, k):
         if not has_cut:
             num = num[0:len(num)-1]
     # 清除整数左侧的数字0
+    start = 0
     for j in range(0, len(num)-1):
-        if num[0] != '0':
+        if num[j] != '0':
             break
-        num = num[1:len(num)]
+        start += 1
+    num = num[start:len(num)]
     # 如果整数的所有数字都被删除了，直接返回0
     if len(num) == 0:
         return "0"
@@ -41,7 +43,7 @@ def remove_k_digits_v2(num, k):
             continue
         # 遍历到的当前数字入栈
         stack.append(c)
-    # 找到栈中第一个非零数字的位置，以此构建新的整数字符串
+    # 用栈构建新的整数字符串
     if new_length <= 0:
         return "0"
     return "".join(stack)
@@ -52,3 +54,4 @@ def remove_k_digits_v2(num, k):
 print(remove_k_digits("10", 2))
 print(remove_k_digits("541270936", 3))
 print(remove_k_digits("1593212", 4))
+print(remove_k_digits("10000100002", 2))

src/chapter6/__init__.py

@@ -20,9 +20,9 @@ def get_word_index(self, bit_index):
         return bit_index >> 6
 
 
-bitMap = MyBitmap(128)
-bitMap.set_bit(126)
-bitMap.set_bit(75)
+bitMap = MyBitmap(21474836470)
+bitMap.set_bit(78)
+bitMap.set_bit(50)
 print(bitMap.get_bit(126))
 print(bitMap.get_bit(78))
 

src/chapter6/part2/MyBitmap.py

@@ -28,18 +28,18 @@ def put(self, key, value):
             self.refresh_node(node)
 
     def remove(self, key):
-        node = self.hash.get(key);
-        self.remove_node(node);
-        self.hash.remove(key);
+        node = self.hash.get(key)
+        self.remove_node(node)
+        self.hash.remove(key)
 
     def refresh_node(self, node):
         # 如果访问的是尾节点，无需移动节点
         if node == self.end:
             return
         # 移除节点
-        self.remove_node(node);
+        self.remove_node(node)
         # 重新插入节点
-        self.add_node(node);
+        self.add_node(node)
 
     def remove_node(self, node):
         if node == self.head and node == self.end:

src/chapter6/part3/LRUCache.py

@@ -1,5 +1,7 @@
 def a_star_search(start, end):
+    # 待访问的格子
     open_list = []
+    # 已访问的格子
     close_list = []
     # 把起点加入open_list
     open_list.append(start)