二叉樹的先序遍歷、中序遍歷、后續遍歷（采用遞歸和棧兩種）層序遍歷（使用隊列）

首先我們要先自己建立一個二叉樹，我們先根據我自己隨便寫的二叉樹建立一個列表保存二叉樹的各個節點的信息，當然你也可以直接寫個程序自己建立。

node_list = [
    {'data':'A', 'left':'B', 'right':'C', 'is_root':True},
    {'data':'B', 'left':'D', 'right':'E', 'is_root':False},
    {'data':'C', 'left':'F', 'right':'G', 'is_root':False},
    {'data':'D', 'left':None, 'right':None, 'is_root':False},
    {'data':'E', 'left':'H', 'right':None, 'is_root':False},
    {'data':'H', 'left':None, 'right':None, 'is_root':False},
    {'data':'F', 'left':None, 'right':None, 'is_root':False},
    {'data':'G', 'left':'I', 'right':'J', 'is_root':False},
    {'data':'I', 'left':None, 'right':None, 'is_root':False},
    {'data':'J', 'left':None, 'right':None, 'is_root':False}
]

然后根據建的列表建立一個二叉樹

from collections import deque
class BinTreeNode(object):
    def __init__(self, data, left=None, right=None):
        self.data, self.left, self.right = data, left, right

class BinTree(object):
    
    def __init__(self, root=None):
        self.root = root
    
    @classmethod
    def build_form(cls, node_list):
        node_dict = {}
        for node_data in node_list:
#這一步是把所有節點存在node_dict中
            data = node_data['data']
            node_dict[data] = BinTreeNode(data)
'''這一步是根據存在node_dict中的節點字典，把對應的左右節點對應上'''
        for node_data in node_list:
            data = node_data['data']
            if node_data['is_root']:
                root = node_dict[data]
            node_dict[data].left = node_dict.get(node_data['left'])
            node_dict[data].right = node_dict.get(node_data['right'])
        return cls(root)

接下來是幾種遍歷

先序遍歷:即先遍歷根節點然后遍歷左節點接着是右節點

第一種：采用遞歸

['A', 'B', 'D', 'E', 'H', 'C', 'F', 'G', 'I', 'J']

def prevorder_trav(self, subtree):
        if subtree:
            yield subtree
            yield from self.prevorder_trav(subtree.left)
            yield from self.prevorder_trav(subtree.right)

我個人比較傾向於返回對應節點而不是直接返回值，這樣我們還可以對二叉樹的每個節點操作。當然你也可以直接返回subtree.date

第二種：采用棧

棧FILO因此我們要先把右節點入棧再把左節點入棧

def prevorder_trav_stack(self, subtree):
        s = deque()
        s.append(subtree)
        while s:
            node = s.pop()
            yield node
            if node.right:
                s.append(node.right)
            if node.left:
                s.append(node.left)

中序遍歷：先遍歷左節點再遍歷根節點最后遍歷右節點，這個先遍歷左節點是要遍歷最左,左到它下一個左節點為None

第一種：使用遞歸

['D', 'B', 'H', 'E', 'A', 'F', 'C', 'I', 'G', 'J']

def inorder_trav(self, subtree):
        if subtree:
            yield from self.inorder_trav(subtree.left)
            yield subtree
            yield from self.inorder_trav(subtree.right)

第二種使用棧：

 

def inorder_trav_use_stack(self, subtree):
        s = deque()
        top = subtree
        while s or top:
            while top:
                s.append(top)
                top = top.left
                
            top = s.pop()
            print(top.data)
            top = top.right

 

后序遍歷

遞歸

def postorder_trav(self, subtree):
        if subtree:
            yield from self.postorder_trav(subtree.left)
            yield from self.postorder_trav(subtree.right)
            yield subtree.data

使用棧：

def postorder_trav_use_stack(self, subtree):
        p = subtree
        s = deque()
        s.append(p)
        s.append(p)
        while s:
            p = s.pop()
            if s and p == s[-1]:
                if p.right:
                    s.append(p.right)
                    s.append(p.right)
                if p.left:
                    s.append(p.left)
                    s.append(p.left)
            else:
                yield p.data

 層序遍歷：

def layer_trav(self, subtree):
        if subtree:
            s = deque()
            s.append(subtree)
            while s:
                node = s.popleft()
                yield node.data
                if node.left:
                    s.append(node.left)
                if node.right:
                    s.append(node.right)