二叉树回顾

遍历：

前序遍历： 节点-左-右

使用一个栈来实现，非递归：

class Solution(object):

    def preorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:return []
        answer=[]
        mystack=[root]
        while mystack:
            now=mystack.pop()
            answer.append(now.val)
            if now.right:mystack.append(now.right)
            if now.left:mystack.append(now.left)
        return answer

嗯，写的麻烦了，判断非空，然后直接append就好了；

def preorderTraversal(self, root):
    ret = []
    stack = [root]
    while stack:
        node = stack.pop()
        if node:
            ret.append(node.val)
            stack.append(node.right)
            stack.append(node.left)
    return ret

后续遍历：左、右、结点

我的思路还是用一个栈来实现，但是这个时候 节点 应该插入在第一位。出栈顺序是 右节点，再是左节点。

class Solution(object):
    def postorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        ret = []
        stack = [root]
        while stack:
            node = stack.pop()
            if node:
                ret=[node.val]+ret
                stack.append(node.left)
                stack.append(node.right)
        return ret

中序遍历：左、节点、右

直接看的好理解的 discuss，就是设置一个标记位：

class Solution:
    def inorderTraversal(self, root):
        stack = [ (False, root) ]
        acc = []

        while stack:
            flag, val = stack.pop()
            if val:
                if not flag:
                    stack.append( (False, val.right) )
                    stack.append( (True, val) )
                    stack.append( (False, val.left) )
                else:
                    acc.append( val.val )
        return acc

层序遍历：

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        ans,level=[],[root]
        while level:
            n,tem=[],[]
            for i in level:
                n.append(i.val)
                tem.extend([i.left,i.right])
            ans.append(n)
            level=[j for j in tem if j]
        return ans

从低向上的层序遍历：

class Solution(object):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        ans,level=[],[root]
        while level:
            n,tem=[],[]
            for i in level:
                n.append(i.val)
                tem.extend([i.left,i.right])
            ans=[n]+ans
            level=[j for j in tem if j]
        return ans 

求树的层数：104. Maximum Depth of Binary Tree

class Solution(object):
    def maxDepth(self, root):
        if not root:
            return 0
        if not root.left and not root.right:
            return 1
        return 1+max(self.maxDepth(root.left),self.maxDepth(root.right))

class Solution(object):
    def maxDepth(self, root):
        stack=[(root,0)]
        level=0
        while stack:
            p=stack.pop()
            if p[0]:
                level=max(level,p[1]+1)
                stack.extend([(p[0].left,p[1]+1),(p[0].right,p[1]+1)])
        return level