二叉樹詳解(python)

樹與樹算法

樹的概念

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

• 每個節點有零個或多個子節點；
• 沒有父節點的節點稱為根節點；
• 每一個非根節點有且只有一個父節點；
• 除了根節點外，每個子節點可以分為多個不相交的子樹；

比如說：

 

 

 

 

樹的術語

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

樹的種類

• 無序樹：樹中任意節點的子節點之間沒有順序關系，這種樹稱為無序樹，也稱為自由樹；
• 有序樹：樹中任意節點的子節點之間有順序關系，這種樹稱為有序樹；
  • 二叉樹：每個節點最多含有兩個子樹的樹稱為二叉樹；
    • 完全二叉樹：對於一顆二叉樹，假設其深度為d(d>1)。除了第d層外，其它各層的節點數目均已達最大值，且第d層所有節點從左向右連續地緊密排列，這樣的二叉樹被稱為完全二叉樹，其中滿二叉樹的定義是所有葉節點都在最底層的完全二叉樹;
    • 平衡二叉樹（AVL樹）：當且僅當任何節點的兩棵子樹的高度差不大於1的二叉樹；
    • 排序二叉樹（二叉查找樹（英語：Binary Search Tree），也稱二叉搜索樹、有序二叉樹）；
  • 霍夫曼樹（用於信息編碼）：帶權路徑最短的二叉樹稱為哈夫曼樹或最優二叉樹；
  • B樹：一種對讀寫操作進行優化的自平衡的二叉查找樹，能夠保持數據有序，擁有多余兩個子樹。

樹的存儲與表示

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

 

 

鏈式存儲：

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

常見的一些樹的應用場景

1. xml，html等，那么編寫這些東西的解析器的時候，不可避免用到樹
2. 路由協議就是使用了樹的算法
3. mysql數據庫索引
4. 文件系統的目錄結構
5. 所以很多經典的AI算法其實都是樹搜索，此外機器學習中的decision tree也是樹結構

 

 

 

二叉樹

二叉樹的基本概念

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

二叉樹的性質(特性)

性質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 時為根,除外）

(1)完全二叉樹——若設二叉樹的高度為h，除第 h 層外，其它各層 (1～h-1) 的結點數都達到最大個數，第h層有葉子結點，並且葉子結點都是從左到右依次排布，這就是完全二叉樹。

 

 

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

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

通過使用Node類中定義三個屬性，分別為elem本身的值，還有lchild左孩子和rchild右孩子

class Note(object):
    """
    構造節點

    """
    def __init__(self, item):
        self.elem = item    # 節點
        self.lchild = None  # 左子節點
        self.rchild = None  # 右子節點

樹的創建,創建一個樹的類，並給一個root根節點，一開始為空，隨后添加節點

class Tree(object):
    def __init__(self):
        """初始化一個空的二叉樹"""
        self.root = None

    def add(self, item):
        """添加元素到最后"""
        node = Note(item)
        if self.root is None:
            self.root = node
        else:
            queue = [self.root]  # 利用列表實現一個隊列
            while queue:
                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)

二叉樹的遍歷

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

深度優先遍歷

對於一顆二叉樹，深度優先搜索(Depth First Search)是沿着樹的深度遍歷樹的節點，盡可能深的搜索樹的分支。
那么深度遍歷有重要的三種方法。這三種方式常被用於訪問樹的節點，它們之間的不同在於訪問每個節點的次序不同。這三種遍歷分別叫做先序遍歷（preorder），中序遍歷（inorder）和后序遍歷（postorder）。我們來給出它們的詳細定義，然后舉例看看它們的應用。

　　　　(1) 先序遍歷 在先序遍歷中，我們先訪問根節點，然后遞歸使用先序遍歷訪問左子樹，再遞歸使用先序遍歷訪問右子樹
　　　　　　根節點->左子樹->右子樹

def preorder(self, root):
      """遞歸實現先序遍歷"""
      if root == None:
          return
      print root.elem
      self.preorder(root.lchild)
      self.preorder(root.rchild)

　　　　(2) 中序遍歷 在中序遍歷中，我們遞歸使用中序遍歷訪問左子樹，然后訪問根節點，最后再遞歸使用中序遍歷訪問右子樹
　　　　　　左子樹->根節點->右子樹　

def inorder(self, root):
      """遞歸實現中序遍歷"""
      if root == None:
          return
      self.inorder(root.lchild)
      print root.elem
      self.inorder(root.rchild)

　　　　(3) 后序遍歷 在后序遍歷中，我們先遞歸使用后序遍歷訪問左子樹和右子樹，最后訪問根節點
　　　　　　左子樹->右子樹->根節點

def postorder(self, root):
      """遞歸實現后續遍歷"""
      if root == None:
          return
      self.postorder(root.lchild)
      self.postorder(root.rchild)
      print root.elem

 

廣度優先遍歷(層次遍歷)

從樹的root開始，從上到下從從左到右遍歷整個樹的節點

class Note(object):
    """
    構造節點

    """
    def __init__(self, item):
        self.elem = item    # 節點
        self.lchild = None  # 左子節點
        self.rchild = None  # 右子節點


class Tree(object):
    def __init__(self):
        """初始化一個空的二叉樹"""
        self.root = None

    def add(self, item):
        """添加元素到最后"""
        node = Note(item)
        if self.root is None:
            self.root = node
        else:
            queue = [self.root]  # 利用列表實現一個隊列
            while queue:
                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 == None:
            return
        queue = []
        queue.append(self.root)
        while queue:
            node = queue.pop(0)
            print(node.elem)
            if node.lchild != None:
                queue.append(node.lchild)
            if node.rchild != None:
                queue.append(node.rchild)

if __name__ == '__main__':
    tree = Tree()
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.breadth_travel()