小灰灰

Author: bjweimengshu

src/chapter4/part3/QuickSort.py

@@ -4,7 +4,7 @@ def quick_sort(start_index, end_index, array=[]):
     if start_index >= end_index:
         return
     # 得到基准元素位置
-    pivot_index = partition_v2(start_index, end_index, array)
+    pivot_index = partition_v1(start_index, end_index, array)
     # 根据基准元素，分成两部分递归排序
     quick_sort(start_index, pivot_index - 1, array)
     quick_sort(pivot_index + 1, end_index, array)
@@ -39,7 +39,7 @@ def partition_v2(start_index, end_index, array=[]):
     mark = start_index
     for i in range(start_index+1, end_index+1):
         if array[i] < pivot:
-            mark +=1
+            mark += 1
             p = array[mark]
             array[mark] = array[i]
             array[i] = p

src/chapter5/part10/BigNumberSum.py

@@ -0,0 +1,29 @@
+def big_number_sum(big_number_a, big_number_b):
+    # 把两个大整数用数组逆序存储，数组长度等于较大整数位数 + 1
+    max_length = len(big_number_a) if len(big_number_a)> len(big_number_b) else len(big_number_b)
+    big_number_a = big_number_a.zfill(max_length)
+    big_number_b = big_number_b.zfill(max_length)
+    array_a = list(big_number_a)
+    array_b = list(big_number_b)
+    # 2.构建result数组，数组长度等于较大整数位数 + 1
+    result = [0] * (max_length + 1)
+    # 3.遍历数组，按位相加
+    for i in range(max_length-1, -1, -1):
+        temp = result[i+1]
+        temp += int(array_a[i])
+        temp += int(array_b[i])
+        # 判断是否进位
+        if temp >= 10:
+            temp = temp-10
+            result[i] = 1
+        result[i+1] = temp
+    if result[0] == 0:
+        result.pop(0)
+    # 4.把result数组转成String
+    result = [str(i) for i in result]
+    result_str = "".join(result)
+    return result_str
+
+
+print(big_number_sum("426709752318", "95481253129"))
+

src/chapter5/part11/GoldMining.py

@@ -0,0 +1,38 @@
+def get_best_gold_mining(w, n, p=[], g=[]):
+    if w == 0 or n == 0:
+        return 0
+    if w < p[n-1]:
+        return get_best_gold_mining(w, n-1, p, g)
+    return max(get_best_gold_mining(w, n-1, p, g), get_best_gold_mining(w - p[n-1], n-1, p, g) + g[n-1])
+
+
+def get_best_gold_mining_v2(w, p=[], g=[]):
+    result_table = [[0 for i in range(w+1)] for i in range(len(g)+1)]
+    # 填充表格
+    for i in range(1, len(g)+1):
+        for j in range(1, w+1):
+            if j < p[i-1]:
+                result_table[i][j] = result_table[i-1][j]
+            else:
+                result_table[i][j] = max(result_table[i-1][j], result_table[i-1][j-p[i-1]]+ g[i-1])
+    # 返回最后一个格子的值
+    return result_table[len(g)][w]
+
+
+def get_best_gold_mining_v3(w, p=[], g=[]):
+    # 创建当前结果
+    results = [0]*(w+1)
+    # 填充一维数组
+    for i in range(1, len(g)+1):
+        for j in range(w, 0, -1):
+            if j >= p[i-1]:
+                results[j] = max(results[j], results[j-p[i-1]] + g[i-1])
+    # 返回最后一个格子的值
+    return results[w]
+
+
+test_w = 10
+test_p = list([5, 5, 3, 4, 3])
+test_g = list({400, 500, 200, 300, 350})
+print("最优收益：", get_best_gold_mining_v2(test_w, test_p, test_g))
+

src/chapter5/part12/FindLostNum.py

@@ -0,0 +1,26 @@
+def find_lost_num(array=[]):
+    # 用于存储两个出现奇数次的整数
+    result = [0, 0]
+    # 第一次整体异或
+    xor_result = 0
+    for i in range(0, len(array)):
+        xor_result ^= array[i]
+    # 如果异或结果为0，说明输入数组不符合题目
+    if xor_result == 0:
+        return None
+    # 确定两个整数的不同位，以此来做分组
+    separator = 1
+    while 0 == (xor_result & separator):
+        separator <<= 1
+    # 第二次分组异或
+    for i in range(0, len(array)):
+        if 0 == (array[i] & separator):
+            result[0] ^= array[i]
+        else:
+            result[1] ^= array[i]
+    return result
+
+
+my_array = list([4, 1, 2, 2, 5, 1, 4, 3])
+print(find_lost_num(my_array))
+

src/chapter5/part8/FindNearestNumber.py

@@ -0,0 +1,58 @@
+def find_nearest_number(numbers=[]):
+    # 1.从后向前查看逆序区域，找到逆序区域的前一位，也就是数字置换的边界
+    index = find_transfer_point(numbers)
+    # 如果数字置换边界是0，说明整个数组已经逆序，无法得到更大的相同数字组成的整数，返回null
+    if index == 0:
+        return None
+
+    # 2.把逆序区域的前一位和逆序区域中刚刚大于它的数字交换位置
+    # 拷贝入参，避免直接修改入参
+    numbers_copy = numbers.copy()
+    exchange_head(index, numbers_copy)
+    # 3.把原来的逆序区域转为顺序
+    reverse(index, numbers_copy)
+    return numbers_copy
+
+
+def find_transfer_point(numbers=[]):
+    for i in range(len(numbers)-1, 0, -1):
+        if numbers[i] > numbers[i-1]:
+            return i
+    return 0
+
+
+def exchange_head(index, numbers=[]):
+    head = numbers[index-1]
+    for i in range(len(numbers)-1, 0, -1):
+        if head < numbers[i]:
+            numbers[index-1] = numbers[i]
+            numbers[i] = head
+            break
+    return numbers
+
+
+def reverse(index, numbers=[]):
+    i = index
+    j = len(numbers)-1
+    while i < j:
+        temp = numbers[i]
+        numbers[i] = numbers[j]
+        numbers[j] = temp
+        i += 1
+        j -= 1
+    return numbers
+
+
+def output_numbers(numbers=[]):
+    for i in numbers:
+        print(i, end='')
+    print()
+
+
+my_numbers = list([1, 2, 3, 4, 5])
+# 打印12345之后的10个全排列整数
+for k in range(0, 10):
+    my_numbers = find_nearest_number(my_numbers)
+    output_numbers(my_numbers)
+
+

src/chapter5/part9/RemoveKDigits.py

@@ -0,0 +1,54 @@
+def remove_k_digits(num, k):
+    for i in range(0, k):
+        has_cut = False
+        # 从左向右遍历，找到比自己右侧数字大的数字并删除
+        for j in range(0, len(num)-1):
+            if num[j] > num[j+1]:
+                num = num[0:j]+num[j+1:len(num)]
+                has_cut = True
+                break
+        # 如果没有找到要删除的数字，则删除最后一个数字
+        if not has_cut:
+            num = num[0:len(num)-1]
+    # 清除整数左侧的数字0
+    for j in range(0, len(num)-1):
+        if num[0] != '0':
+            break
+        num = num[1:len(num)]
+    # 如果整数的所有数字都被删除了，直接返回0
+    if len(num) == 0:
+        return "0"
+    return num
+
+
+def remove_k_digits_v2(num, k):
+    # 新整数的最终长度 = 原整数长度 - k
+    new_length = len(num) - k
+    # 创建一个栈，用于接收所有的数字
+    stack = []
+    for i in range(0, len(num)):
+        # 遍历当前数字
+        c = num[i]
+        # 当栈顶数字大于遍历到的当前数字，栈顶数字出栈（相当于删除数字）
+        while len(stack) > 0 and stack[len(stack)-1] > c and k > 0:
+            stack.pop()
+            k -= 1
+        # 如果遇到数字0，且栈为空，0不入栈
+        if '0' == c and len(stack) == 0:
+            new_length -= 1
+            if new_length <= 0:
+                return "0"
+            continue
+        # 遍历到的当前数字入栈
+        stack.append(c)
+    # 找到栈中第一个非零数字的位置，以此构建新的整数字符串
+    if new_length <= 0:
+        return "0"
+    return "".join(stack)
+
+
+print(remove_k_digits("1593212", 3))
+print(remove_k_digits("30200", 1))
+print(remove_k_digits("10", 2))
+print(remove_k_digits("541270936", 3))
+print(remove_k_digits("1593212", 4))

src/chapter6/part2/MyBitmap.py

@@ -0,0 +1,29 @@
+class MyBitmap:
+    def __init__(self, size):
+        self.words = [0] * (self.get_word_index(size-1) + 1)
+        self.size = size
+
+    def get_bit(self, bit_index):
+        if bit_index < 0 or bit_index > self.size-1:
+            return None
+        word_index = self.get_word_index(bit_index)
+        return (self.words[word_index] & (1 << bit_index)) != 0
+
+    def set_bit(self, bit_index):
+        if bit_index < 0 or bit_index > self.size-1:
+            return None
+        word_index = self.get_word_index(bit_index)
+        self.words[word_index] |= (1 << bit_index)
+
+    def get_word_index(self, bit_index):
+        # 右移6位，相当于除以64
+        return bit_index >> 6
+
+
+bitMap = MyBitmap(128)
+bitMap.set_bit(126)
+bitMap.set_bit(75)
+print(bitMap.get_bit(126))
+print(bitMap.get_bit(78))
+
+

src/chapter6/part3/LRUCache.py

@@ -0,0 +1,96 @@
+class LRUCache:
+    def __init__(self, limit):
+        self.limit = limit
+        self.hash = {}
+        self.head = None
+        self.end = None
+
+    def get(self, key):
+        node = self.hash.get(key)
+        if node is None:
+            return None
+        self.refresh_node(node)
+        return node.value
+
+    def put(self, key, value):
+        node = self.hash.get(key)
+        if node is None:
+            # 如果key不存在，插入key-value
+            if len(self.hash) >= self.limit:
+                old_key = self.remove_node(self.head)
+                self.hash.pop(old_key)
+            node = Node(key, value)
+            self.add_node(node)
+            self.hash[key] = node
+        else:
+            # 如果key存在，刷新key-value
+            node.value = value
+            self.refresh_node(node)
+
+    def remove(self, 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.add_node(node);
+
+    def remove_node(self, node):
+        if node == self.head and node == self.end:
+            # 移除唯一的节点
+            self.head = None
+            self.end = None
+        elif node == self.end:
+            # 移除节点
+            self.end = self.end.pre
+            self.end.next = None
+        elif node == self.head:
+            # 移除头节点
+            self.head = self.head.next
+            self.head.pre = None
+        else:
+            # 移除中间节点
+            node.pre.next = node.pre
+            node.next.pre = node.pre
+        return node.key
+
+    def add_node(self, node):
+        if self.end is not None:
+            self.end.next = node
+            node.pre = self.end
+            node.next = None
+        self.end = node
+        if self.head is None:
+            self.head = node
+
+
+class Node:
+    def __init__(self, key, value):
+        self.key = key
+        self.value = value
+        self.pre = None
+        self.next = None
+
+
+lruCache = LRUCache(5)
+lruCache.put("001", "用户1信息")
+lruCache.put("002", "用户2信息")
+lruCache.put("003", "用户3信息")
+lruCache.put("004", "用户4信息")
+lruCache.put("005", "用户5信息")
+print(lruCache.get("002"))
+lruCache.put("004", "用户2信息更新")
+lruCache.put("006", "用户6信息")
+print(lruCache.get("001"))
+print(lruCache.get("006"))
+
+
+
+
+