二叉树回顾

遍历：

前序遍历： 节点-左-右

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

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