26数据结构day04完成

Author: HaoZhang95

26数据结构/day03/06_merge_sort.py

@@ -1,7 +1,30 @@
 
-def merge_sort(alist, first, last):
+def merge_sort(alist):
 
     """
         归并排序:对数组进行对半拆分，直到每个只有一个元素，然后进行合并
         合并中
     """
+    n = len(alist)
+    if n <= 1:
+        return alist
+
+    mid = n // 2
+    left_li = merge_sort(alist[:mid])
+    right_li = merge_sort(alist[mid:])
+
+    left_pointer, right_pointer = 0, 0
+    result = []
+
+    while left_pointer < len(left_li) and right_pointer < len(right_li):
+
+        if left_li[left_pointer] < right_li[right_pointer]:
+            result.append(left_li[left_pointer])
+            left_pointer += 1
+        else:
+            result.append(right_li[right_pointer])
+            right_pointer += 1
+
+    result += left_li[left_pointer:]
+    result += right_li[right_pointer:]
+    return result

26数据结构/day04/01_binary_search.py

@@ -1,5 +1,43 @@
-def binary_search(alist):
+def binary_search(alist, item):
     """二分法查找，递归方法"""
 
     n = len(alist)
-    mid = n // 2
+    mid = n // 2
+
+    if n > 0:
+
+        if alist[mid] == item:
+            return True
+        elif item < alist[mid]:
+            # 产生新的列表进行递归
+            return binary_search(alist[:mid], item)
+        else:
+            return binary_search(alist[mid:], item)
+
+    return False
+
+
+"""
+    二分法查找的折半查找，操作的对象必须有序，其次计算mid需要index需要顺序表才行
+    时间复杂度为 折半2的几次方等于n，最坏所以为 O(logn)，最好就是O(1)
+"""
+
+
+def binary_search_2(alist, item):
+    """二分法查找，非递归方法"""
+
+    n = len(alist)
+    first = 0
+    last = n - 1
+
+    while first <= last:
+
+        mid = (first + last) // 2
+
+        if item == alist[mid]:
+            return True
+        elif item < alist[mid]:
+            last = mid - 1
+        else:
+            first = mid + 1
+    return False

26数据结构/day04/02_tree.py

@@ -0,0 +1,98 @@
+"""
+    树分为好多种，二叉树就是一个父节点最多只能包含两个子节点，树的度最多为2
+
+    完全二叉树：如果有n层，那么除了最底层之外的节点都挂满了子节点，父节点都达到了最大的度
+    满二叉树：所有节点都达到最大的度，包含最底层
+    平衡二叉树：当且仅当任意一个节点的**两颗子树**的高度差不大于1的二叉树
+    有序二叉树：树的每一个节点都是有序的，根节点左边的节点都比根节点小，右边的都比根节点大
+"""
+
+"""
+    树的存储：
+    如果采用顺序存储的话,那么以数组的方式，装完一层之后去装下一层的节点，虽然遍历上有优势，但是占用空间大，非主流的存储方式
+    一般采用的就是链式的存储方式，树常用在xml,html的解析中，mysql的索引，路由协议，文件系统的目录结构
+"""
+
+
+class Node(object):
+    """树的结构类似于链表的扩充，也需要节点"""
+
+    def __init__(self, elem=None, lchild=None, rchild=None):
+        self.elem = elem
+        self.lchild = lchild
+        self.rchild = rchild
+
+
+class Tree(object):
+
+    def __init__(self, root):
+        self.root = root
+
+    def add(self, item):
+        """完全二叉树的添加，那一层缺元素的话那么就直接添加到该层的节点，那一层的节点没满就添加到此处"""
+        node = Node(item)
+        if self.root is None:
+            self.root = node
+            return
+
+        queue = [self.root]
+        while queue:
+            # 只要队列存在元素，就pop判断
+            cur_node = queue.pop(0)
+            if cur_node.lchild is None:
+                cur_node.lchild = node
+                return
+            else:
+                queue.append(cur_node.lchild)
+
+            if cur_node.rchild is None:
+                cur_node.rchild = node
+                return
+            else:
+                queue.append(cur_node.rchild)
+
+    def breadth_travel(self):
+        """广度遍历"""
+        if self.root is None:
+            return
+
+        queue = [self.root]
+        while queue:
+
+            cur_node = queue.pop(0)
+            print(cur_node)
+
+            if cur_node.lchild is not None:
+                queue.append(cur_node.lchild)
+            if cur_node.rchild is not None:
+                queue.append(cur_node.rchild)
+
+    def pre_order(self, node):
+        """深度遍历中的先序便利，根节点先， 根 -> 左 -> 右"""
+
+        if node is None:
+            return
+
+        print(node.elem)
+        self.pre_order(node.lchild)
+        self.pre_order(node.rchild)
+
+    def in_order(self, node):
+        """深度遍历中的中序便利，根节点在中，  左 -> 根 -> 右"""
+
+        if node is None:
+            return
+
+        self.in_order(node.lchild)
+        print(node.elem)
+        self.in_order(node.rchild)
+
+    def post_order(self, node):
+        """深度遍历中的后序便利，根节点在后， 左 -> 右 -> 后"""
+
+        if node is None:
+            return
+
+        self.post_order(node.lchild)
+        self.post_order(node.rchild)
+        print(node.elem)

26数据结构/day04/__init__.py

@@ -9,7 +9,7 @@
 |Author|白发老书生|
 |---|---
 |E-mail|Github联系
-> 最近更新至第23章节（共30章节）：2019-05-08
+> 最近更新至第26章节（共30章节）：2019-07-01
 
 ****
 
@@ -56,7 +56,7 @@
 - [x] [23电商爬虫和Scrapy框架](/23电商爬虫和Scrapy框架/README.md)
 - [x] [24自动化运维](/24自动化运维/README.md)
 - [x] [25项目环境自动化部署](/25项目环境自动化部署/README.md)
-- [ ] [26数据结构](/26数据结构/README.md)
+- [x] [26数据结构](/26数据结构/README.md)
 - [ ] [27数据挖掘](/27数据挖掘/README.md)