二叉树的遍历

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

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]

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 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