面试题

Author: bjweimengshu

src/chapter5/part2/LinkedListCycle.py

@@ -0,0 +1,29 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+
+def is_cycle(head):
+    p1 = head
+    p2 = head
+    while p2 is not None and p2.next is not None:
+        p1 = p1.next
+        p2 = p2.next.next
+        if p1 == p2:
+            return True
+    return False
+
+
+node1 = Node(5)
+node2 = Node(3)
+node3 = Node(7)
+node4 = Node(2)
+node5 = Node(6)
+node1.next = node2
+node2.next = node3
+node3.next = node4
+node4.next = node5
+node5.next = node2
+print(is_cycle(node1))
+

src/chapter5/part3/MinStack.py

@@ -0,0 +1,35 @@
+class MinStack:
+    def __init__(self):
+        self.mainStack = []
+        self.minStack = []
+
+    def push(self, element):
+        self.mainStack.append(element)
+        # 如果辅助栈为空，或新元素小于等于辅助栈栈顶，则新元素压入辅助栈
+        if len(self.minStack) == 0 or element <= self.minStack[len(self.minStack)-1]:
+            self.minStack.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()
+
+    def get_min(self):
+        if len(self.mainStack) == 0:
+            return None
+        return self.minStack[len(self.minStack) - 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())

src/chapter5/part4/GreatestCommonDivisor.py

@@ -0,0 +1,46 @@
+def get_greatest_common_divisor(a, b):
+    big = max(a, b)
+    small = min(a, b)
+    if big % small == 0:
+        return small
+    for i in range(small//2, 1, -1):
+        if small % i == 0 and big % i == 0:
+            return i
+    return 1
+
+
+def get_greatest_common_divisor_v2(a, b):
+    big = max(a, b)
+    small = min(a, b)
+    if big % small == 0:
+        return small
+    return get_greatest_common_divisor_v2(big % small, small)
+
+
+def get_greatest_common_divisor_v3(a, b):
+    if a == b:
+        return a
+    big = max(a, b)
+    small = min(a, b)
+    return get_greatest_common_divisor_v2(big-small, small)
+
+
+def gcb(a, b):
+    if a == b:
+        return a
+    if (a & 1) == 0 and (b & 1) == 0:
+        return gcb(a >> 1, b >> 1) << 1
+    elif (a & 1) == 0 and (b & 1) != 0:
+        return gcb(a >> 1, b)
+    elif (a & 1) != 0 and (b & 1) == 0:
+        return gcb(a, b >> 1)
+    else:
+        big = max(a, b)
+        small = min(a, b)
+        return gcb(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))

src/chapter5/part5/PowerOf2.py

@@ -0,0 +1,24 @@
+def is_power_of_2(num):
+    temp = 1
+    while temp <= num:
+        if temp == num:
+            return True
+        temp = temp * 2
+    return False
+
+
+def is_power_of_2_v2(num):
+    temp = 1
+    while temp <= num:
+        if temp == num:
+            return True
+        temp = temp << 1
+    return False
+
+
+def is_power_of_2_v3(num):
+    return (num & num-1) == 0
+
+
+print(is_power_of_2_v3(19))
+print(is_power_of_2_v3(32))

src/chapter5/part6/MaxSortedDistance.py

@@ -0,0 +1,46 @@
+class Bucket:
+    def __init__(self):
+        self.min = None
+        self.max = None
+
+
+def get_max_sorted_distance(array=[]):
+    # 1.得到数列的最大值和最小值
+    max_value = array[0]
+    min_value = array[0]
+    for i in range(1, len(array)):
+        if array[i] > max_value:
+            max_value = array[i]
+        if array[i] < min_value:
+            min_value = array[i]
+    d = max_value - min_value
+    # 如果max和min相等，说明数组所有元素都相等，返回0
+    if d == 0:
+        return 0
+    # 2.初始化桶
+    bucket_num = len(array)
+    buckets = []
+    for i in range(0, bucket_num):
+        buckets.append(Bucket())
+    # 3.遍历原始数组，确定每个桶的最大最小值
+    for i in range(0, len(array)):
+        # 确定数组元素所归属的桶下标
+        index = int((array[i] - min_value) * (bucket_num-1) / d)
+        if buckets[index].min is None or buckets[index].min > array[i]:
+            buckets[index].min = array[i]
+        if buckets[index].max is None or buckets[index].max < array[i]:
+            buckets[index].max = array[i]
+    # 4.遍历桶，找到最大差值
+    left_max = buckets[0].max
+    max_distance = 0
+    for i in range(1, len(buckets)):
+        if buckets[i].min is None:
+            continue
+        if buckets[i].min - left_max > max_distance:
+            max_distance = buckets[i].min - left_max
+        left_max = buckets[i].max
+    return max_distance
+
+
+my_array = list([2, 6, 3, 4, 5, 10, 9])
+print(get_max_sorted_distance(my_array))

src/chapter5/part7/StackQueue.py

@@ -0,0 +1,30 @@
+class StackQueue:
+    def __init__(self):
+        self.stackA = []
+        self.stackB = []
+
+    def en_queue(self, element):
+        self.stackA.append(element)
+
+    def de_queue(self):
+        if len(self.stackB) == 0:
+            if len(self.stackA) == 0:
+                return None
+            self.transfer()
+        return self.stackB.pop()
+
+    def transfer(self):
+        while len(self.stackA) > 0:
+            self.stackB.append(self.stackA.pop())
+
+
+stack_queue = StackQueue()
+stack_queue.en_queue(1)
+stack_queue.en_queue(2)
+stack_queue.en_queue(3)
+print(stack_queue.de_queue())
+print(stack_queue.de_queue())
+stack_queue.en_queue(4)
+print(stack_queue.de_queue())
+print(stack_queue.de_queue())
+