2020-01-08

Author: JiayangWu

0094.二叉树的中序遍历/0094-二叉树的中序遍历.py

@@ -11,16 +11,15 @@ def inorderTraversal(self, root):
         :type root: TreeNode
         :rtype: List[int]
         """
-        stack = []
-        cur = root
-        res = []
+        if not root:
+            return []
+        cur, stack, res = root, [], []
         while cur or stack:
             if cur:
                 stack.append(cur)
-                cur = cur.left 
+                cur = cur.left
             else:
                 cur = stack.pop()
                 res.append(cur.val)
-                cur = cur.right 
-        return res
-
+                cur = cur.right
+        return res

0108.将有序数组转换为二叉搜索树/0108-将有序数组转换为二叉搜索树.py

@@ -13,8 +13,11 @@ def sortedArrayToBST(self, nums):
         """
         if not nums:
             return None
-        l = len(nums)
-        root = TreeNode(nums[l // 2])
-        root.left = self.sortedArrayToBST(nums[:l//2])
-        root.right = self.sortedArrayToBST(nums[l//2 + 1:])
+        rootIdx = len(nums)//2
+        rootVal = nums[rootIdx]
+        
+        root = TreeNode(rootVal)
+        root.left = self.sortedArrayToBST(nums[:rootIdx])
+        root.right = self.sortedArrayToBST(nums[rootIdx + 1:])
+        
         return root

0114.二叉树展开为链表/0114-二叉树展开为链表.py

@@ -12,16 +12,16 @@ def flatten(self, root):
         :rtype: None Do not return anything, modify root in-place instead.
         """
         if not root:
-            return None
-        if not root.left and not root.right:
             return root
-        
         self.flatten(root.left)
         self.flatten(root.right)
-        ltree, rtree = root.left, root.right
-        root.right = ltree
+        
+        tmp = root.right
+        root.right = root.left
         root.left = None
-        p = root
-        while p.right:
-            p = p.right
-        p.right = rtree
+        
+        node = root
+        while node.right:
+            node = node.right
+        node.right = tmp
+        

0145.二叉树的后序遍历/0145-二叉树的后序遍历.py

@@ -11,12 +11,15 @@ def postorderTraversal(self, root):
         :type root: TreeNode
         :rtype: List[int]
         """
-        stack = [root]
-        res = []
+        # left right mid
+        # mid right left [::-1]
+        stack, res = [root], []
         while stack:
             cur = stack.pop()
             if cur:
                 res.append(cur.val)
                 stack.append(cur.left)
                 stack.append(cur.right)
-        return res[::-1]
+        return res[::-1]
+            
+        

0173.二叉搜索树迭代器/0173-二叉搜索树迭代器.py

@@ -11,27 +11,32 @@ def __init__(self, root):
         """
         :type root: TreeNode
         """
+        self.stack = []
+        self.cur = root
 
-        def inorder(node):
-            if not node:
-                return []
-            return inorder(node.left) + [node.val] + inorder(node.right)
-        self.l = inorder(root)
-        self.idx = 0
     def next(self):
         """
         @return the next smallest number
         :rtype: int
         """
-        self.idx += 1
-        return self.l[self.idx - 1]
+        while self.cur or self.stack:
+            if self.cur:
+                self.stack.append(self.cur)
+                self.cur = self.cur.left
+            else:
+                self.cur = self.stack.pop()
+                res = self.cur.val
+                self.cur = self.cur.right
+
+                return res
+            
 
     def hasNext(self):
         """
         @return whether we have a next smallest number
         :rtype: bool
         """
-        return self.idx < len(self.l)
+        return self.cur or self.stack
 
 
 # Your BSTIterator object will be instantiated and called as such:

0230.二叉搜索树中第K小的元素/0230-二叉搜索树中第K小的元素.py

@@ -12,11 +12,15 @@ def kthSmallest(self, root, k):
         :type k: int
         :rtype: int
         """
-        
-        def inorderTraversal(node):
-            if not node:
-                return []
-            return inorderTraversal(node.left) + [node.val] + inorderTraversal(node.right)
-        
-        l = inorderTraversal(root)
-        return l[k - 1]
+        cnt = 0
+        cur, stack = root, []
+        while cur or stack:
+            if cur:
+                stack.append(cur)
+                cur = cur.left
+            else:
+                cnt += 1
+                cur = stack.pop()
+                if cnt == k:
+                    return cur.val
+                cur = cur.right

0366.寻找完全二叉树的叶子节点/0366-寻找完全二叉树的叶子节点.py

@@ -11,25 +11,40 @@ def findLeaves(self, root):
         :type root: TreeNode
         :rtype: List[List[int]]
         """
-        from collections import defaultdict
-        self.dic = defaultdict(list)
-        res = []
-        def get_Height(node):
+        from collections import defaultdict, deque
+        outdegree = defaultdict(int)
+        child2parent = {root:None}
+        leavesNodes = []
+        def dfs(node):
             if not node:
-                return -1
-            lh = get_Height(node.left)
-            rh = get_Height(node.right)
-            h = max(lh, rh) + 1
-            self.dic[h].append(node.val)
-            return h
+                return
+            
+            if node.left:
+                outdegree[node] += 1
+                child2parent[node.left] = node
+                dfs(node.left)
+            if node.right:
+                outdegree[node] += 1
+                child2parent[node.right] = node
+                dfs(node.right)
+            
+            if not outdegree[node]:
+                leavesNodes.append(node)
+        dfs(root)
 
-        get_Height(root)
-        # print self.dic
-        h = 0
-        while 1:
-            if h not in self.dic:
-                break
-            res.append(self.dic[h])
-            h += 1
+        res = []
+        queue = deque(leavesNodes)
+        while queue:
+            tmp = []
+            for _ in range(len(queue)):
+                cur = queue.popleft()
+                tmp.append(cur.val)
+                
+                parent = child2parent[cur]
+                outdegree[parent] -= 1
+                
+                if not outdegree[parent]:
+                    queue.append(parent)
+            res.append(tmp)
         return res
-        
+                

0513.找树左下角的值/0513-找树左下角的值.py

@@ -11,18 +11,19 @@ def findBottomLeftValue(self, root):
         :type root: TreeNode
         :rtype: int
         """
-        next_layer = [root]
-        while(next_layer):
-            temp_next_layer = []
-            layer_value = []
-            for node in next_layer:
-                if node.left:                    
-                    temp_next_layer.append(node.left)
-                if node.right:
-                    temp_next_layer.append(node.right)
-                layer_value.append(node.val)
-                # print layer_value 
-            next_layer = temp_next_layer
-            
-        # print layer_value        
-        return layer_value[0]
+        #层序遍历返回最后一层第一个
+        from collections import deque
+        if not root:
+            return None
+        queue = deque([root])
+        while queue:
+            res = []
+            for _ in range(len(queue)):
+                cur = queue.popleft()
+                res.append(cur.val)
+                if cur.left:
+                    queue.append(cur.left)
+                if cur.right:
+                    queue.append(cur.right)
+        return res[0]
+                    

0559.N叉树的最大深度/0559-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
 """
@@ -11,10 +11,9 @@ def maxDepth(self, root):
         :type root: Node
         :rtype: int
         """
-        result = []
         if not root:
             return 0
-        for node in root.children:
-            result.append(self.maxDepth(node))
-        
-        return 1 + max(result) if result else 1
+        res = 0
+        for child in root.children:
+            res = max(res, self.maxDepth(child))
+        return 1 + res

0701.二叉搜索树中的插入操作/0701-二叉搜索树中的插入操作.py

@@ -1,22 +1,33 @@
+# 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 insertIntoBST(self, root, val):
-        """
-        :type root: TreeNode
-        :type val: int
-        :rtype: TreeNode
-        """
         if not root:
-            return 
-        def helper(node, val):
-            if node.val < val:
-                if not node.right:
-                    node.right = TreeNode(val)
-                else:
-                    helper(node.right, val)
-            elif node.val > val:
-                if not node.left:
-                    node.left = TreeNode(val)
-                else:
-                    helper(node.left, val)
-        helper(root, val)
-        return root
+            return TreeNode(val)
+        node, parent = root, root
+        while node:
+            parent = node
+            node = parent.left if val < parent.val else parent.right
+        if val > parent.val:
+            parent.right = TreeNode(val)
+        else:
+            parent.left = TreeNode(val)
+        return root
+# class Solution(object):
+#     def insertIntoBST(self, root, val):
+#         """
+#         :type root: TreeNode
+#         :type val: int
+#         :rtype: TreeNode
+#         """
+#         if not root:
+#             return TreeNode(val)
+#         if root.val > val:
+#             root.left = self.insertIntoBST(root.left, val)
+#         else:
+#             root.right = self.insertIntoBST(root.right, val)
+#         return root

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

@@ -11,19 +11,8 @@ def isUnivalTree(self, root):
         :type root: TreeNode
         :rtype: bool
         """
-            
-        self.value = root.val
-        self.result = True
-        self.generate(root)
-        return self.result
-    
-    def generate(self, root):
-        if root.val != self.value:
-            self.result = False
-            return
-        if not root:
-            return 
-        if root.left:
-            self.generate(root.left)
-        if root.right:
-            self.generate(root.right)
+        if not root or (not root.left and not root.right):
+            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)
+        return left and right