Python超全乾貨：【二叉樹】基礎知識大全

概念

二叉樹是每一個節點最多有兩個子樹的樹結構。一般子樹被稱做「左子樹」（left subtree）和「右子樹」（right subtree）

二叉樹的鏈式存儲：

將二叉樹的節點定義爲一個對象，節點之間經過相似鏈表的連接方式來鏈接。

樹的定義與基本術語

樹型結構是一類重要的非線性數據結構，其中以樹和二叉樹最爲經常使用，是以分支關係定義的層次結構。樹結構在客觀世界中普遍存在，如人類社會的族譜和各類社會組織機構；在計算機領域中也有普遍應用，如在編譯程序中，可用樹來表示源程序的語法結構；在數據庫系統中，樹型結構也是信息的重要組織形式之一；在機器學習中，決策樹，隨機森林，GBDT等是常見的樹模型。
樹（Tree）是n(n>=0)個結點的有限集。在任意一棵樹中：（1）有且僅有一個特定的稱爲根（Root）的節點；（2）當n>1時，其他節點可分爲m(m>0)個互不相交的有限集，其中每個集合自己又是一棵樹，而且稱爲根的子樹（SubTree）。

圖1 樹型結構

在圖1，該樹一共有13個節點，其中A是根，其他節點分紅3個互不相交的子集：

T1={B,E,F,K,L}，T2={C,G}，T3={D,H,I,J,K}；T1,T2,T3都是根A的子樹，且自己也是一顆樹。

例如T1，其根爲B，其他節點分爲兩個互不相交的子集；T11={E,K,L},T12={F}。T11和T12都是B的子樹。而在T11中E是根，{K}和{L}是E的兩棵互不相交的子樹，其自己又是隻有一個根節點的樹。

樹的基本術語

樹的結點包含一個數據元素及若干指向其子樹的分支。

節點擁有的子樹數量稱爲節點的度（Degree）。

在圖1中，A的度爲3，B的度爲2，C的度爲1，F的度爲0。

度爲0的結點稱爲葉子（Leaf）結點。

在圖1中，K,L,F,G,M,I,J都是該樹的葉子。度不爲0的結點稱爲分支結點。

樹的度是指樹內個結點的度的最大值。

結點的子樹的根稱爲該結點的孩子（Child），相應地，該結點稱爲孩子的雙親（Parent）

在圖1,中，D是A的孩子，A是D的雙親。同一個雙親的孩子之間互稱兄弟(Sibling)

H,I,J互爲兄弟。結點的祖先是從根到該結點所經分支上的全部結點，M的祖先爲A,D,H。

對應地，以某結點爲根的子樹中的任一結點都稱爲該結點的子孫。B的子孫爲E,F,K,L。

樹的層次(Level)是從根開始，根爲第一層，根的孩子爲第二層等。雙親在同一層的結點互爲同兄弟。圖1中，K,L,M互爲堂兄弟。樹中結點的最大層次稱爲樹的深度(Depth)或高度，樹的深度爲4。

若是將樹中結點的各子樹當作從左到右是有次序的（即不能交換），則稱該樹爲有序樹，不然爲無序樹。

森林（Forest）是m(m>=0)棵互不相交的樹的集合。對樹中每一個結點而言，其子樹的集合即爲森林。

在機器學習模型中，決策樹爲樹型結構，而隨機森林爲森林，是由若干決策樹組成的森林。

性質

性質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.滿二叉樹——除了葉結點外每個結點都有左右子葉且葉子結點都處在最底層的二叉樹。

二叉樹Python實現

class Node(object):
    """節點類"""
    def __init__(self, elem=-1, lchild=None, rchild=None):
        self.elem = elem  # 自身
        self.lchild = lchild  # 左孩子
        self.rchild = rchild  # 右孩子
class Tree(object):
    """樹類"""
    def __init__(self, root=None):
        self.root = root

    def add(self, elem):
        node = Node(elem)
        if self.root == None:
            self.root = node
        else:
            queue = []
            queue.append(self.root)  # 先將根節點添加到隊列中
            while queue:  # 遍歷樹
                cur = queue.pop(0)  # 首先彈出了根節點
                if cur.lchild == None:  # 若是沒有作孩子的話
                    cur.lchild = node  # 添加node
                    return
                elif cur.rchild == None:  # 若是沒有有孩子的話
                    cur.rchild = node
                    return
                else:  # 若是左右子樹都不爲空，加入隊列繼續判斷
                    queue.append(cur.lchild) 
                    queue.append(cur.rchild)

 

二叉樹的遍歷：

常見的遍歷方法有：先序遍歷，中序遍歷，後序遍歷，層序遍歷。這些遍歷方法通常使用遞歸算法實現。

前序遍歷：EACBDGF

前序遍歷的操做定義爲：若二叉樹爲空，爲空操做；不然（1）訪問根節點；（2）先序遍歷左子樹；（3）先序遍歷右子樹。

遞歸實現：

def preorder(root):
    if not root:
        return 
    print(root.val)
    preorder(root.left)
    preorder(root.right)

迭代實現：

def preorder(root):
    stack = [root]
    while stack:
        s = stack.pop()
        if s:
            print(s.val)
            stack.append(s.right)
            stack.append(s.left)

中序遍歷：ABCDEGF

中序遍歷的操做定義爲：若二叉樹爲空，爲空操做；不然（1）中序遍歷左子樹；（2）訪問根結點；（3）中序遍歷右子樹。

遞歸實現：

def inorder(root):
    if not root:
        return 
    inorder(root.left)
    print(root.val)
    inorder(root.right)

迭代實現：

def inorder(root):
    stack = []
    while stack or root:
        while root:
            stack.append(root)
            root = root.left
        root = stack.pop()
        print(root.val)
        root = root.right

後序遍歷：BDCAFGE

後序遍歷的操做定義爲：若二叉樹爲空，爲空操做；不然（1）後序遍歷左子樹；（2）後序遍歷右子樹；（3）訪問根結點。

遞歸實現：

def postorder(root):
    if not root:
        return 
    postorder(root.left)
    postorder(root.right)
    print(root.val)

迭代實現：

def postorder(root):
    stack = []
    while stack or root:
        while root:                 # 下行循環，直到找到第一個葉子節點

            stack.append(root)
            if root.left:           # 能左就左，不能左就右

                root = root.left 
            else:
                root = root.right     
        s = stack.pop()
        print(s.val)
        #若是當前節點是上一節點的左子節點，則遍歷右子節點

        if stack and s == stack[-1].left: 

            root = stack[-1].right
        else:
            root = None

層次遍歷：EAGCFBD

層序遍歷的操做定義爲：若二叉樹爲空，爲空操做；不然從上到下、從左到右按層次進行訪問。

遞歸實現：

def BFS(root):
    queue = [root]
    while queue:
        n = len(queue)
        for i in range(n):
            q = queue.pop(0)
            if q:
                print(q.val)
                queue.append(q.left if q.left else None)
                queue.append(q.right if q.right else None)

代碼實現：

# _*_ coding=utf-8 _*_


"""
實現一個二叉樹結果，並進行遍歷
             E
           /  \
          A    G
           \    \
            C    F
           / \
          B   D
"""
from collections import deque


class BinaryTree(object):
    def __init__(self, data):
        self.data = data
        self.child_l = None
        self.child_r = None


# 建立
a = BinaryTree("A")
b = BinaryTree("B")
c = BinaryTree("C")
d = BinaryTree("D")
e = BinaryTree("E")
f = BinaryTree("F")
g = BinaryTree("G")

# 構造節點關係
e.child_l = a
e.child_r = g
a.child_r = c
c.child_l = b
c.child_r = d
g.child_r = f

# 設置根
root = e


def pre_order(tree):
    """
    前序遍歷:root -> child_l -> child_r
    :param tree: the root of tree
    :return:
    """
    if tree:
        print(tree.data, end=',')
        # print("")
        pre_order(tree.child_l)
        pre_order(tree.child_r)


def in_order(tree):
    """
    中序遍歷：child_l -> root -> child_r
    :param tree:
    :return:
    """
    if tree:
        in_order(tree.child_l)
        print(tree.data, end=',')
        in_order(tree.child_r)


def post_order(tree):
    """
    後序遍歷：child_l -> child_r -> root
    :param tree:
    :return:
    """
    if tree:
        post_order(tree.child_l)
        post_order(tree.child_r)
        print(tree.data, end=',')


def level_order(tree):
    """
    層次遍歷：E -> AG -> CF -> BD
    使用隊列實現
    :param tree:
    :return:
    """
    queue = deque()
    queue.append(tree)          # 先把根添加到隊列
    while len(queue):           # 隊列不爲空
        node = queue.popleft()
        print(node.data, end=',')
        if node.child_l:
            queue.append(node.child_l)
        if node.child_r:
            queue.append(node.child_r)


pre_order(root)
print('')
in_order(root)
print('')
post_order(root)
print('')
level_order(root)

二叉樹的最大深度

基本思路就是遞歸，當前樹的最大深度等於（1+max(左子樹最大深度，右子樹最大深度)）。代碼以下：

def maxDepth(root):

    if not root:
        return 0
    return 1+max(maxDepth(root.left),maxDepth(root.right))

二叉樹的最小深度

最小深度是從根節點到最近葉子節點的最短路徑上的節點數量。能夠經過遞歸求左右節點的最小深度的較小值，也能夠層序遍歷找到第一個葉子節點所在的層數。

遞歸方法：

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        if not root.left and not root.right:
            return 1 
        if not root.right:
            return 1+self.minDepth(root.left)
        if not root.left:
            return 1+self.minDepth(root.right)
        return 1+min(self.minDepth(root.left),self.minDepth(root.right))

迭代方法：

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if not root: return 0
        ans,count = [root],1
        while ans:
            n = len(ans)
            for i in range(n):
                r = ans.pop(0)
                if r:
                    if not r.left and not r.right:
                        return count
                    ans.append(r.left if r.left else [])
                    ans.append(r.right if r.right else [])
            count+=1

二叉樹的全部路徑

根節點到葉子節點的全部路徑。

def traverse(node):
    if not node.left and not node.right:
        return [str(node.val)]
    left, right = [], []
    if node.left:
        left = [str(node.val) + x for x in traverse(node.left)]
    if node.right:
        right = [str(node.val) + x for x in traverse(node.right)]

    return left + right