LeetCode 94 Binary Tree Inorder Traversal(Python详解及实现)

【题目】

Given a binary tree, return the inordertraversal of its nodes' values.

 

For example:

Given binary tree [1,null,2,3],

   1

    \

    2

    /

   3

return [1,3,2].

Note: Recursive solution is trivial, couldyou do it iteratively?

 

给定一个二叉树返回其中序遍历

注意：递归解法过于简单，你能用迭代的方式吗？

 

【思路】

二叉树遍历：

前序遍历：根结点、左子树、右子树

中序遍历：左子树、根结点、右子树

后序遍历：左子树、右子树、根结点

如下一棵二叉树，利用栈其整个过程为：

l  根结点G入栈，若入栈的结点存在左子树，则依次入栈G/D/A，直至A发现其左子树为空，停止入栈，此时栈stack = [G,D,A]。

l  A出栈，并对A进行遍历，发现A没有右子树，根据中序遍历，需要遍历A的根节点D，D出栈，D存在右孩子，将其右孩子F入栈，F有左子树E，E入栈，此时stack = [G,F,E]，res=[A,D]

l  E出栈，并对E进行遍历，发现没有右子树，根据中序遍历，需要遍历E的根结点F，F出栈，此时栈为stack = [G],res = [A,D, E, F]

l  G出栈，并遍历G，G有右子树，将右子树M入栈，此时栈为stack = [M],res = [A,D, E, F,G]

l  右子树根结点M，按照中序遍历规则重复以上步骤：

         M存在左子树H入栈，stack = [M,H],res= [A,D, E, F,G]

         H出栈，遍历H，发现H没有右子树，根据中序遍历，需要遍历H的根结点M，M有右子树Z，Z入栈，此时stack = [Z],res = [A,D, E, F,G,H,M]

         Z出栈，遍历Z，发现Z没有右子树，此时stack= [],res = [A,D, E, F,G,H,M,Z]

 

【Python实现】

方法一：非递归方式

#输出二叉树的中序遍历，非递归方式

# Definition for a binary tree node.
class TreeNode(object):
     def __init__(self, x):
         self.val = x
         self.left = None
         self.right = None

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        self.iterative_inorder(root, res)
        print(res)
        return res
    def iterative_inorder(self, root, res):#迭代中序遍历
        stack = []
        while root or stack:
            if root:
                stack.append(root)
                root = root.left
            else:
                root = stack.pop()
                res.append(root.val)
                root = root.right
        return res

if __name__ == '__main__':
    S = Solution()
    l1 = TreeNode(1)
    l2 = TreeNode(2)
    l3 = TreeNode(3)
    l4 = TreeNode(4)
    l5 = TreeNode(5)
    l6 = TreeNode(6)
    l7 = TreeNode(7)
    root = l1
    l1.left = l2
    l1.right = l3
    l2.left = l4
    l2.right = l5
    l3.left = l6
    l3.right = l7
    S.inorderTraversal(root)                

方法二：递归方式

# Definition for a binary tree node.
class TreeNode(object):
     def __init__(self, x):
         self.val = x
         self.left = None
         self.right = None

class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        res = []
        self. recursive_inorder (root, res)
        print(res)
        return res
    def recursive_inorder(self, root, res):#递归中序遍历
        if root:
            self.recursive_inorder(root.left, res)
            res.append(root.val)
            self.recursive_inorder(root.right, res)
            
            
if __name__ == '__main__':
    S = Solution()
    l1 = TreeNode(1)
    l2 = TreeNode(2)
    l3 = TreeNode(3)
    l4 = TreeNode(4)
    l5 = TreeNode(5)
    l6 = TreeNode(6)
    l7 = TreeNode(7)
    root = l1
    l1.left = l2
    l1.right = l3
    l2.left = l4
    l2.right = l5
    l3.left = l6
    l3.right = l7
    S.inorderTraversal(root)