regular leetcode

Author: KrisYu

035._search_insert_position.md

@@ -0,0 +1,32 @@
+###35. Search Insert Position
+
+题目:
+<https://leetcode.com/problems/search-insert-position/>
+
+
+难度:
+
+Medium
+
+
+递归
+
+```
+class Solution(object):
+    def searchInsert(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        n = len(nums)
+        if target <= nums[0]:
+            return 0
+        if target > nums[n-1]:
+            return n
+        for i in range(1,n):
+            if target == nums[i]:
+                return i
+            elif target > nums[i-1] and target < nums[i]:
+                return i
+```

094._binary_tree_inorder_traversal.md

@@ -0,0 +1,70 @@
+###94. Binary Tree Inorder Traversal
+
+题目:
+<https://leetcode.com/problems/binary-tree-inorder-traversal/>
+
+
+难度:
+
+Medium
+
+
+递归
+
+```
+class Solution(object):
+    def inorderTraversal(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[int]
+        """
+        self.lst = []
+        self.DFS(root)
+        return self.lst
+
+    
+    def DFS(self,root):
+        if root == None:
+            return
+        if root.left:
+            self.DFS(root.left)
+        self.lst.append(root.val)
+        if root.right:
+            self.DFS(root.right)
+                
+```
+
+非递归用stack，我听谁讲过 😓
+
+// to be done
+
+
+via wikipedia
+
+
+递归：
+
+```
+inorder(node)
+  if (node = null)
+    return
+  inorder(node.left)
+  visit(node)
+  inorder(node.right)
+```
+
+
+非递归,跟之前那个iterator有得一拼，其实好几个题都是在玩这个花样？
+
+```
+iterativeInorder(node)
+  s ← empty stack
+  while (not s.isEmpty() or node ≠ null)
+    if (node ≠ null)
+      s.push(node)
+      node ← node.left
+    else
+      node ← s.pop()
+      visit(node)
+      node ← node.right
+```

112._path_sum.md

@@ -0,0 +1,30 @@
+###112. Path Sum
+
+题目:
+<https://leetcode.com/problems/path-sum/>
+
+
+难度:
+
+Easy
+
+
+递归
+
+```
+class Solution(object):
+    def hasPathSum(self, root, sum):
+        """
+        :type root: TreeNode
+        :type sum: int
+        :rtype: bool
+        """
+        if root == None:
+                return False
+        else:
+            if root.val == sum and (root.left == None and root.right == None):
+                return True
+            else:
+                return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)
+                
+```

125._valid_palindrome.md

@@ -0,0 +1,63 @@
+###125. Valid Palindrome
+
+题目:
+<https://leetcode.com/problems/valid-palindrome/>
+
+
+难度:
+
+Easy
+
+根据这个palindrome原理来看，running time比较慢
+
+```
+class Solution(object):
+    def isPalindrome(self,s):
+        """
+        :type s: str
+        :rtype: bool
+        """
+        Alphabets = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9']
+        i = 0
+        j = len(s) - 1
+        palindrome = True
+        lowerS = s.lower()
+        while i < j:
+            if lowerS[i] not in Alphabets:
+                i += 1
+                continue
+            if lowerS[j] not in Alphabets:
+                j -= 1
+                continue
+            if lowerS[i] != lowerS[j]:
+                print(i,lowerS[i],j,lowerS[j])
+                return False
+            # s[i] == s[j]
+            else:
+                i += 1
+                j -= 1
+        return palindrome
+                
+```
+
+当然也有取巧的办法，就是比较reversed string 和原本的是否相等.
+Running time 提升了一点
+
+```
+class Solution(object):
+    def isPalindrome(self,s):
+        """
+        :type s: str
+        :rtype: bool
+        """
+          
+        new=[]  
+  
+        s=s.lower()  
+  
+        for i in s:  
+            if '0'<=i<='9' or 'a'<=i<='z':  
+                new.append(i)  
+  
+        return new==new[::-1]  
+```

129._sum_root_to_leaf_numbers.md

@@ -0,0 +1,37 @@
+###129. Sum Root to Leaf Numbers
+
+题目:
+<https://leetcode.com/problems/sum-root-to-leaf-numbers/>
+
+
+难度:
+
+Medium
+
+其实递归不难想到，不过我自己做错在细节方面
+
+如果只有单支，每朝下走一层，代表的数字都增加10， 10* 原本的 + 新节点的数字，最终也是用这个来解
+
+```
+class Solution(object):
+    def sumNumbers(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        return self.calSum(root,0)
+    
+    
+    def calSum(self,root,curSum):
+        if root == None:
+            return 0
+        else:
+            curSum = curSum * 10 + root.val
+            if root.left == None and root.right == None:
+                return curSum
+            else:
+                return self.calSum(root.left, curSum) + self.calSum(root.right, curSum)
+        
+
+                
+```

238._product_of_array_except_self.md

@@ -0,0 +1,100 @@
+###238. Product of Array Except Self
+
+题目:
+<https://leetcode.com/problems/product-of-array-except-self/>
+
+
+难度:
+
+Medium
+
+
+不使用division 并且O(n)
+
+
+想到的算法 O(n^2)
+
+会超时
+
+
+```
+class Solution(object):
+        def productExceptSelf(self,nums):
+            """
+            :type nums: List[int]
+            :rtype: List[int]
+            """
+            lst = []
+            for i in range(len(nums)):
+                lst.append(self.productWithoutI(nums,i))
+            return lst
+        
+
+        def productWithoutI(self,nums,i):
+            product = 1
+            for j in range(len(nums)):
+                if j != i:
+                    product *= nums[j]
+            return product
+```
+
+如果用除法，也会有问题，如果有0出现也会变繁琐。
+
+谷歌一下：
+
+
+解法还是很棒的
+
+    output[i] =  { i 前面的数的乘积}  X  { i 后面的数的乘积}
+
+
+```
+class Solution(object):
+        def productExceptSelf(self,nums):
+            """
+            :type nums: List[int]
+            :rtype: List[int]
+            """
+            if nums == [] : return []  
+            lft = [1]
+            rgt = [1]
+            product = 1 
+            for i in range(1,len(nums)):
+                product *= nums[i-1]
+                lft.append(product)
+            product = 1 
+            for i in reversed(range(1,len(nums))):
+                product *= nums[i]
+                rgt.append(product)
+            rgt.reverse()
+            result = []
+            for i in range(len(nums)):
+                result.append(lft[i]*rgt[i])
+            return result
+            
+```
+
+
+空间O（n），再看到满足要求的“标准解法”
+
+
+```
+class Solution(object):
+        def productExceptSelf(self,nums):
+            """
+            :type nums: List[int]
+            :rtype: List[int]
+            """
+            if nums == [] : return []  
+            size = len(nums)
+            output = [1] * size
+            left = 1
+            for x in range(size-1):
+                left *= nums[x]
+                output[x+1] *= left
+            right = 1
+            for x in range(size - 1, 0, -1):
+                right *= nums[x]
+                output[x-1] *= right
+            return output
+```