2020-01-07

Author: JiayangWu

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

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

0144.二叉树的前序遍历/0144-二叉树的前序遍历.py

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

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

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

0589.N叉树的前序遍历/0589-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
 """
@@ -12,11 +12,9 @@ def preorder(self, root):
         :rtype: List[int]
         """
         if not root:
-            return list()
-        result = list()
-        result.append(root.val)
-        
-        for leaf in root.children:
-            result += self.preorder(leaf)
-            
-        return result
+            return []
+
+        res = [root.val]
+        for child in root.children:
+            res += self.preorder(child)
+        return res

0590.N叉树的后序遍历/0590-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,8 +13,7 @@ def postorder(self, root):
         """
         if not root:
             return []
-        res = list()
-        for leaf in root.children:
-            res += self.postorder(leaf)
-        
+        res = []
+        for child in root.children:
+            res += self.postorder(child)
         return res + [root.val]

0700.二叉搜索树中的搜索/0700-二叉搜索树中的搜索.py

@@ -12,14 +12,10 @@ def searchBST(self, root, val):
         :type val: int
         :rtype: TreeNode
         """
-        # print root.val
-        if not root:
-            return None
-        if root.val == val:
+        if not root or root.val == val:
             return root
-        elif root.val > val:
+
+        if root.val > val:
             return self.searchBST(root.left, val)
-        else:
-            return self.searchBST(root.right, val)
-            
-        
+        elif root.val < val:
+            return self.searchBST(root.right, val)

0814.二叉树剪枝/0814-二叉树剪枝.py

@@ -12,12 +12,9 @@ def pruneTree(self, root):
         :rtype: TreeNode
         """
         if not root:
-            return None
-        # print root.val,  self.generate(root.left), self.generate(root.right)
+            return None 
         root.left = self.pruneTree(root.left)
         root.right = self.pruneTree(root.right)
-        if root.left == None and root.right == None and (root.val == 0):
-            return None
-        return root
-    
-            
+        if not root.left and not root.right and not root.val:
+            root = None 
+        return root

1008.先序遍历构造二叉树/1008-先序遍历构造二叉树.py

@@ -11,30 +11,12 @@ def bstFromPreorder(self, preorder):
         :type preorder: List[int]
         :rtype: TreeNode
         """
-        inorder = sorted(preorder)
-        
-        return self.buildTree(preorder, inorder)
-        
-        
-        
-    def buildTree(self, preorder, inorder): # leetcode 105
-        """
-        :type preorder: List[int]
-        :type inorder: List[int]
-        :rtype: TreeNode
-        """
         if not preorder:
-            return None
-        
-        root = TreeNode(preorder[0])        
-        left_inorder = inorder[: inorder.index(root.val)]
-        right_inorder = inorder[inorder.index(root.val) + 1 :]
-        
-        l_left = len(left_inorder)
-        left_preorder = preorder[1:l_left + 1]
-        right_preorder = preorder[l_left + 1 :]
-        
-        root.left = self.buildTree(left_preorder, left_inorder)
-        root.right = self.buildTree(right_preorder, right_inorder)
-        
+            return None 
+        inorder = sorted(preorder)
+
+        idx = inorder.index(preorder[0])
+        root = TreeNode(preorder[0])
+        root.left = self.bstFromPreorder(preorder[1:idx + 1])
+        root.right = self.bstFromPreorder(preorder[idx + 1:])
         return root