二叉树的遍历（前序、中序、后序、层序）

前言

复习期间，将一些知识点记录下来，原理部分简单带过（主要是画图什么的太费时间，好在自己能看得懂）。
树中节点结构

class Node:  
    def __init__(self,value=None,left=None,right=None):  
         self.value=value  
         self.left=left    #左子树
         self.right=right  #右子树

一、先序遍历

1、递归形式

def pre_order_traverse(root):  
    '''

    @description:  二叉树递归前序遍历
    @param {type} 
    @return: 
    '''       
    if root==None:  
        return  
    print(root.value)  
    pre_order_traverse(root.left)  
    pre_order_traverse(root.right)  

递归形式比较简单，先序遍历顺序为：中左右

2、非递归形式

非递归遍历二叉树需要借助栈，初始化时将根节点压入栈。每一个节点出栈时，将其右子节点、左子节点依次入栈，（左子节点后进先出）。

def pre_order_traverse_no_recursion(root):
    '''
    @description: 二叉树非递归前序遍历，中左右，
    将根节点压入栈，取出栈顶元素，再将该元素的右节点、左节点依次压入栈
    @param {type} 
    @return: 
    '''   
    if not root:return []
    store,ans=[],[]
    store.append(root)
    while store:
        node=store.pop()
        ans.append(node.value)
        if node.right:store.append(node.right)
        if node.left:store.append(node.left)
    return ans

二、中序遍历

1、递归形式

def in_order_traverse(root): 
    '''
    @description:  二叉树递归中序遍历
    @param {type} 
    @return: 
    '''    
    
    if root==None:  
        return  
    in_order_traverse(root.left)  
    print(root.value)  
    in_order_traverse(root.right)  

2、非递归形式

def in_order_traverse_no_recursion(root):
    '''
    @description: 非递归中序遍历，
    从根节点开始不停压入左节点，直至最后，读取栈顶元素，值存入结果，
    然后进入该节点的右子树，
    重复上述过程
    @param {type} 
    @return: 
    '''    
    if not root:return []
    store,ans=[],[]
    # store.append(root)
    tmp=root
    while tmp or store:
        while tmp:
            store.append(tmp)
            tmp=tmp.left   
        tmp=store.pop()
        ans.append(tmp.value)
        tmp=tmp.right
    return ans

三、后序遍历

1、递归形式

def post_order_traverse(root):  
    '''
    @description: 二叉树递归后序遍历
    @param {type} 
    @return: 
    '''    
 
    if root==None:  
        return  
    post_order_traverse(root.left)  
    post_order_traverse(root.right)  
    print(root.value)

2、非递归形式一

def post_order_traverse_no_recursion2(root):
    '''
    @description: 参考中序遍历非递归形式，
    不断压入左子节点，然后取栈顶元素（不出栈），
    判断它是否有右子节点或右子节点已访问（last记录上次访问的右子节点），
    没有则栈顶元素出栈，值存入结果，否则，进入右子树，
    重复上述过程
    @param {type} 
    @return: 
    '''
    if not root:return []
    store,ans=[],[]
    tmp=root
    last=None
    while tmp or  store:
        while tmp:
            store.append(tmp)
            tmp=tmp.left
        top=store[-1]
        if not top.right or top.right ==last:
            top=store.pop()
            ans.append(top.value)
            last=top
        else:
            tmp=top.right
    return ans

3、非递归形式2

这个方法可以说是相当精巧了
具体见这位大佬的文章

def post_order_traverse_no_recursion(root):
    '''
    @description: 非递归后序遍历，顺序为左右中，
    前序遍历是中左右，因此按照中右左进行遍历，取结果逆序
    @param {type} 
    @return: 
    '''    
    if not root:return []
    store,ans=[],[]
    store.append(root)
    while store:
        node=store.pop()
        ans.append(node.value)
        if node.left:store.append(node.left)
        if node.right:store.append(node.right)
    return ans[::-1]

四、层序遍历

def level_traversal(root):
    '''
    @description: 二叉树层序遍历，借助队列
    @param {type} 
    @return: 
    '''
    if not root:return []
    import collections
    queue=collections.deque()
    ans=[]
    queue.append(root)
    while queue:
        node=queue.popleft()
        ans.append(node.value)
        if node.left:queue.append(node.left)
        if node.right:queue.append(node.right)
    return ans

五、参考文章

1、二叉树的非递归遍历
2、二叉树的非递归遍历：精巧的后序遍历，具体见这位大佬的文章