Leetcode刷题全记录，每题都有长进（medium 91-120）

94 二叉树的中序遍历

二叉树的基础遍历。不多说了

96 不同的二叉搜索树

这道题有点找规律。关键是找到dp的递推公式。
我们以3为例，

1. 如果1为根节点，右侧剩下2，3需要分配。变成一个两个节点的问题。所以有dp[0]*dp[2]种方法。
2. 如果2为根节点，左侧有1分配，种类是dp[1]，右侧只有3，种类是dp[1]。共有dp[1]*dp[1]
3. 如果3为根节点，左侧有1，2分配，种类是dp[2]，右侧没有。共有dp[2]*dp[0]
4. 总的就是dp[3] = sum(dp[0]*dp[2]+dp[1]*dp[1]+dp[2]*dp[0])

class Solution(object):
    def numTrees(self, n):
        """
        :type n: int
        :rtype: int
        """
        dp = [0 for i in range(n+1)]
        #dp = [0]*(n+1)
        dp[0] = 1
        for i in range(1,n+##1):
            for j in range(i):
                dp[i] += dp[j]*dp[i-1-j]
        return dp[n]

代码亮点：
首先是初始值为0，并且dp[0]=1

98 验证二叉搜索树

详情这里

102 二叉树的层次遍历

还是写一下标准的迭代方法。

# 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 levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        queue = []
        queue.append(root)
        ans = []
        while queue:
            now = []
            n = len(queue)
            ## ！！！保证每次都是同一级的全部一次性处理完成
            while n>0:
                root = queue.pop(0)
                if root.left:
                    queue.append(root.left)
                if root.right:
                    queue.append(root.right)
                now.append(root.val)
                n -= 1
            ans.append(now)
        return ans

代码亮点：
为保证每次都是同一层的节点被访问，采用一次性弹出n个解决。
附赠递归的方法：

class Solution(object):
    def levelOrder(self, root): 
        levels = []
        if not root:
            return levels

        def helper(node, level):
            if len(levels) == level:
                levels.append([])

            levels[level].append(node.val)

            if node.left:
                helper(node.left, level+1)
            if node.right:
                helper(node.right, level+1)

        helper(root,0)
        return levels

105 从前序与中序遍历序列构造二叉树

题目很有意思，是一道DC思想的题目，在二叉树题目中，DC思想真的用的不少。
思路核心就是一个图，思考清楚子问题具体是什么。对于二叉树来说子问题往往就是处理好每一个小的二叉树，处理跳出条件，处理好好当前节点并且将左右子节点带入函数。

class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        if not preorder:
            return None
        root = TreeNode(preorder[0])
        index = inorder.index(preorder[0])
        root.left = self.buildTree(preorder[1:index+1], inorder[:index])
        root.right = self.buildTree(preorder[index+1:], inorder[index+1:])
        return root

114. 二叉树展开为链表

是一道最开始没有做出来得题目，还是值得一做的。