二叉树的前、中、后、层序遍历的递归实现

前中后序三种遍历方法对于左右结点的遍历顺序都是一样的（先左后右），唯一不同的就是根节点的出现位置。

1.前序：前序遍历指根结点在最前面输出，所以前序遍历的顺序是：中左右。

递归：
class Solution: 
　　def preorderTraversal(self, root): ##前序遍历 
　　　　""" :type root
　　　　　　: TreeNode 
　　　　　　:rtype: List[int] """
　　　　if not root: return [] 
　　　　return [root.val] + self.inorderTraversal(root.left) + self.inorderTraversal(root.right)

循环
class Solution:
    def preorderTraversal(self, root):  ## 前序遍历
        stack = []
        sol = []
        curr = root
        while stack or curr:
            if curr:
                sol.append(curr.val)
                stack.append(curr.right)
                curr = curr.left
            else:
                curr = stack.pop()
        return sol

 

2.中序：对于中序遍历来说，根结点的遍历位置在中间，所以中序遍历的顺序：左中右。

递归

class Solution:
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return [] 
        return self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right)

循环
class Solution: 
　　def inorderTraversal(self, root): 
　　　　stack = [] 
　　　　sol = [] 
　　　　curr = root 
　　　　while stack or curr: 
　　　　　　if curr: 
　　　　　　　　stack.append(curr) 
　　　　　　　　curr = curr.left 
　　　　　　else: 
　　　　　　　　curr = stack.pop() 
　　　　　　　　sol.append(curr.val) 
　　　　　　　　curr = curr.right 
　　　　return sol

 

3.后序：后序遍历指根结点在最后面输出，所以后序遍历的顺序是：左右中。

递归
def postorderTraversal(self, root): ##后序遍历 
　　""" 
　　:type root
　　: TreeNode 
　　:rtype: List[int] 
　　""" 
　　if not root: return [] 
　　return self.inorderTraversal(root.left) + self.inorderTraversal(root.right) + [root.val]

循环
def postorderTraversal(self, root): ## 后序遍历 
　　stack = [] 
　　sol = [] 
　　curr = root 
　　while stack or curr: 
　　　　if curr: 
　　　　　　sol.append(curr.val) 
　　　　　　stack.append(curr.left) 
　　　　　　curr = curr.right 
　　　　else: 
　　　　　　curr = stack.pop() 
　　return sol[::-1]

 

4.层序：层序遍历也可以叫做宽度优先遍历：先访问树的第一层结点，再访问树的第二层结点...然后一直访问到最下面一层结点。在同一层结点中，以从左到右的顺序依次访问。

 

递归
class Solution:
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        def helper(node, level):
            if not node:
                return
            else:
                sol[level-1].append(node.val)
                if len(sol) == level:  # 遍历到新层时，只有最左边的结点使得等式成立
                    sol.append([])
                helper(node.left, level+1)
                helper(node.right, level+1)
        sol = [[]]
        helper(root, 1)
        return sol[:-1]

循环
class Solution: 
　　def levelOrder(self, root): 
　　　　if not root: return [] 
　　　　sol = [] 
　　　　curr = root 
　　　　queue = [curr] 
　　　　while queue: 
　　　　　　curr = queue.pop(0) 
　　　　　　sol.append(curr.val) 
　　　　　　if curr.left: 
　　　　　　　　queue.append(curr.left) 
　　　　　　if curr.right: 
　　　　　　　　queue.append(curr.right) 
　　　　return sol

PS：

Q：如果仍然按层遍历，但是每层从右往左遍历怎么办呢？

A：将上面的代码left和right互换即可

Q：如果仍然按层遍历，但是我要第一层从左往右，第二层从右往左，第三从左往右...这种zigzag遍历方式如何实现？

A：将sol[level-1].append(node.val)进行一个层数奇偶的判断，一个用append()，一个用insert(0,)

    if level%2==1:
        sol[level-1].append(node.val)
    else:
        sol[level-1].insert(0, node.val)