leetcode算法题复习01

面试准备好了吗

已于 2022-08-28 16:22:25 修改

阅读量85

点赞数

分类专栏：测试开发面试文章标签： leetcode 算法

于 2022-08-14 17:22:44 首次发布

本文链接：https://blog.csdn.net/Habc5050/article/details/126331219

版权

测试开发面试专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        #暴力法 循环遍历 创建一个空的列表 用于存放以后的下标索引 
        result = []
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                sum = nums[i]+nums[j]
                if sum==target:               #找到了就加到列表中
                    result.append(i)
                    result.append(j)
        return result

9.回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

class Solution:
    def isPalindrome(self, x: int) -> bool:
        #将列字符串左右两部分进行对比
        s = str(x)
        l = len(s)
        h = l//2
        if l%2 ==0:#如果是偶数个
            return s[:h]==s[-1:h-1:-1] 
        else:
            return s[:h]==s[-1:h:-1]

14.最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 ""。

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:#先考虑字符串为空的情况
            return ""

        res= min(strs,key=len)#先获得最短的字符串
        for s in strs:#遍历整个列表 依次对比每一个字符串和最短的字符串 
            for j in range(len(res)):#从最短字符串的最后一个元素开始对比 如果不相等就往前走 
                if s[j]!=res[j]:
                    res = res[:j]
                    break
        return res

20.有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

class Solution:
    def isValid(self, s: str) -> bool:
        stc = []#创建一个列表 用于存放括号 栈的思想 左括号进栈右括号出栈并检查是否匹配 最好栈空
        for c in s:
            #左括号入栈
            if c in ['(','{','[']:
                stc.append(c)
                #右括号出栈 且栈不为空 进行匹配
            elif c==')' and stc and stc[-1]=='(':
                stc.pop()
            elif c=='}' and stc and stc[-1]=='{':
                stc.pop()
            elif c==']' and stc and stc[-1]=='[':
                stc.pop()
            else:
                return False
            #如果最后栈不为空就不是有效的括号
        return not stc

26.删除有序数组中的重复项(重点:有点忘记)

给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        n = len(nums)#从后往前遍历列表 从前往后遍历长度会改变 不好控制循环条件
        for i in range(n-1,0,-1):
            if nums[i] == nums[i-1]:
                nums.pop(i)

27.移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        #快慢指针 快指针用来依次遍历每个元素 判断是否与val相同 不同赋值给慢指针
        # fast=slow =0
        # while fast < len(nums):
        #     if nums[fast] != val:
        #         nums[slow] = nums[fast]
        #         slow +=1
        #     fast +=1
        # return slow
        n = len(nums)#和第26题类似做法
        for i in range(n-1,-1,-1):
            if nums[i] == val:
                nums.pop(i)
        return len(nums)

28.实现strStr()(重点:有点忘记)

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        #字符串比较 
        for i in range(len(haystack)-len(needle)+1):#长度如果比needle小不用遍历
            if haystack[i:i+len(needle)]==needle:
                return i
        return -1

        # def strStr(self, haystack: str, needle: str) -> int: #方法二:直接使用index()函数
        # try:
        #     return haystack.index(needle)
        # except:
        #     return -1

35.搜索插入位置

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

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        left =0 #二分法
        right = len(nums)-1
        while left <= right:
            mid = (left + right)//2
            if nums[mid] <target:
                left = mid+1
            elif nums[mid] > target:
                right = mid -1
            elif nums[mid] == target:
                return mid
        return left

55.跳跃游戏贪心算法

给定一个非负整数数组 nums ，你最初位于数组的第一个下标。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        max_num= 0
        for i in range(len(nums)):
            if max_num<i:
                return False
            max_num = max(max_num,i+nums[i])
        return True
    
        #官网解答  遍历每个元素 看每个元素中的数字是否可以跳跃到最后一个# 
    def canJump(self, nums: List[int]) -> bool:
        n, rightmost = len(nums), 0
        for i in range(n):
            if i <= rightmost:
                rightmost = max(rightmost, i + nums[i])
                if rightmost >= n - 1:
                    return True
        return False

66.加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        carry = 1#循环遍历 现在最低位加
        n = len(digits)
        for i in range(n-1,-1,-1):
            if digits[i]==9:
                if carry ==1:
                    digits[i] = 0
                    carry = 1
            else:
                digits[i] += carry#不能直接加1 加carry
                carry = 0
        if carry ==1:
            digits=[1]+digits
        
        return digits

136.只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

class Solution:
    def singleNumber(self, nums: List[int]) -> int:#自己参照删除重复有序数组写的，后续其他法
        list_one = []
        for i in range(len(nums)):
            if nums[i] in list_one:
                list_one.remove(nums[i])
            else:
                list_one.append(nums[i])
        return list_one[0]

206.反转链表

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre,cur = None,head
        while cur:
            tmp = cur.next
            cur.next = pre
            pre =cur
            cur = tmp
        return pre

278.第一个错误版本

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

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

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

class Solution:
    def firstBadVersion(self, n: int) -> int:#二分法
        l = 1
        r = n
        while l<r:
            mid = (l+r)//2
            if isBadVersion(mid):
                r = mid
            else:
                l = mid +1#######重要 
        return l

704.二分查找

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

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        # for i in range(len(nums)):#暴力法
        #     if nums[i] == target:
        #         return i
        # return -1
        l = 0#二分法
        r = len(nums)-1
        while l<=r:
            mid = (l+r)//2
            if nums[mid] == target:
                return mid
            elif nums[mid] < target:
                l = mid+1
            elif nums[mid] > target:
                r = mid-1
        return -1

剑指 Offer 58 - II. 左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        #方法一 切片方法
        #return s[n:]+s[0:n]
        #方法二 使用revese()函数和join函数
        # s = list(s)
        # s[0:n] = list(reversed(s[0:n]))
        # s[n:] = list(reversed(s[n:]))
        # s.reverse()

        # return "".join(s)
        #方法三 创建一个新的列表 依次遍历 逐个添加元素到该列表中
        new_s = ''
        for i in range(len(s)):
            j = (i+n)%len(s)
            new_s = new_s +s[j]
        return new_s