Add files via upload

Author: bjweimengshu

src/chapter1/part2/TimeComplex.py

@@ -0,0 +1,30 @@
+def eat1(n):
+    for i in range(n):
+        print("等待1min")
+        print("等待1min")
+        print("吃1cm面包")
+
+
+def eat2(n):
+    while n > 1:
+        print("等待1min")
+        print("等待1min")
+        print("等待1min")
+        print("等待1min")
+        print("吃一半面包")
+        n /= 2
+
+
+def eat3(n):
+    print("等待1min")
+    print("吃一个鸡腿")
+
+
+def eat4(n):
+    for i in range(n):
+        for j in range(i):
+            print("等待1min")
+        print("吃1cm面包")
+
+
+eat4(16)

src/chapter1/part3/SpaceComplex.py

@@ -0,0 +1,22 @@
+def fun1(n):
+    i = 3
+    # do something
+
+
+def fun2(n):
+    array = [[0] * n]
+    # do something
+
+
+def fun3(n):
+    matrix = [[0] * n] * n
+    # do something
+
+
+def fun4(n):
+    if n > 0:
+        fun4(n-1)
+    # do something
+
+
+fun2(10)

src/chapter2/part1/ListOperator.py

@@ -0,0 +1,27 @@
+
+
+def operate_list():
+    # 初始化列表
+    my_list = [3, 1, 2, 5, 4, 9, 7, 2]
+
+    # 读取元素
+    print(my_list[2])
+
+    # 更新元素
+    my_list[3] = 10
+    print(my_list[3])
+
+    # 尾部插入元素
+    my_list.append(6)
+    print(my_list)
+
+    # 中间插入元素
+    my_list.insert(5, 11)
+    print(my_list)
+
+    # 删除元素
+    my_list.remove(6)
+    print(my_list)
+
+
+operate_list()

src/chapter2/part1/MyArray.py

@@ -0,0 +1,61 @@
+
+class MyArray:
+    def __init__(self, capacity):
+        self.array = [None] * capacity
+        self.size = 0
+
+    def insert(self, index, element):
+        # 判断访问下标是否超出范围
+        if index < 0 or index > self.size:
+            print("超出列表实际元素范围！")
+        # 从右向左循环，逐个元素向右挪一位。
+        for i in range(self.size-1, -1, -1):
+            self.array[i+1] = self.array[i]
+        # 腾出的位置放入新元素
+        self.array[index] = element
+        self.size += 1
+
+    def insert_v2(self, index, element):
+        # 判断访问下标是否超出范围
+        if index < 0 or index > self.size:
+            print("超出列表实际元素范围！")
+        # 如果实际元素达到数组容量上线，数组扩容
+        if self.size >= len(self.array):
+            self.resize()
+        # 从右向左循环，逐个元素向右挪一位。
+        for i in range(self.size-1, -1, -1):
+            self.array[i+1] = self.array[i]
+        # 腾出的位置放入新元素
+        self.array[index] = element
+        self.size += 1
+
+    def resize(self):
+        array_new = [None] * len(self.array) * 2
+        # 从旧数组拷贝到新数组
+        for i in range(self.size):
+            array_new[i] = self.array[i]
+        self.array = array_new
+
+    def remove(self, index):
+        # 判断访问下标是否超出范围
+        if index < 0 or index >= self.size:
+            print("超出列表实际元素范围！")
+        # 从左到右，逐个元素向左挪动一位
+        for i in range(index, self.size):
+            self.array[i] = self.array[i+1]
+        self.size -= 1
+
+    def output(self):
+        for i in range(self.size):
+            print(self.array[i])
+
+
+array = MyArray(4)
+array.insert_v2(0, 10)
+array.insert_v2(0, 11)
+array.insert_v2(0, 15)
+array.remove(1)
+array.output()
+
+
+

src/chapter2/part2/MyLinkedList.py

@@ -0,0 +1,84 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+
+class LinkedList:
+    def __init__(self):
+        self.size = 0
+        self.head = None
+        self.last = None
+
+    def get(self, index):
+        if index < 0 or index >= self.size:
+            print('超出链表节点范围！')
+            return
+        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
+        node = Node(data)
+        if self.size == 0:
+            # 空链表
+            self.head = node
+            self.last = node
+        elif index == 0:
+            # 插入头部
+            node.next = self.head
+            self.head = node
+        elif self.size == index:
+            # 插入尾部
+            self.last.next = node
+            self.last = node;
+        else:
+            # 插入中间
+            prev_node = self.get(index-1)
+            node.next = prev_node.next
+            prev_node.next = node
+        self.size += 1
+
+    def remove(self, index):
+        if index < 0 or index >= self.size:
+            print('超出链表节点范围！')
+            return
+        # 暂存被删除的节点，用于返回
+        if index == 0:
+            # 删除头节点
+            removed_node = self.head
+            self.head = self.head.next
+        elif index == self.size - 1:
+            # 删除尾节点
+            prev_node = self.get(index-1)
+            removed_node = prev_node.next
+            prev_node.next = None
+            self.last = prev_node
+        else:
+            # 删除中间节点
+            prev_node = self.get(index-1)
+            next_node = prev_node.next.next
+            removed_node = prev_node.next
+            prev_node.next = next_node
+        self.size -= 1
+        return removed_node
+
+    def output(self):
+        p = self.head
+        while p is not None:
+            print(p.data)
+            p = p.next
+
+
+linkedList = LinkedList()
+linkedList.insert(3, 0)
+linkedList.insert(4, 0)
+linkedList.insert(9, 2)
+linkedList.insert(5, 3)
+linkedList.insert(6, 1)
+linkedList.remove(0)
+linkedList.output()

src/chapter2/part3/MyQueue.py

@@ -0,0 +1,38 @@
+
+class MyQueue:
+    def __init__(self, capacity):
+        self.list = [None] * capacity
+        self.front = 0
+        self.rear = 0
+
+    def enqueue(self, element):
+        if (self.rear+1) % len(self.list) == self.front:
+            print('队列已满！')
+            return
+        self.list[self.rear] = element
+        self.rear = (self.rear+1) % len(self.list)
+
+    def dequeue(self):
+        if self.rear == self.front:
+            print('队列为空！')
+            return
+        dequeue_element = self.list[self.front]
+        self.front = (self.front+1) % len(self.list)
+        return dequeue_element
+
+    def output(self):
+        i = self.front
+        while i != self.rear:
+            print(self.list[i])
+            i = (i+1) % len(self.list)
+
+
+myQueue = MyQueue(6)
+myQueue.enqueue(3)
+myQueue.enqueue(5)
+myQueue.enqueue(6)
+myQueue.dequeue()
+myQueue.dequeue()
+myQueue.enqueue(2)
+myQueue.enqueue(4)
+myQueue.output()

src/chapter3/part2/BinaryTreeTraversal.py

@@ -0,0 +1,57 @@
+
+
+class TreeNode:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+def create_binary_tree(input_list=[]):
+    if input_list is None or len(input_list) == 0:
+        return None
+    data = input_list.pop(0)
+    if data is None:
+        return None
+    node = TreeNode(data)
+    node.left = create_binary_tree(input_list)
+    node.right = create_binary_tree(input_list)
+    return node
+
+
+def pre_order_traversal(node):
+    if node is None:
+        return
+    print(node.data)
+    pre_order_traversal(node.left)
+    pre_order_traversal(node.right)
+    return node
+
+
+def in_order_traversal(node):
+    if node is None:
+        return
+    in_order_traversal(node.left)
+    print(node.data)
+    in_order_traversal(node.right)
+    return node
+
+
+def post_order_traversal(node):
+    if node is None:
+        return
+    post_order_traversal(node.left)
+    post_order_traversal(node.right)
+    print(node.data)
+    return node
+
+
+my_input_list = list([3, 2, 9, None, None, 10, None, None, 8, None, 4])
+root = create_binary_tree(my_input_list)
+print("前序遍历：")
+pre_order_traversal(root)
+print("中序遍历：")
+in_order_traversal(root)
+print("后序遍历：")
+post_order_traversal(root)
+

src/chapter3/part2/BinaryTreeTraversalLevel.py

@@ -0,0 +1,42 @@
+from queue import Queue
+
+
+def level_order_traversal(node):
+    queue = Queue()
+    queue.put(node)
+    while not queue.empty():
+        node = queue.get()
+        print(node.data)
+        if node.left is not None:
+            queue.put(node.left)
+        if node.right is not None:
+            queue.put(node.right)
+
+
+def create_binary_tree(input_list=[]):
+    if input_list is None or len(input_list) == 0:
+        return None
+    data = input_list.pop(0)
+    if data is None:
+        return None
+    node = TreeNode(data)
+    node.left = create_binary_tree(input_list)
+    node.right = create_binary_tree(input_list)
+    return node
+
+
+class TreeNode:
+    def __init__(self, data):
+        self.data = data
+        self.left = None
+        self.right = None
+
+
+my_input_list = list([3, 2, 9, None, None, 10, None, None, 8, None, 4])
+root = create_binary_tree(my_input_list)
+print("层序遍历：")
+level_order_traversal(root)
+
+
+
+