一、二叉樹

二叉樹是一種特殊的樹，其特點如下：

1. 二叉樹每個節點最大隻能有兩個節點。
2. 二叉樹的子樹也就是節點有左右之分，即左節點和右節點，次序不能亂。
3. 二叉樹即使只有一個子樹，也有左右之分。

二、滿二叉樹

一種特殊的二叉樹，其所有的分支節點都有兩棵樹，其所有的葉子節點都在同一層內。

1. 所有的葉子節點都在同一層。
2. 所有的非葉子節點都有兩棵樹，即節點度都是2.
3. 同樣深度的二叉樹中，滿二叉樹的節點最多，2的h次方減1，其中h為樹的深度。

三、完全二叉樹

若設二叉樹的深度為h，除第h層外，其它各層(1～h−1)(1～h−1)的結點數都達到最大個數，第hh層所有的結點都連續集中在最左邊，這就是完全二叉樹。其具有以下特點：

1. 葉子節點可以出現在最後一層或倒數第二層。
2. 最後一層的葉子節點一定集中在左部連續位置。
3. 完全二叉樹嚴格按層序編號。（可利用陣列或列表進行實現，滿二叉樹同）
4. 若一個節點為葉子節點，那麼編號比其大的節點均為葉子節點。

四、建立節點

class Node(object):

    def __init__(self, data, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right

五、根據列表建立二叉樹

class Node(object):

    def __init__(self, data, left
 
=None, right=None):
        self.data = data
        self.left = left
        self.right = right


class BinTreeNode(object):

    def __init__(self):
        self.root = None

    def create(self, li):
        for i in li:
            self.insert(i)

    def insert(self,num):
        if self.root == None:
            self.root 
 
= Node(num)
        else:
            p = self.root
            while 1:
                if num < p.data:
                    if p.left:
                        p = p.left  #遞迴建立
                    else:
                        p.left = Node(num)
                        break
                elif num > p.data:
                    if p.right:
                        p = p.right  # 遞迴建立
                    else:
                        p.right = Node(num)
                        break


if __name__ == "__main__":
    tree = BinTreeNode()
    li = [5, 1, 3, 8, 2, 9, 4, 6, 7]
    tree.create(li)

六、前序遍歷

先訪問根節點，再先序遍歷左子樹，然後再先序遍歷右子樹。總的來說是根、左、右。

def proNode(root):
    if root:
        print(root.data, end=' ')
        proNode(root.left)
        proNode(root.right)

七，中序遍歷

先中序訪問左子樹，然後訪問根，最後中序訪問右子樹。總的來說是左、根、右。

def proNode(root):
    if root:
        proNode(root.left)
        print(root.data, end=' ')
        proNode(root.right)

八、後續遍歷

先後序訪問左子樹，然後後序訪問右子樹，最後訪問根。總的來說是左、右、根。

def proNode(root):
    if root:
        proNode(root.left)
        proNode(root.right)
        print(root.data, end=' ')

九、寬度優先遍歷——層次遍歷

利用佇列，依次將根，左子樹，右子樹存入佇列，按照佇列的先進先出規則來實現層次遍歷。

def bfs(root):
    if root ==None:
        return
    queue = []
    queue.append(root)

    while queue:
        curNode = queue.pop(0)
        print(curNode.data, end=' ')
        if curNode.left:
            queue.append(curNode.left)

        if curNode.right:
            queue.append(curNode.right)

十、深度優先

利用棧，先將根入棧，再將根出棧，並將根的右子樹，左子樹存入棧，按照棧的先進後出規則來實現深度優先遍歷。

前序、中序、後續遍歷都屬於深度優先遍歷。

下面程式碼即是不用遞迴實現的前序遍歷。

def dfs(root):
    if root == None:
        return

    infoqueue = []
    infoqueue.append(root)

    while infoqueue:
        curNode = infoqueue.pop()
        print(curNode.data, end=' ')
        if curNode.right:
            infoqueue.append(curNode.right)
        if curNode.left:
            infoqueue.append(curNode.left)

結束！