二叉树的遍历

二叉树的中序遍历：

迭代：

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res,stack = [],[]
        while True:
            while root:
                stack.append(root)
                root = root.left
            if not stack:
                return res
            node = stack.pop()
            res.append(node.val)
            root = node.right
        return res

递归：

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def helper(root):
            if not root:
                return
            helper(root.left)
            res.append(root.val)
            helper(root.right)
        helper(root)
        return res

另：

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        f = self.inorderTraversal 
        return f(root.left) + [root.val] + f(root.right) if root else []

二叉树的前序遍历：

递归：

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        def helper(root):
            if not root:
                return
            res.append(root.val)
            helper(root.left)
            helper(root.right)
            
        helper(root)
        return res

迭代：

class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        res,stack = [],[root]
        if not root:
            return res
        while stack:
            node = stack.pop()
            res.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
        return res

二叉树的后序遍历：

迭代1：

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        res = []
        if not root:
            return res
        stack = [root]
        while stack:
            node = stack.pop()
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
            res.append(node.val)
        return res[::-1]

迭代2：

class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root: return []
        stack = []
        p = root
        res = []
        flag = []
        while p or stack:
            while p:
                flag.append(0)
                stack.append(p)
                p = p.left
            while stack and flag[-1] == 1:
                flag.pop()
                res.append(stack.pop().val)
            if stack:
                flag[-1] = 1
                p = stack[-1].right
        return res      

 二叉树的层次遍历：

 

 

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:return []
        res = []
        stack = [root]
        while stack:
            tmp,ans = [],[]
            for node in stack:
                ans.append(node.val)
                if node.left:
                    tmp.append(node.left)
                if node.right:
                    tmp.append(node.right)
            res.append(ans)
            stack = tmp
        return res

二叉树的锯齿形遍历：

递归：

class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        res = []
        def helper(root, depth): 
            if not root: return 
            if len(res) == depth: 
                res.append([]) 
            if depth % 2 == 0:
                res[depth].append(root.val) 
            else: 
                res[depth].insert(0, root.val) 
            helper(root.left, depth + 1) 
            helper(root.right, depth + 1) 
        helper(root, 0) 
        return res

迭代：

class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        stack = [root]
        ans = []
        depth = 0
        while stack:
            tem_ans,tem_stack = [],[]
            for i in stack:
                tem_ans.append(i.val)
                if i.left:
                    tem_stack.append(i.left)
                if i.right:
                    tem_stack.append(i.right)
            if depth%2 == 0:
                ans.append(tem_ans)
            else:
                ans.append(tem_ans[::-1])
            stack = tem_stack
            depth += 1
        return ans