2019-07-16

Author: JiayangWu

0161.相隔为1的编辑距离/0161-相隔为1的编辑距离.py

@@ -0,0 +1,32 @@
+class Solution(object):
+    def isOneEditDistance(self, s, t):      
+        distance = len(s) - len(t)
+        if abs(distance) > 1: #长度都差了不止一位，肯定不对
+            return False
+        if not s or not t: #两者有一个为空返回真，两个都为空返回假
+            return s != t
+        
+        edit = 0 #代表编辑次数
+        i, j = 0, 0
+        while i < len(s) and j < len(t):
+            if s[i] == t[j]: #无需编辑
+                i += 1 #两个指针都顺序后延一位
+                j += 1
+            else:
+                if edit: #唯一的机会已经用完了
+                    return False
+                if distance == 1: #删除
+                    i += 1
+                elif distance == -1:#插入
+                    j += 1
+                else: #替换
+                    i += 1
+                    j += 1
+                edit += 1
+
+        if i < len(s): #如果t没了，s还多了一位，取决于edit还是不是0
+            return edit == 0
+        if j < len(t): #如果s没了，t还多了一位，取决于edit还是不是0
+            return edit == 0
+        
+        return i == len(s) and j == len(t) and edit == 1 

0164.最大间距/0164-最大间距.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def maximumGap(self, nums):
+        if len(nums) < 2:
+            return 0
+        min_val, max_val = min(nums), max(nums)
+        if min_val == max_val:
+            return 0
+        
+        n = len(nums) + 1 # 桶的个数
+        step = (max_val - min_val) // n
+        
+        exist = [0 for _ in range(n + 1)]  #表示桶是否为空
+        max_num = [0 for _ in range(n + 1)]#表示桶里元素的最大值
+        min_num = [0 for _ in range(n + 1)]#表示桶离元素的最小值
+        
+        for num in nums: #把所有的数入桶
+            idx = self.findBucketIndex(num, min_val, max_val, n) 
+            max_num[idx] = num if not exist[idx] else max(num, max_num[idx])
+            min_num[idx] = num if not exist[idx] else min(num, min_num[idx])
+            exist[idx] = 1
+        res = 0
+        pre = max_num[0]
+        for i in range(1, n + 1):
+            if exist[i]:
+                res = max(res, min_num[i] - pre)
+                pre = max_num[i]
+        return res
+                        
+    def findBucketIndex(self, num, min_val, max_val, n):
+        return int((num - min_val) * n / (max_val - min_val))

0165.比较版本号/0165-比较版本号.py

@@ -0,0 +1,39 @@
+class Solution(object):
+    def compareVersion(self, version1, version2):
+        """
+        :type version1: str
+        :type version2: str
+        :rtype: int
+        """
+        l1 = version1.split(".")
+        l2 = version2.split(".")
+        
+        i, j = 0, 0
+        while i < len(l1) and j < len(l2): # 逐位比大小
+            num1, num2 = int(l1[i]), int(l2[j])
+            if num1 < num2:
+                return -1
+            elif num1 > num2:
+                return 1
+            i += 1
+            j += 1
+
+        if len(l1) == len(l2) and num1 == num2: #长度相等而且最后一位也相等
+            return 0
+
+        if len(l1) > len(l2): #如果l1还在而l2结束了
+            while i < len(l1) and int(l1[i]) == 0:  #判断l1后面是不是全是0
+                i += 1
+            if i == len(l1): #如果全是0，则还相等
+                return 0
+            else:
+                return 1
+            
+        if len(l2) > len(l1):
+            while j < len(l2) and int(l2[j]) == 0: #判断l2后面是不是全是0
+                j += 1
+            if j == len(l2): #如果全是0，则还相等
+                return 0
+            else:
+                return -1
+            return -1

5119.删点成林/5119-删点成林.py

@@ -5,6 +5,7 @@
 #         self.left = None
 #         self.right = None
 
+
 class Solution(object):
     def delNodes(self, root, to_delete):
         """
@@ -30,7 +31,7 @@ def delNodes(self, root, to_delete):
         def dfs(node):
             if not node:
                 return
-
+ 
             if node.left and node.left.val in to_delete:  #左节点要删
                 dfs(node.left)
                 if node.left.left: #左节点的左节点还在，不需要删
@@ -48,11 +49,9 @@ def dfs(node):
                     self.roots += [node.right.right]
 
                 node.right = None
-
+ 
             dfs(node.left)
             dfs(node.right)
 
         dfs(root)
         return self.roots
-            
-