可爱的小灰

bjweimengshu · bjweimengshu · commit 8907cf1aecc7 · 2019-08-05T10:37:05.000+08:00
diff --git a/src/chapter2/part1/MyArray.py b/src/chapter2/part1/MyArray.py
@@ -7,7 +7,7 @@ def __init__(self, capacity):
     def insert(self, index, element):
         # 判断访问下标是否超出范围
         if index < 0 or index > self.size:
-            print("超出列表实际元素范围！")
+            raise Exception("超出数组实际元素范围！")
         # 从右向左循环，逐个元素向右挪一位。
         for i in range(self.size-1, -1, -1):
             self.array[i+1] = self.array[i]
@@ -18,7 +18,7 @@ def insert(self, index, element):
     def insert_v2(self, index, element):
         # 判断访问下标是否超出范围
         if index < 0 or index > self.size:
-            print("超出列表实际元素范围！")
+            raise Exception("超出数组实际元素范围！")
         # 如果实际元素达到数组容量上线，数组扩容
         if self.size >= len(self.array):
             self.resize()
@@ -39,7 +39,7 @@ def resize(self):
     def remove(self, index):
         # 判断访问下标是否超出范围
         if index < 0 or index >= self.size:
-            print("超出列表实际元素范围！")
+            raise Exception("超出数组实际元素范围！")
         # 从左到右，逐个元素向左挪动一位
         for i in range(index, self.size):
             self.array[i] = self.array[i+1]
diff --git a/src/chapter2/part2/MyLinkedList.py b/src/chapter2/part2/MyLinkedList.py
@@ -12,17 +12,15 @@ def __init__(self):
 
     def get(self, index):
         if index < 0 or index >= self.size:
-            print('超出链表节点范围！')
-            return
+            raise Exception("超出链表节点范围！")
         p = self.head
         for i in range(index):
             p = p.next
         return p
 
     def insert(self, data, index):
         if index < 0 or index > self.size:
-            print('超出链表节点范围！')
-            return
+            raise Exception("超出链表节点范围！")
         node = Node(data)
         if self.size == 0:
             # 空链表
@@ -35,7 +33,7 @@ def insert(self, data, index):
         elif self.size == index:
             # 插入尾部
             self.last.next = node
-            self.last = node;
+            self.last = node
         else:
             # 插入中间
             prev_node = self.get(index-1)
@@ -45,8 +43,7 @@ def insert(self, data, index):
 
     def remove(self, index):
         if index < 0 or index >= self.size:
-            print('超出链表节点范围！')
-            return
+            raise Exception("超出链表节点范围！")
         # 暂存被删除的节点，用于返回
         if index == 0:
             # 删除头节点
diff --git a/src/chapter2/part3/MyQueue.py b/src/chapter2/part3/MyQueue.py
@@ -7,15 +7,13 @@ def __init__(self, capacity):
 
     def enqueue(self, element):
         if (self.rear+1) % len(self.list) == self.front:
-            print('队列已满！')
-            return
+            raise Exception("队列已满 !")
         self.list[self.rear] = element
         self.rear = (self.rear+1) % len(self.list)
 
     def dequeue(self):
         if self.rear == self.front:
-            print('队列为空！')
-            return
+            raise Exception("队列为空 !")
         dequeue_element = self.list[self.front]
         self.front = (self.front+1) % len(self.list)
         return dequeue_element
diff --git a/src/chapter3/part4/PriorityQueue.py b/src/chapter3/part4/PriorityQueue.py
@@ -11,8 +11,7 @@ def enqueue(self, element):
 
     def dequeue(self):
         if self.size < 0:
-            print("队列为空！")
-            return None
+            raise Exception("队列为空 !")
         head = self.array[0]
         self.array[0] = self.array[self.size-1]
         self.size -= 1
diff --git a/src/chapter5/part12/MedianSortedArrays.py b/src/chapter5/part12/MedianSortedArrays.py
@@ -0,0 +1,42 @@
+def find_median_sorted_arrays(array_A, array_B):
+    m, n = len(array_A), len(array_B)
+    # 如果数组A的长度大于等于数组B，则交换数组
+    if m > n:
+        array_A, array_B, m, n = array_B, array_A, n, m
+    if n == 0:
+        raise ValueError
+    start, end, half_len = 0, m, (m + n + 1) // 2
+    while start <= end:
+        i = (start + end) // 2
+        j = half_len - i
+        if i < m and array_B[j-1] > array_A[i]:
+            # i偏小了，需要右移
+            start = i + 1
+        elif i > 0 and array_A[i - 1] > array_B[j]:
+            # i偏大了，需要左移
+            end = i - 1
+        else:
+            # i刚好合适，或i已达到数组边界
+            if i == 0:
+                max_of_left = array_B[j-1]
+            elif j == 0:
+                max_of_left = array_A[i-1]
+            else:
+                max_of_left = max(array_A[i-1], array_B[j-1])
+            if (m + n) % 2 == 1:
+                # 如果大数组的长度是奇数，中位数就是左半部分的最大值
+                return max_of_left
+            if i == m:
+                min_of_right = array_B[j]
+            elif j == n:
+                min_of_right = array_A[i]
+            else:
+                min_of_right = min(array_A[i], array_B[j])
+            # 如果大数组的长度是偶数，取左侧最大值和右侧最小值的平均
+            return (max_of_left + min_of_right) / 2.0
+
+
+my_array_A = list([3, 5, 6, 7, 8, 12, 20])
+my_array_B = list([1, 10, 17, 18])
+print(find_median_sorted_arrays(my_array_A, my_array_B))
+
diff --git a/src/chapter5/part13/FindLostNum.py b/src/chapter5/part13/FindLostNum.py
@@ -7,7 +7,7 @@ def find_lost_num(array=[]):
         xor_result ^= array[i]
     # 如果异或结果为0，说明输入数组不符合题目
     if xor_result == 0:
-        return None
+        raise ValueError
     # 确定两个整数的不同位，以此来做分组
     separator = 1
     while 0 == (xor_result & separator):
diff --git a/src/chapter5/part3/MinStack.py b/src/chapter5/part3/MinStack.py
@@ -11,14 +11,14 @@ def push(self, element):
 
     def pop(self):
         # 如果出栈元素和辅助栈栈顶元素值相等，辅助栈出栈
-        if self.mainStack[len(self.mainStack) - 1] == self.minStack[len(self.minStack) - 1]:
+        if self.mainStack[len(self.mainStack)-1] == self.minStack[len(self.minStack)-1]:
             self.minStack.pop()
         return self.mainStack.pop()
 
     def get_min(self):
         if len(self.mainStack) == 0:
             return None
-        return self.minStack[len(self.minStack) - 1]
+        return self.minStack[len(self.minStack)-1]
 
 
 myStack = MinStack()
diff --git a/src/chapter5/part4/GreatestCommonDivisor.py b/src/chapter5/part4/GreatestCommonDivisor.py
@@ -25,22 +25,22 @@ def get_greatest_common_divisor_v3(a, b):
     return get_greatest_common_divisor_v2(big-small, small)
 
 
-def gcb(a, b):
+def get_greatest_common_divisor_v4(a, b):
     if a == b:
         return a
     if (a & 1) == 0 and (b & 1) == 0:
-        return gcb(a >> 1, b >> 1) << 1
+        return get_greatest_common_divisor_v4(a >> 1, b >> 1) << 1
     elif (a & 1) == 0 and (b & 1) != 0:
-        return gcb(a >> 1, b)
+        return get_greatest_common_divisor_v4(a >> 1, b)
     elif (a & 1) != 0 and (b & 1) == 0:
-        return gcb(a, b >> 1)
+        return get_greatest_common_divisor_v4(a, b >> 1)
     else:
         big = max(a, b)
         small = min(a, b)
-        return gcb(big-small, small)
+        return get_greatest_common_divisor_v4(big - small, small)
 
 
 print(get_greatest_common_divisor(25, 5))
 print(get_greatest_common_divisor_v2(100, 75))
 print(get_greatest_common_divisor_v3(99, 55))
-print(gcb(100, 80))
+print(get_greatest_common_divisor_v4(100, 80))
diff --git a/src/chapter5/part7/StackQueue.py b/src/chapter5/part7/StackQueue.py
@@ -9,7 +9,7 @@ def en_queue(self, element):
     def de_queue(self):
         if len(self.stackB) == 0:
             if len(self.stackA) == 0:
-                return None
+                raise Exception("栈已经空了 !")
             self.transfer()
         return self.stackB.pop()
 
diff --git a/src/chapter5/part8/FindNearestNumber.py b/src/chapter5/part8/FindNearestNumber.py
@@ -4,7 +4,6 @@ def find_nearest_number(numbers=[]):
     # 如果数字置换边界是0，说明整个数组已经逆序，无法得到更大的相同数字组成的整数，返回null
     if index == 0:
         return None
-
     # 2.把逆序区域的前一位和逆序区域中刚刚大于它的数字交换位置
     # 拷贝入参，避免直接修改入参
     numbers_copy = numbers.copy()
diff --git a/src/chapter6/part2/MyBitmap.py b/src/chapter6/part2/MyBitmap.py
@@ -5,13 +5,13 @@ def __init__(self, size):
 
     def get_bit(self, bit_index):
         if bit_index < 0 or bit_index > self.size-1:
-            return None
+            raise Exception("超过bitmap有效范围 !")
         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
+            raise Exception("超过bitmap有效范围 !")
         word_index = self.get_word_index(bit_index)
         self.words[word_index] |= (1 << bit_index)
 
diff --git a/src/chapter6/part3/LRUCache.py b/src/chapter6/part3/LRUCache.py
@@ -35,7 +35,7 @@ def remove(self, key):
     def refresh_node(self, node):
         # 如果访问的是尾节点，无需移动节点
         if node == self.end:
-            return;
+            return
         # 移除节点
         self.remove_node(node);
         # 重新插入节点
diff --git a/src/chapter6/part4/AStar.py b/src/chapter6/part4/AStar.py
@@ -0,0 +1,125 @@
+def a_star_search(start, end):
+    open_list = []
+    close_list = []
+    # 把起点加入open_list
+    open_list.append(start)
+    # 主循环，每一轮检查一个当前方格节点
+    while len(open_list) > 0:
+        # 在open_list中查找 F值最小的节点作为当前方格节点
+        current_grid = find_min_gird(open_list)
+        # 当前方格节点从openList中移除
+        open_list.remove(current_grid)
+        # 当前方格节点进入 closeList
+        close_list.append(current_grid)
+        # 找到所有邻近节点
+        neighbors = find_neighbors(current_grid, open_list, close_list)
+        for grid in neighbors:
+            if grid not in open_list:
+                # 邻近节点不在openList中，标记父亲、G、H、F，并放入openList
+                grid.init_grid(current_grid, end)
+                open_list.append(grid)
+        # 如果终点在openList中，直接返回终点格子
+        for grid in open_list:
+            if (grid.x == end.x) and (grid.y == end.y):
+                return grid
+    # openList用尽，仍然找不到终点，说明终点不可到达，返回空
+    return None
+
+
+def find_min_gird(open_list=[]):
+    temp_grid = open_list[0]
+    for grid in open_list:
+        if grid.f < temp_grid.f:
+            temp_grid = grid
+    return temp_grid
+
+
+def find_neighbors(grid, open_list=[], close_list=[]):
+    grid_list = []
+    if is_valid_grid(grid.x, grid.y-1, open_list, close_list):
+        grid_list.append(Grid(grid.x, grid.y-1))
+    if is_valid_grid(grid.x, grid.y+1, open_list, close_list):
+        grid_list.append(Grid(grid.x, grid.y+1))
+    if is_valid_grid(grid.x-1, grid.y, open_list, close_list):
+        grid_list.append(Grid(grid.x-1, grid.y))
+    if is_valid_grid(grid.x+1, grid.y, open_list, close_list):
+        grid_list.append(Grid(grid.x+1, grid.y))
+    return grid_list
+
+
+def is_valid_grid(x, y, open_list=[], close_list=[]):
+        # 是否超过边界
+        if x < 0 or x >= len(MAZE) or y < 0 or y >= len(MAZE[0]):
+            return False
+        # 是否有障碍物
+        if MAZE[x][y] == 1:
+            return False
+        # 是否已经在open_list中
+        if contain_grid(open_list, x, y):
+            return False
+        # 是否已经在closeList中
+        if contain_grid(close_list, x, y):
+            return False
+        return True
+
+
+def contain_grid(grids, x, y):
+    for grid in grids:
+        if (grid.x == x) and (grid.y == y):
+            return True
+    return False
+
+
+class Grid:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+        self.f = 0
+        self.g = 0
+        self.h = 0
+        self.parent = None
+
+    def init_grid(self, parent, end):
+        self.parent = parent
+        if parent is not None:
+            self.g = parent.g + 1
+        else:
+            self.g = 1
+        self.h = abs(self.x - end.x) + abs(self.y - end.y)
+        self.f = self.g + self.h
+
+
+# 迷宫地图
+MAZE = [
+    [0, 0, 0, 0, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 1, 0, 0, 0],
+    [0, 0, 0, 0, 0, 0, 0]
+]
+
+# 设置起点和终点
+start_grid = Grid(2, 1)
+end_grid = Grid(2, 5)
+# 搜索迷宫终点
+result_grid = a_star_search(start_grid, end_grid)
+# 回溯迷宫路径
+path = []
+while result_grid is not None:
+    path.append(Grid(result_grid.x, result_grid.y))
+    result_grid = result_grid.parent
+# 输出迷宫和路径，路径用星号表示
+for i in range(0, len(MAZE)):
+    for j in range(0, len(MAZE[0])):
+        if contain_grid(path, i, j):
+            print("*, ", end='')
+        else:
+            print(str(MAZE[i][j]) + ", ", end='')
+    print()
+
+
+
+
+
+
+
diff --git a/src/chapter6/part5/Redpackage.py b/src/chapter6/part5/Redpackage.py
@@ -0,0 +1,20 @@
+import random
+
+
+def divide_red_package(total_amount, total_people_num):
+    amount_list = []
+    rest_amount = total_amount
+    rest_people_num = total_people_num
+    for i in range(0, total_people_num-1):
+        # 随机范围：[1，剩余人均金额的两倍)，左闭右开
+        amount = random.randint(1, int(rest_amount/rest_people_num*2)-1)
+        rest_amount -= amount
+        rest_people_num -= 1
+        amount_list.append(amount)
+    amount_list.append(rest_amount)
+    return amount_list
+
+
+my_amount_list = divide_red_package(1000, 10)
+for my_amount in my_amount_list:
+    print("抢到金额：%.2f" % (my_amount/100))
