【題目】

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)