题目描述

Given a binary tree, return the preorder traversal of its nodes’ values.

Example:

Input: [1,null,2,3]
1

2
/
3

Output: [1,2,3]
Follow up: Recursive solution is trivial, could you do it iteratively?

算法思路

前序遍历采用“根左右”的顺序，如果采用递归则先打印出根节点，然后将当前节点的左节点作为根节点再次调用方法，最后将当前节点左右右节点再进行递归调用即可。

如果采用栈来进行迭代的话，栈不为空时，每次迭代应该将根节点出栈后，然后将右节点放入栈中，接着将左节点放入栈中。

算法实现

class TreeNode():
    def __init__(self,x):
        self.val=x
        self.left=None
        self.right=None
class Solution():
    #迭代方法
    def preorderTraversal(self,root):
        res=[]
        stack=[root]
        while stack:
            node=stack.pop()
            res.append(node.val)
            if node.right!=None :stack.append(node.right)
            if node.left!=None :stack.append(node.left)   
        
        return res
    #递归方法
    def preorderTraversal_r(self,root):
        res_r=[]
        if root:
            res_r.append(root.val)
            left =self.preorderTraversal_r(root.left)
            res_r.extend(left)
            right =self.preorderTraversal_r(root.right) 
            res_r.extend(right)
        return res_r
    
test=Solution()
n1=TreeNode(1)
n2=TreeNode(2)
n3=TreeNode(3)
n4=TreeNode(4)
n5=TreeNode(5)
n6=TreeNode(6)
n7=TreeNode(7)
n1.left=n2
n1.right=n3
n2.left=n4
n3.left=n5
n3.right=n6
n6.right=n7
"""
       1
      / \
     2   3
    /    /\
   4    5  6
            \
             7
"""
print(test.preorderTraversal(n1))
print(test.preorderTraversal_r(n1))

小结

在利用栈进行迭代的时候，应该先让右节点入栈，再让左节点入栈，这样才能保证出栈的顺序为先序遍历的顺序——“根左右”