二叉树遍历--先序、中序以及后序（递归与非递归）

1、先序遍历

先序遍历是二叉树遍历的一种，先序遍历首先访问根节点，其次是左子树，最后是右子树；在访问左子树与右子树是仍然按照这个原则。若二叉树为空，则返回。若图所示。

先序遍历上图的二叉树可以得到：A、B、D、C、E、F 。

非递归代码如下所示。

class Tree():
    def __init__(self,val):
        self.val=val
        self.left=None
        self.right=None

    def dfs(self,root):
        stack = [root]
        datalist=[]
        datalist.append(root.val)
        while stack:  # 如果栈不为空
            node = stack.pop()  # 出栈
            # 前序遍历的操作在这里
            if node.left:
                stack.append(node.left)  # 入栈
                datalist.append(node.left.val)
            if node.right:
                stack.append(node.right)  # 入栈
                datalist.append(node.right.val)
        return datalist

    def preorder(self,node):
        res=[]
        res.append(node.val)
        for i in self.dfs(node.left):
            res.append(i)
        for i in self.dfs(node.right):
            res.append(i)
        return res

if __name__=="__main__":
    tree=Tree(1)
    tree.left=Tree(2)
    tree.right=Tree(3)
    tree.left.right=Tree(6)
    tree.left.left=Tree(4)
    tree.right.left=Tree(9)
    res=tree.preorder(tree)
    print(res)

递归算法如下所示。

class Tree():
    def __init__(self,val):
        self.val=val
        self.left=None
        self.right=None

      

   def preorder(self,node,res):
       if not node:
          return res

      res.append(node.val)
      self.preorder(node.left,res)
      self.preorder(node.right,res)
      return res

if __name__=="__main__":
    tree=Tree(1)
    tree.left=Tree(2)
    tree.right=Tree(3)
    tree.left.right=Tree(6)
    tree.left.left=Tree(4)
    tree.right.left=Tree(9)
    res=[]
    res_1=tree.preorder(tree,res)
    print(res_1)

2、中序遍历

中序遍历的二叉树遍历规则是先左后根再右，意思就是给定一棵二叉树，先直接到二叉树的最左端的叶子节点，再遍历它的父节点，最后遍历它的兄弟节点。

如上图，遍历得到的序列为：D、B、A、E、C、F。

非递归算法如下所示。

 

class Tree():
    def __init__(self,val):
        self.val=val
        self.left=None
        self.right=None

   def midorder(self, root):
      aStack = []
      node = root
      output = []
      if root == None:  # 如果直接是个空的就回个空的给它。
         return output
      while node or aStack:  # 如果node和aStack都是空的，说明全查完了。
         while node:  # 如果node是空的，说明左边没子节点了。
             aStack.append(node)
             node = node.left
         node = aStack.pop()  # 左边没子节点了就输出栈顶的节点值，然后从它右边的子节点继续。
         output.append(node.val)
         node = node.right
      return output

递归算法如下所示。

 class Tree():

          def __init__(self,val):

                self.val=val self.left=None self.right=None

         

   def midorder(self, root):
       if not root:
           return []
       return self.midorder(root.left)+[root.val]+self.midorder(root.right)

3、后序遍历

后序遍历的规则是先左再右后根，上图遍历的结果为：D、B、E、F、C、A 

非递归算法如下所示。

class Tree():
    def __init__(self,val):
        self.val=val
        self.left=None
        self.right=None

    def behindorder(self,root):
        stack=[root]
        datalist=[]
        while len(stack)>0:
            node = stack.pop()
            datalist.append(node)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        res=[]
        while len(datalist)>0:
            res.append(datalist.pop().val)
        return res

if __name__=="__main__":
    tree=Tree(1)
    tree.left=Tree(2)
    tree.right=Tree(3)
    tree.left.right=Tree(6)
    tree.left.left=Tree(4)
    tree.right.left=Tree(9)
    
    print(tree.behindorder(tree))

递归算法如下所示。

class Tree():
    def __init__(self,val):
        self.val=val
        self.left=None
        self.right=None

    def behindorder(self,root):
        if not root:
            return []
        return self.behindorder(root.left)+self.behindorder(root.right)+[root.val]

if __name__=="__main__":
    tree=Tree(1)
    tree.left=Tree(2)
    tree.right=Tree(3)
    tree.left.right=Tree(6)
    tree.left.left=Tree(4)
    tree.right.left=Tree(9)
    print(tree.behindorder(tree))