樹與樹的算法的實現 ------ Python數據結構與算法第8章

1. 樹的概念

樹（tree）是一種抽象數據類型（ADT）或是作這種抽象數據類型的數據結構，用來模擬具有樹狀結構性質的數據集合。 它是由n（n>=1）個有限節點組成一個具有層次關係的集合。把它叫做“樹”是因爲它看起來像一棵倒掛的樹，也就是說它是根朝上，而葉朝下的。它具有以下的特點：

① 每個節點有零個或多個子節點
② 沒有父節點的節點稱爲根節點
③ 每一個非根節點有且只有一個父節點
④ 除了根節點外，每個子節點可以分爲多個不相交的子樹

2. 樹的術語

• 節點的度：一個節點含有子樹的個數稱爲該節點的度
• 樹的度：一棵樹中，最大的節點的度稱爲樹的度
• 葉子節點或終端節點：度爲零的節點
• 父親節點或父節點：若一個節點含有子節點，則這個節點稱爲其子節點的父節點
• 孩子節點或子節點：一個節點含有的子樹的根節點稱爲該節點的子節點
• 兄弟節點：具有相同父節點的節點互稱爲兄弟節點
• 節點的層次：從根開始定義起，根爲第1層，根的子節點爲第2層，以此類推
• 樹的高度或深度：樹中節點的最大層次
• 堂兄弟節點：父節點在同一層的節點互爲堂兄弟
• 節點的祖先：從根到該節點所經分支上的所有節點
• 子孫：以某節點爲根的子樹中任一節點都稱爲該節點的子孫
• 森林：由m（m>=0）棵互不相交的樹的集合稱爲森林

3. 樹的種類

樹分爲無序樹和有序樹，樹中任意節點的子節點之間沒有順序關係，這種樹稱爲無序樹，也稱爲自由樹。樹中任意節點的子節點之間有順序關係，這種樹稱爲有序樹。有序樹還可以進一步劃分：

① 二叉樹：每個節點最多含有 兩個 子樹的樹稱爲二叉樹

② 完全二叉樹：對於一顆二叉樹，假設其深度爲d(d>1)。除了第d層外，其它各層的節點數目均已達最大值，且第d層所有節點從左向右連續地緊密排列，這樣的二叉樹被稱爲完全二叉樹。其中滿二叉樹的定義是所有葉子節點都在最底層的完全二叉樹

③ 平衡二叉樹：當且僅當任何節點的兩棵子樹的 高度差不大於1的二叉樹

④ 排序二叉樹：也稱二叉搜索樹、有序二叉樹

⑤ 霍夫曼樹：帶權路徑最短 的二叉樹稱爲哈夫曼樹或最優二叉樹，用於信息編碼

⑥ B樹：一種對 讀寫操作進行優化的自平衡的二叉查找樹，能夠保持數據有序，擁有多於兩個子樹

4. 樹的存儲與表示

順序存儲：

將數據結構存儲在固定的數組中，在 遍歷速度上有一定的優勢，但因 所佔空間比較大，是非主流二叉樹。二叉樹通常以鏈式存儲。

鏈式存儲：

由於對節點的個數無法掌握，常見樹的存儲表示都轉換成二叉樹進行處理，子節點個數最多爲2。

5. 樹的應用場景

① xml、html等，那麼編寫這些格式文件的解析器不可避免用到樹
② 路由協議
③ mysql數據庫索引
④ 文件系統的目錄結構
⑤ 很多經典的 AI算法其實都是樹搜索，此外機器學習中的決策樹也是樹結構

6. 二叉樹的基本概念

二叉樹是每個節點最多有兩個子樹的樹結構。通常子樹被稱作“左子樹”（left subtree）和“右子樹”（right subtree）。

7. 二叉樹的性質

性質1: 在二叉樹的第i層上至多有 2^(i-1) 個結點（i>0）

性質2: 深度爲k的二叉樹至多有 2^{k - 1} 個結點（k>0）

性質3: 對於任意一棵二叉樹，如果其葉結點數爲N0，而度數爲2的結點總數爲N2，則N0=N2+1

性質4：具有n個結點的完全二叉樹的深度必爲 log2(n+1)

性質5：對完全二叉樹，若從上至下、從左至右編號，則編號爲i的結點，其左孩子編號必爲2i，其右孩子編號必爲2i＋1；其雙親的編號必爲i/2（i＝1 時爲根，除外）

完全二叉樹：如果設二叉樹的深度是h，除了h層以外，其它各層的節點數都達到了最大數。第h層有葉子節點，並且葉子節點都是從左到右依次排布

滿二叉樹：除了葉子結點外每一個結點都有左右子葉且葉子結點都處在最底層的二叉樹

8. 二叉樹的節點表示以及樹的創建

Node類中定義三個屬性，分別是節點本身的值，還有左孩子和右孩子：

class Node:
    def __init__(self, elem, l_child=None, r_child=None):
        self.elem = elem  # 節點本身的值
        self.l_child = l_child  # 左孩子
        self.r_child = r_child  # 右孩子

樹的創建，創建一個樹的類，並給一個根節點，一開始爲空，隨後添加節點：

class Node:
    def __init__(self, elem, l_child=None, r_child=None):
        self.elem = elem  # 節點本身的值
        self.l_child = l_child  # 左孩子
        self.r_child = r_child  # 右孩子

class Tree:
    def __init__(self, root=None):
        self.root = root

    def add_node(self, elem):
        # 創建一個節點
        node = Node(elem)
        # 如果根節點爲空，則爲根節點賦值
        if self.root == None:
            self.root = node
        # 否則繼續判斷
        else:
            # 創建一個隊列並加入根節點
            queue = [self.root]
            while queue:
                # 彈出第一個節點
                curr_node = queue.pop(0)
                # 如果該節點的左孩子爲空，則需要創建的節點賦給當前節點的左孩子節點
                if curr_node.l_child is None:
                    curr_node.l_child = node
                    return
                # 如果該節點的右孩子爲空，則需要創建的節點賦給當前節點的右孩子節點
                elif curr_node.r_child is None:
                    curr_node.r_child = node
                    return
                # 如果該節點的左孩子和右孩子都有值，則需要將左右孩子加入隊列繼續判斷它們有沒有孩子節點
                else:
                    queue.append(curr_node.l_child)
                    queue.append(curr_node.r_child)
                    
tree = Tree()
# 第一個賦值給根節點
tree.add_node('A')
# 爲根節點的左孩子賦值
tree.add_node('B')
# 爲根節點的右孩子賦值
tree.add_node('C')
# 爲根節點的左孩子的左孩子賦值
tree.add_node('D')
# 爲根節點的左孩子的右孩子賦值
tree.add_node('E')
# 爲根節點的右孩子的左孩子賦值
tree.add_node('F')
# 爲根節點的右孩子的右孩子賦值
tree.add_node('G')

9. 二叉樹的遍歷

樹的遍歷是樹的一種重要的運算。所謂遍歷是指對樹中所有結點的信息的訪問，即依次對樹中每個結點訪問一次且僅訪問一次，我們把這種對所有節點的訪問稱爲遍歷（traversal）。那麼樹的兩種重要的遍歷模式是深度優先遍歷和廣度優先遍歷,深度優先一般用遞歸，廣度優先一般用隊列。一般情況下能用遞歸實現的算法大部分也能用堆棧來實現。

10. 二叉樹廣度優先遍歷

廣度優先遍歷也就是層次遍歷，從樹的根節點開始，從上到下從從左到右遍歷整個樹的節點：

class Node:
    def __init__(self, elem, l_child=None, r_child=None):
        self.elem = elem  # 節點本身的值
        self.l_child = l_child  # 左孩子
        self.r_child = r_child  # 右孩子

class Tree:
    def __init__(self, root=None):
        self.root = root

    def add_node(self, elem):
        # 創建一個節點
        node = Node(elem)
        # 如果根節點爲空，則爲根節點賦值
        if self.root == None:
            self.root = node
        # 否則繼續判斷
        else:
            # 創建一個隊列並加入根節點
            queue = [self.root]
            while queue:
                # 彈出第一個節點
                curr_node = queue.pop(0)
                # 如果該節點的左孩子爲空，則需要創建的節點賦給當前節點的左孩子節點
                if curr_node.l_child is None:
                    curr_node.l_child = node
                    return
                # 如果該節點的右孩子爲空，則需要創建的節點賦給當前節點的右孩子節點
                elif curr_node.r_child is None:
                    curr_node.r_child = node
                    return
                # 如果該節點的左孩子和右孩子都有值，則需要將左右孩子加入隊列繼續判斷它們有沒有孩子節點
                else:
                    queue.append(curr_node.l_child)
                    queue.append(curr_node.r_child)

    def breadth_traversal(self):
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            curr_node = queue.pop(0)
            print(curr_node.elem)
            if curr_node.l_child is not None:
                queue.append(curr_node.l_child)
            if curr_node.r_child is not None:
                queue.append(curr_node.r_child)

tree = Tree()
# 第一個賦值給根節點
tree.add_node('A')
# 爲根節點的左孩子賦值
tree.add_node('B')
# 爲根節點的右孩子賦值
tree.add_node('C')
# 爲根節點的左孩子的左孩子賦值
tree.add_node('D')
# 爲根節點的左孩子的右孩子賦值
tree.add_node('E')
# 爲根節點的右孩子的左孩子賦值
tree.add_node('F')
# 爲根節點的右孩子的右孩子賦值
tree.add_node('G')
tree.breadth_traversal()
"""
A
B
C
D
E
F
G
"""

11. 二叉樹深度優先遍歷

對於一顆二叉樹，深度優先搜索(Depth First Search)是沿着樹的深度遍歷樹的節點，儘可能深的搜索樹的分支。那麼深度遍歷有重要的三種方法。這三種方式常被用於訪問樹的節點，它們之間的不同在於訪問每個節點的次序不同。這三種遍歷分別叫做先序遍歷（preorder），中序遍歷（inorder）和後序遍歷（postorder）。

① 先序遍歷。在先序遍歷中，我們先訪問根節點，然後遞歸使用先序遍歷訪問左子樹，再遞歸使用先序遍歷訪問右子樹。遍歷的順序是：根節點->左子樹->右子樹

def preorder_traversal(self, root):
    """遞歸實現先序遍歷"""
    if root is None:
        return
    print(root.elem, end=' ')
    self.preorder_traversal(root.l_child)
    self.preorder_traversal(root.r_child)

② 中序遍歷。在中序遍歷中，我們遞歸使用中序遍歷訪問左子樹，然後訪問根節點，最後再遞歸使用中序遍歷訪問右子樹。遍歷的順序是：左子樹->根節點->右子樹

def inorder_traversal(self, root):
    """遞歸實現中序遍歷"""
    if root is None:
        return
    self.inorder_traversal(root.l_child)
    print(root.elem, end=' ')
    self.inorder_traversal(root.r_child)

③ 後序遍歷。在後序遍歷中，我們先遞歸使用後序遍歷訪問左子樹和右子樹，最後訪問根節點。遍歷的順序是：左子樹->右子樹->根節點

def postorder_traversal(self, root):
    """遞歸實現後續遍歷"""
    if root is None:
        return
    self.postorder_traversal(root.l_child)
    self.postorder_traversal(root.r_child)
    print(root.elem, end=' ')

完整的遍歷測試：

class Node:
    def __init__(self, elem, l_child=None, r_child=None):
        self.elem = elem  # 節點本身的值
        self.l_child = l_child  # 左孩子
        self.r_child = r_child  # 右孩子

class Tree:
    def __init__(self, root=None):
        self.root = root

    def add_node(self, elem):
        # 創建一個節點
        node = Node(elem)
        # 如果根節點爲空，則爲根節點賦值
        if self.root == None:
            self.root = node
        # 否則繼續判斷
        else:
            # 創建一個隊列並加入根節點
            queue = [self.root]
            while queue:
                # 彈出第一個節點
                curr_node = queue.pop(0)
                # 如果該節點的左孩子爲空，則需要創建的節點賦給當前節點的左孩子節點
                if curr_node.l_child is None:
                    curr_node.l_child = node
                    return
                # 如果該節點的右孩子爲空，則需要創建的節點賦給當前節點的右孩子節點
                elif curr_node.r_child is None:
                    curr_node.r_child = node
                    return
                # 如果該節點的左孩子和右孩子都有值，則需要將左右孩子加入隊列繼續判斷它們有沒有孩子節點
                else:
                    queue.append(curr_node.l_child)
                    queue.append(curr_node.r_child)

    def breadth_traversal(self):
        """廣度優先遍歷/層次遍歷"""
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            curr_node = queue.pop(0)
            print(curr_node.elem, end=' ')
            if curr_node.l_child is not None:
                queue.append(curr_node.l_child)
            if curr_node.r_child is not None:
                queue.append(curr_node.r_child)

    def preorder_traversal(self, root):
        """遞歸實現先序遍歷"""
        if root is None:
            return
        print(root.elem, end=' ')
        self.preorder_traversal(root.l_child)
        self.preorder_traversal(root.r_child)

    def inorder_traversal(self, root):
        """遞歸實現中序遍歷"""
        if root is None:
            return
        self.inorder_traversal(root.l_child)
        print(root.elem, end=' ')
        self.inorder_traversal(root.r_child)

    def postorder_traversal(self, root):
        """遞歸實現後續遍歷"""
        if root is None:
            return
        self.postorder_traversal(root.l_child)
        self.postorder_traversal(root.r_child)
        print(root.elem, end=' ')

tree = Tree()
# 第一個賦值給根節點
tree.add_node(0)
# 爲根節點的左孩子賦值
tree.add_node(1)
# 爲根節點的右孩子賦值
tree.add_node(2)
# 爲根節點的左孩子的左孩子賦值
tree.add_node(3)
# 爲根節點的左孩子的右孩子賦值
tree.add_node(4)
# 爲根節點的右孩子的左孩子賦值
tree.add_node(5)
# 爲根節點的右孩子的右孩子賦值
tree.add_node(6)
tree.add_node(7)
tree.add_node(8)
tree.add_node(9)
print('廣度優先遍歷(層次遍歷)：', end='')
tree.breadth_traversal()
print('\n前序遍歷：', end='')
tree.preorder_traversal(tree.root)
print('\n中序遍歷：', end='')
tree.inorder_traversal(tree.root)
print('\n後序遍歷：', end='')
tree.postorder_traversal(tree.root)
"""
廣度優先遍歷(層次遍歷)：0 1 2 3 4 5 6 7 8 9 
前序遍歷：0 1 3 7 8 4 9 2 5 6 
中序遍歷：7 3 8 1 9 4 0 5 2 6 
後序遍歷：7 8 3 9 4 1 5 6 2 0 
"""

Github：https://github.com/ThanlonSmith/Data-Structure-Python3