LeetCode题集二（Python实现）

---

简单题

35. 搜索插入位置

题目：

思路：

主要有两个思路：

1. 将目标数直接插入，然后使用sort()方法排序后，再用index()查找目标数的位置；
2. 直接遍历数组，查找相应位置。

解法：

• 插入后查找位置

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        if not nums:
            return 0
        
        nums.append(target)
        nums.sort()
        return nums.index(target)

• 遍历数组比对大小

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
	    return len([i for i in nums if i < target])

---

38. 外观数列

题目：

思路：

想了半天感觉使用双指针实现是比较合适的方法，一个指针p指向当前的数字，一个指针q后移来比对。

1. 当前后相同时候，指针q后移
2. 当前后不同的时候，统计出相同的个数和数字，之后p更新到q的位置，q继续后移

解法：

class Solution:
    def countAndSay(self, n: int) -> str:
        res = "1"
        if n == 1:
            return res
        
        for _ in range(n-1):  # 需要计算n-1次
            p, q = 0, 1 # 双指针
            tmp = ""
            while q <= len(res):
                if q == len(res):  # 防止溢出
                    tmp = tmp + str(q-p) + res[p]
                elif res[q] != res[p]:
                    tmp = tmp + str(q-p) + res[p]
                    p = q
                q += 1
            res = tmp
        return res

---

53. 最大子序和

题目：

思路：

运用动态规划dp的思想，当前位置的最大值肯定是：1.由前面位置的最大值与当前位置的值的和；2.就是当前位置的值。

解法：

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        max_sum = tmp_sum = nums[0]
        for num in nums[1:]:
            tmp_sum = max(num, num + tmp_sum)
            max_sum = max(max_sum, tmp_sum)
        return max_sum

		# 简化写法
        # for i in range(1,len(nums)):
        #     nums[i] = max(nums[i-1]+nums[i], nums[i])
        # return max(nums)

---

58. 最后一个单词的长度

题目：

思路：

使用strip()方法把前后空格除去，之后使用split()拆分获取最后一个单词，之后便可长度

解法：

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        if not s:
            return 0

        res = s.strip(" ").split(" ")[-1]
        return len(res)

---

66. 加一

题目：

思路：

1.直接在列表上操作，从后遍历
2.转为数字后计算再转为列表

解法：

• 从后遍历

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
    	# 遍历
        for i in range(len(digits)-1, -1, -1):        	
        	# 如果最后一位不是9的话 
            if digits[i] is not 9:
                digits[i] += 1
                break
			
			# 如果最后一位是9的话，置0
            digits[i] = 0
			
			# 当第一数是0的话，说明该进位了
            if digits[0] is 0:
                digits.insert(0, 1)

        return digits 

• 转数字法

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        a = [i * 10**index for index,i in enumerate(digits[::-1])]
        num = sum(a) + 1
        return [int(x) for x in str(num)]

---

67. 二进制求和

题目：

思路：

python里有可以将二进制转化为十进制的函数，直接调用

解法：

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        num = int(a, 2) + int(b, 2)
        ans = bin(num)
        return ans[2:]

---

69. x 的平方根

题目：

思路：

1.暴力破解，一个个查找
2.二分法查找
3.次方求解

解法：

• 暴力求解

class Solution:
    def mySqrt(self, x: int) -> int:
    	# 暴力求解
        if x == 0:
            return 0

        res = 1
        while True:
            if res**2 <= x < (res+1)**2:
                return res
            res += 1  

• 二分查找

class Solution:
    def mySqrt(self, x: int) -> int:
        # 二分查找
        l, h = 0, x
        while l < h:
            m = (l + h) // 2
            if m**2 <= x < (m+1)**2:
                return m
            elif m**2 < x:
                l = m + 1
            else:
                h = m - 1
        return l

• 次方求解

class Solution:
    def mySqrt(self, x: int) -> int:
        # 直接求根号
        return int(x**0.5)

---

70. 爬楼梯

题目：

思路：

类似于斐波那契数列，后项等于前两项之和。

解法：

• 递归实现

class Solution:
    def climbStairs(self, n: int) -> int:
        if n == 1:
            return 1
        if n == 2:
            return 2
        
        res = self.climbStairs(n-1) + self.climbStairs(n-2)

        return res

• 非递归实现

class Solution:
    def climbStairs(self, n: int) -> int:
        if n == 1:
            return 1
        if n == 2:
            return 2

        res_f, res_s = 1, 2
        for i in range(2, n):
            res_f, res_s = res_s, res_f + res_s
        return res_s

---

83. 删除排序链表中的重复元素

题目：

思路：

常规解法，直接一个个找下去对比即可

解法：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:

        res = head
       
        while head and head.next:
            if head.next.val == head.val:
                head.next = head.next.next
            else:
                head = head.next

        return res 

---

88. 合并两个有序数组

题目：

思路：

为了不让前面的数被覆盖，考虑从末尾一一比较，最大的放在后面，然后依次执行，达成排序。

解法：

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        p, q = m-1, n-1
        while p >= 0 and q >= 0:
            if nums1[p] > nums2[q]:
                nums1[p+q+1] = nums1[p]
                p = p-1
            else:
                nums1[p+q+1] = nums2[q]
                q = q-1
        nums1[:q+1] = nums2[:q+1]

---