2020-01-09

0096.不同的二叉搜索树/0096-不同的二叉搜索树.py

@@ -4,11 +4,12 @@ def numTrees(self, n):
         :type n: int
         :rtype: int
         """
-        res = [0] * (n+1)
-        res[0] = 1
-        res[1] = 1
+        dic = {0:1, 1:1}
+
         for i in range(2, n + 1):
-            for j in range(i):
-                res[i] += res[j] * res[i-j-1]
-
-        return res[n]
+            cnt = 0
+            for l in range(0, i):
+                cnt += dic[l] * dic[i - 1 - l]
+            dic[i] = cnt 
+
+        return dic[n]

0105.从前序与中序遍历序列构造二叉树/0105-从前序与中序遍历序列构造二叉树.py

@@ -14,18 +14,10 @@ def buildTree(self, preorder, inorder):
         """
         if not preorder:
             return None
-        root_val = preorder[0]
-        root_idx = inorder.index(root_val)
-
-        preorder_left = preorder[1:1 + root_idx]
-        preorder_right = preorder[root_idx + 1:]
-
-        inorder_left = inorder[:root_idx]
-        inorder_right = inorder[root_idx + 1:]
-
-        # print preorder_left, preorder_right, inorder_left, inorder_right
-        root = TreeNode(root_val)
-        root.left = self.buildTree(preorder_left, inorder_left)
-        root.right = self.buildTree(preorder_right, inorder_right)
-
+
+        root = TreeNode(preorder[0])
+        idx = inorder.index(root.val)
+
+        root.left = self.buildTree(preorder[1:idx + 1], inorder[:idx])
+        root.right = self.buildTree(preorder[idx + 1:], inorder[idx + 1:])
         return root

0106.从中序与后序遍历序列构造二叉树/0106-从中序与后序遍历序列构造二叉树.py

@@ -13,19 +13,11 @@ def buildTree(self, inorder, postorder):
         :rtype: TreeNode
         """
         if not inorder:
-            return None
-        root_val = postorder[-1]
-        root_idx = inorder.index(root_val)
-
-        postorder_left = postorder[:root_idx]
-        postorder_right = postorder[root_idx:-1]
-
-        inorder_left = inorder[:root_idx]
-        inorder_right = inorder[root_idx + 1:]
-
-        # print preorder_left, preorder_right, inorder_left, inorder_right
-        root = TreeNode(root_val)
-        root.left = self.buildTree(inorder_left, postorder_left)
-        root.right = self.buildTree(inorder_right, postorder_right)
+            return None 
 
+        root = TreeNode(postorder[-1])
+        idx = inorder.index(root.val)
+
+        root.left = self.buildTree(inorder[:idx], postorder[:idx])
+        root.right = self.buildTree(inorder[idx + 1:], postorder[idx:-1])
         return root

0107.二叉树的层次遍历II/0107-二叉树的层次遍历II.py

@@ -11,16 +11,17 @@ def levelOrderBottom(self, root):
         :type root: TreeNode
         :rtype: List[List[int]]
         """
-        queue = [root]
+        if not root:
+            return []
+        from collections import deque 
+        queue = deque([root])
         res = []
         while queue:
-            next_queue = []
             layer = []
-            for node in queue:
-                if node:
-                    layer.append(node.val)
-                    next_queue += [node.left, node.right]
-            queue = next_queue[:]
-            if layer:
-                res.append(layer[:])
-        return res[::-1]
+            for _ in range(len(queue)):
+                cur = queue.popleft() 
+                if cur:
+                    layer.append(cur.val)
+                    queue += [cur.left, cur.right]
+            res.append(layer)
+        return res[:-1][::-1]

0199.二叉树的右视图/0199-二叉树的右视图.py

@@ -11,15 +11,18 @@ def rightSideView(self, root):
         :type root: TreeNode
         :rtype: List[int]
         """
+        from collections import deque 
+        if not root:
+            return []
+        queue = deque([root])
         res = []
-        def dfs(node, depth):
-            if not node:
-                return
-            if depth > len(res):
-                res.append(node.val)
-            dfs(node.right, depth + 1)
-            dfs(node.left, depth +1)
-
-
-        dfs(root, 1)
-        return res
+        while queue:
+            tmp = None
+            for _ in range(len(queue)):
+                cur = queue.popleft() 
+                if cur:
+                    tmp = cur.val 
+                    queue += [cur.left, cur.right] 
+            if tmp:
+                res.append(tmp)
+        return res

0222.完全二叉树的节点个数/0222-完全二叉树的节点个数.py

@@ -11,9 +11,26 @@ def countNodes(self, root):
         :type root: TreeNode
         :rtype: int
         """
-        def inorder(node):
-            if not node:
-                return []
-            return inorder(node.left) + [node.val] + inorder(node.right)
-        return len(inorder(root))
-
+        if not root:
+            return 0
+
+        self.leavesCnt = 0
+        self.height = 0
+        self.flag = 0
+        def dfs(node, layer):
+            if not node or self.flag:
+                return
+            if not node.left and not node.right:
+
+                self.height = max(self.height, layer)
+                if layer < self.height:
+                    self.flag = 1
+                else:
+                    self.leavesCnt += 1
+                return 
+            dfs(node.left, layer + 1)
+            dfs(node.right, layer + 1)
+
+        dfs(root, 0)
+        # print self.leavesCnt
+        return self.leavesCnt + sum([2 ** i for i in range(self.height)] )

0429.N叉树的层序遍历/0429-N叉树的层序遍历.py

@@ -1,7 +1,7 @@
 """
 # Definition for a Node.
 class Node(object):
-    def __init__(self, val, children):
+    def __init__(self, val=None, children=None):
         self.val = val
         self.children = children
 """
@@ -13,20 +13,17 @@ def levelOrder(self, root):
         """
         if not root:
             return []
-        nodes = [root]
-        node_val = list(list())
-        self.generate(nodes, node_val)
-        return node_val
-
-    def generate(self, nodes, node_val):
-        new_node = []
-        new_node_val = []
-        for node in nodes:
-            for leaf in node.children:
-                new_node.append(leaf)
-            new_node_val.append(node.val)
-        node_val.append(new_node_val)
-        if len(new_node) == 0:
-            return
-        self.generate(new_node, node_val)
-
+        from collections import deque 
+        queue = deque([root])
+        res = []
+        while queue:
+            layer = []
+            for _ in range(len(queue)):
+                cur = queue.popleft() 
+                if cur:
+                    layer.append(cur.val)
+                    for child in cur.children:
+                        queue.append(child)
+            res.append(layer)
+
+        return res

0637.二叉树的层平均值/0637-二叉树的层平均值.py

@@ -11,22 +11,18 @@ def averageOfLevels(self, root):
         :type root: TreeNode
         :rtype: List[float]
         """
+        from collections import deque 
         if not root:
             return []
-        next_layer = [root.left, root.right]
-        result = [float(root.val)]
-
-        while(next_layer):
-            temp_next_layer = list()
-            layer_value = list()
-            for node in next_layer:
-                if not node:
-                    continue
-                temp_next_layer.append(node.left)
-                temp_next_layer.append(node.right)
-                layer_value.append(node.val)
-            if layer_value:
-                result.append(sum(layer_value) / float(len(layer_value)))
-            next_layer = temp_next_layer
-        return result
-
+        queue = deque([root])
+        res = []
+        while queue:
+            layer = []
+            for _ in range(len(queue)):
+                cur = queue.popleft() 
+                if cur:
+                    layer.append(cur.val)
+                    queue += [cur.left, cur.right] 
+            if layer:
+                res.append(sum(layer) * 1.0 / len(layer))
+        return res

0669.修剪二叉搜索树/0669-修剪二叉搜索树.py

@@ -0,0 +1,26 @@
+# 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 trimBST(self, root, L, R):
+        """
+        :type root: TreeNode
+        :type L: int
+        :type R: int
+        :rtype: TreeNode
+        """
+        if not root:
+            return None 
+
+        root.left = self.trimBST(root.left, L, R)
+        root.right = self.trimBST(root.right, L, R)
+
+        if root.val < L:
+            return root.right 
+        if root.val > R:
+            return root.left
+        return root

0897.递增顺序查找树/0897-递增顺序查找树.py

@@ -11,26 +11,24 @@ def increasingBST(self, root):
         :type root: TreeNode
         :rtype: TreeNode
         """
-        preorder = list()
-
-        def pre_order(root):
-            if not root:
-                return
-            pre_order(root.left)
-            preorder.append(root.val)
-            pre_order(root.right)
-
-        pre_order(root)
-        dummy = TreeNode(0)
-        for i, node in enumerate(preorder):
+        if not root:
+            return root 
+        new_root = TreeNode(-1)
 
-            temp = TreeNode(node)
-            temp.left = None
-            temp.right = None
-            if i == 0:
-                dummy.right = temp
-                cur = temp
+        cur, stack = root, []
+        parent = None
+        while cur or stack:
+            if cur:
+                stack.append(cur)
+                cur = cur.left 
             else:
-                cur.right = temp
-                cur = temp
-        return dummy.right
+                cur = stack.pop()
+                cur.left = None
+                if not parent:
+                    parent = cur
+                    new_root.right = parent 
+                else:
+                    parent.right = cur 
+                    parent = cur   
+                cur = cur.right 
+        return new_root.right

0965.单值二叉树/0965-单值二叉树.py

@@ -11,7 +11,7 @@ def isUnivalTree(self, root):
         :type root: TreeNode
         :rtype: bool
         """
-        if not root or (not root.left and not root.right):
+        if not root:
             return True
         left = not root.left or (self.isUnivalTree(root.left) and root.val == root.left.val)
         right = not root.right or (self.isUnivalTree(root.right) and root.val == root.right.val)

0979.在二叉树中分配硬币/0979-在二叉树中分配硬币.py

@@ -12,20 +12,13 @@ def distributeCoins(self, root):
         :rtype: int
         """
         self.res = 0
-
         def dfs(node):
             if not node:
-                return 
-
-            if node.left:
-                dfs(node.left)
-                node.val += node.left.val - 1
-            if node.right:
-                dfs(node.right)
-                node.val += node.right.val - 1
-
-            self.res += abs(node.val - 1)
-
-
+                return 0
+            l = dfs(node.left)
+            r = dfs(node.right)
+
+            self.res += abs(l) + abs(r)
+            return l + r + node.val - 1
         dfs(root)
         return self.res

1104.二叉树寻路/1104-二叉树寻路.py

@@ -0,0 +1,12 @@
+class Solution(object):
+    def pathInZigZagTree(self, label):
+        """
+        :type label: int
+        :rtype: List[int]
+        """
+        res = []
+        while label > 1:
+            res.append(label)
+            label >>= 1
+            label = label ^(1 << (label.bit_length() - 1)) - 1
+        return [1] + res[::-1]