2020-03-09

Author: JiayangWu

0543.二叉树的直径/0543-二叉树的直径.py

@@ -13,14 +13,8 @@ def diameterOfBinaryTree(self, root):
         """
         if not root:
             return 0
-        self.res = 0
-        def height(node):
+        def Height(node):
             if not node:
                 return 0
-            left_h = height(node.left)
-            right_h = height(node.right)
-            
-            self.res = max(self.res, left_h + right_h) 
-            return 1 + max(left_h, right_h)
-        height(root)
-        return self.res
+            return 1 + max(Height(node.left), Height(node.right))
+        return max(self.diameterOfBinaryTree(root.left), Height(root.left) + Height(root.right), self.diameterOfBinaryTree(root.right))

面试题47.礼物的最大价值/面试题47-礼物的最大价值.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def maxValue(self, grid):
+        """
+        :type grid: List[List[int]]
+        :rtype: int
+        """
+        if not grid or not grid[0]:
+            return 0
+        m, n = len(grid), len(grid[0])
+        
+        for i in range(1, n):
+            grid[0][i] += grid[0][i - 1]
+            
+        for i in range(1, m):
+            grid[i][0] += grid[i - 1][0]
+            
+        for i in range(1, m):
+            for j in range(1, n):
+                grid[i][j] += max(grid[i - 1][j], grid[i][j - 1])
+                
+        return grid[-1][-1]
+        

面试题50.第一个只出现一次的字符/面试题50-第一个只出现一次的字符.py

@@ -0,0 +1,14 @@
+class Solution(object):
+    def firstUniqChar(self, s):
+        """
+        :type s: str
+        :rtype: str
+        """
+        from collections import Counter
+        
+        dic = Counter(s)
+        
+        for ch in s:
+            if dic[ch] == 1:
+                return ch
+        return " "

面试题52.两个链表的第一个公共节点/面试题52-两个链表的第一个公共节点.py

@@ -0,0 +1,39 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def getIntersectionNode(self, headA, headB):
+        """
+        :type head1, head1: ListNode
+        :rtype: ListNode
+        """
+        la, lb = 0, 0
+        
+        p = headA
+        while p:
+            la += 1
+            p = p.next
+            
+        p = headB
+        while p:
+            lb += 1
+            p = p.next 
+            
+        if la < lb:
+            headA, headB = headB, headA
+            la, lb = lb, la
+            
+        cnt = la - lb
+        p = headA
+        while cnt:
+            cnt -= 1
+            p = p.next 
+            
+            
+        while p != headB:
+            p = p.next 
+            headB = headB.next 
+        return p

面试题53-I.在排序数组中查找数字I/面试题53-I-在排序数组中查找数字I.py

@@ -0,0 +1,8 @@
+class Solution(object):
+    def search(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: int
+        """
+        return nums.count(target)

面试题53-II.0～n-1中缺失的数字/面试题53-II-0～n-1中缺失的数字.py

@@ -0,0 +1,16 @@
+class Solution(object):
+    def missingNumber(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        for i, num in enumerate(nums):
+            if num == len(nums):
+                continue
+            if num != i:
+                nums[num], nums[i] = nums[i], nums[num]
+                
+        for i in range(len(nums)):
+            if nums[i] != i:
+                return i
+        return len(nums)

面试题54.二叉搜索树的第k大节点/面试题54-二叉搜索树的第k大节点.py

@@ -0,0 +1,36 @@
+# 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 kthLargest(self, root, k):
+        """
+        :type root: TreeNode
+        :type k: int
+        :rtype: int
+        """
+        def inorder(node):
+            if not node:
+                return []
+            return inorder(node.left) + [node.val] + inorder(node.right)
+        
+        return inorder(root)[-k]
+#         self.res = None
+#         def dfs(node, left):
+#             if not node:
+#                 return None
+
+#             if not self.res:
+#                 dfs(node.right, left)
+#                 if node.right:
+#                     left -= 1
+#                 if left == 1:
+#                     self.res = node.val
+#                     return
+#                 dfs(node.left, left - 1)
+            
+#         dfs(root, k)
+#         return self.res

面试题55-I.二叉树的深度/面试题55-I-二叉树的深度.py

@@ -0,0 +1,16 @@
+# 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 maxDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root:
+            return 0
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))

面试题57.和为s的两个数字/面试题57-和为s的两个数字.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        left, right = 0, len(nums) - 1
+        while left < right:
+            s = nums[left] + nums[right]
+            
+            if s == target:
+                return [nums[left], nums[right]]
+            elif s > target:
+                right -= 1
+            else:
+                left += 1

面试题68-I.二叉搜索树的最近公共祖先/面试题68-I-二叉搜索树的最近公共祖先.py

@@ -0,0 +1,20 @@
+# 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 lowestCommonAncestor(self, root, p, q):
+        """
+        :type root: TreeNode
+        :type p: TreeNode
+        :type q: TreeNode
+        :rtype: TreeNode
+        """
+        if min(p.val, q.val) <= root.val <= max(p.val, q.val):
+            return root 
+        if max(p.val, q.val) < root.val:
+            return self.lowestCommonAncestor(root.left, p, q)
+        return self.lowestCommonAncestor(root.right, p, q)