leetcode刷题：第一周

系列文章目录

leetcode刷题：第一周

---

前言

。
博主刚刚结束了RHCE的学习，下一步决定刷一刷leetcode的算法题，一天2-3道，周末巩固复习。

---

第一天

1.二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        low = 0
        height = len(nums)-1
        mid = (height + low) // 2
        while low != height:
            if nums[mid] == target:
                return mid
            if nums[mid] < target:
                low = mid+1
            else:
                height = mid
            mid = int((low + height) / 2)
        if nums[low]==target:
            return low
        return -1

2.第一个错误版本

假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例 1：

输入：n = 5, bad = 4
输出：4
解释：
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。
示例 2：

输入：n = 1, bad = 1
输出：1

class Solution:
    def firstBadVersion(self, n):
        low=1
        height=n
        mid = int(low + (height - low) / 2)
        while low != height:
            print(low,mid,height)
            if isBadVersion(mid):
                if isBadVersion(mid-1):
                    height=mid-1

            if isBadVersion(mid):
                if isBadVersion(mid-1) is False:
                    return mid

            if isBadVersion(mid) is False:
                if isBadVersion(mid-1) is False:
                    low=mid+1

            if isBadVersion(mid) is False:
                if isBadVersion(mid+1):
                    return (mid+1)
            mid = int(low + (height - low) / 2)
        return 1

注：当low和height的长度都超过int类型的一半时，mid=（low+height）//2，会产生溢出，要使用。mid = int(low + (height - low) / 2)

3.搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2
示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1
示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4
示例 4:

输入: nums = [1,3,5,6], target = 0
输出: 0
示例 5:

输入: nums = [1], target = 0
输出: 0

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        low = 0
        height = len(nums) - 1
        mid = (height + low) // 2
        while low != height:
            #print(low, mid, height)

            if nums[mid] == target:
                return mid
            if nums[mid] < target:
                low = mid + 1
            else:
                height = mid
            mid = int((low + height) / 2)
        if nums[low] == target:
            return low
        if nums[0]>target:
            return 0
        if nums[-1]<target:
            return len(nums)
        return low

直接在第一题上简单修改。

第二天

1.有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        sqrt=[]
        for i in nums:
            z=pow(i,2)
            sqrt.append(z)
        sqrt.sort()
        return sqrt

2.轮转数组

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]
示例 2:

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释:
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        k=k%len(nums)
        for i in range(k):
            a=nums.pop()
            nums.insert(0,a)

注：题目最后只会返回数组的源地址，所以不能修改数组的地址指向。

第三天

1.移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:

输入: nums = [0]
输出: [0]

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        for i in range(nums.count(0)):
            nums.remove(0)
            nums.append(0)

2.两数之和 II - 输入有序数组

给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列 ，请你从数组中找出满足相加之和等于目标数 target 的两个数。如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。

以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。

你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。

你所设计的解决方案必须只使用常量级的额外空间。

示例 1：

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
示例 2：

输入：numbers = [2,3,4], target = 6
输出：[1,3]
解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。
示例 3：

输入：numbers = [-1,0], target = -1
输出：[1,2]
解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2]

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        left = 0
        right = len(numbers)-1
        while left != right:
            if numbers[left] + numbers[right] == target:
                return [left + 1, right + 1]
            if numbers[left] + numbers[right] < target:
                left = left + 1
            else:
                right = right - 1

注：本题采用双指针解法，头和尾各一个指针，相加等于目标返回索引，小于目标左指针右移，大于目标，右指针左移。

第四天

1.反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

示例 1：

输入：s = [“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]
示例 2：

输入：s = [“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

class Solution:
    def reverseString(self, s: List[str]) -> None:
        left = 0
        right = len(s) - 1
        while left < right:
            if s[left] == s[right]:
                left = left + 1
                right = right - 1
                continue
            s[left], s[right] = s[right], s[left]
            left = left + 1
            right = right - 1

注：双指针，头尾交换后一起向中心移动。

2.反转字符串中的单词 III

给定一个字符串 s ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 1：

输入：s = “Let’s take LeetCode contest”
输出：“s’teL ekat edoCteeL tsetnoc”
示例 2:

输入： s = “God Ding”
输出：“doG gniD”

def reverseString(s):
    s=list(s)
    left = 0
    right = len(s) - 1
    while left < right:
        s[left], s[right] = s[right], s[left]
        left = left + 1
        right = right - 1
    s="".join(s)
    return s

class Solution:
    def reverseWords(self, s: str) -> str:
        ls=s.split()
        reult=[]
        for i in ls:
            item=reverseString(i)
            reult.append(item)
        s=" ".join(reult)
        return s

第五天

1.链表的中间结点

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

示例 1：

输入：[1,2,3,4,5]
输出：此列表中的结点 3 (序列化形式：[3,4,5])
返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
注意，我们返回了一个 ListNode 类型的对象 ans，这样：
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
示例 2：

输入：[1,2,3,4,5,6]
输出：此列表中的结点 4 (序列化形式：[4,5,6])
由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        slow=fast=head
        while fast and fast.next:
            slow=slow.next
            fast=fast.next.next
        return slow

注：这里使用快慢指针，快指针一次右移两位，慢指针一次右移一位，当快指针移动到末尾时，慢指针移动到中间节点。

2.删除链表的倒数第 N 个结点

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：

输入：head = [1], n = 1
输出：[]
示例 3：

输入：head = [1,2], n = 1
输出：[1]

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        slow=fast=head
        if head.next is None:
            return None
        for i in range(n):
            fast=fast.next
        while fast is not None and fast.next is not None:
            slow=slow.next
            fast=fast.next
        if fast is None:
            head=slow.next
            return head
        slow.next=slow.next.next
        return head

注：双指针，右指针现在n步，然后左右指针同时右移，当右指针到达末尾，做指针到达要删除节点的前一个结点。

第六天

1.无重复字符的最长子串

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        string_dict = {}
        start = 0
        end=0
        max=0
        if s == "":
            return 0
        for i in range(len(s)):
            end = i
            if s[end] in s[start:end]:
                start = string_dict[s[end]] + 1
                string_dict[s[i]] = i
            else:
                string_dict[s[i]] = i
            item=(end - start) + 1
            if item>max:
                max=item
        return max

注：采用双指针，右指针右移添加新字符，若字符在左右指针范围内，左指针右移动到该字符的下一位，然后右指针右移。若字符不在范围内左指针不动，右指针继续右移。每次指针移动记录指针的间距，结束后返回最大值。

2.字符串的排列

给你两个字符串 s1 和 s2 ，写一个函数来判断 s2 是否包含 s1 的排列。如果是，返回 true ；否则，返回 false 。

换句话说，s1 的排列之一是 s2 的 子串 。
示例 1：

输入：s1 = “ab” s2 = “eidbaooo”
输出：true
解释：s2 包含 s1 的排列之一 (“ba”).
示例 2：

输入：s1= “ab” s2 = “eidboaoo”
输出：false

class Solution:
    def checkInclusion(self, s1: str, s2: str) -> bool:
    	#n1,n2记录字符长度
        n1 = len(s1)
        n2 = len(s2)
        #dict1，dict2记录字符串种类和数量
        dict1 = {}
        dict2 = {}
        #填充dict1
        for i in s1:
            if i in dict1:
                dict1[i] = dict1[i] + 1
            else:
                dict1[i] = 1
		#当s1长度>s2，不符合题意
        if n1 > n2:
            return False
        #当s1长度为1，直接if判断结果
        if n1 ==1:
            if s1 in s2:
                return True
            else:
                return False
        #当s1和s2相同，直接返回结果
        while n1 == n2:
            if s1 == s2:
                return True
            else:
                break
		#记录第一个s2滑动窗口的种类和数量
        for i in s2[0:n1]:
            if i in dict2:
                dict2[i] = dict2[i] + 1
            else:
                dict2[i] = 1
        #如果两个字典结果相同，然会结果
        if dict1 == dict2 :
            return True
        for i in range(1,(n2 - n1) + 1):
        	#窗口移动，改变dict2，两个字典比较返回结果
            s = s2[i:i + n1]
            x=s2[i-1]
            y=s2[i+n1-1]
            if x==y:
                continue

            dict2[x]=dict2[x]-1
            if dict2[x]==0:
                del dict2[x]

            if y in dict2:
                dict2[y]=dict2[y]+1
            else:
                dict2[y]=1
            if dict1==dict2:
                return True

        return False

总结

leetcode刷题之路，任重而道远。