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刷题之路,任重而道远。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值