Python-----LeetCode刷题日志1.0（基础20题）

最新推荐文章于 2024-05-08 20:54:14 发布

Fitz&

最新推荐文章于 2024-05-08 20:54:14 发布

阅读量365

点赞数

分类专栏： Python进阶 Python学习文章标签： leetcode 算法职场和发展 python 开发语言

本文链接：https://blog.csdn.net/m0_73633088/article/details/129497754

版权

Python学习同时被 2 个专栏收录

34 篇文章 20 订阅

订阅专栏

Python进阶

21 篇文章 0 订阅

订阅专栏

前言：

这里我给大家分享我最近在LeetCode刷的题，大概20道左右，编程语言：Python。希望大家喜欢。

1.两数之和

最直接的做法就是利用双层循环，直接去找这两个数字，让它们相加对于target的值，如果找到就把这两个数字添加到列表li中返回，代码如下：

class Solution(object):
    def twoSum(self, num, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        li=[]
        for i in range(len(num)):
            for j in range(i+1,len(num)):
                if target==num[i]+num[j]:
                    li.append(i)
                    li.append(j)
                    break
        return li

2.回文数

先把这个数字转换为字符串形式，然后我们可以去通过正序和倒序去一一对比每个字符，如果出现不同就返回False,代码如下：

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        x=str(x)
        for (i,j) in zip(range(len(x)),range(len(x)-1,-1,-1)):
            if x[i]!=x[j]:
                return False
        return True

3.最长公共前缀

这道题我们可以去使用zip函数直接秒杀，先对每一个列表进行解压缩*，然后得到多个字符串，通过zip函数把每一组字符串单个字符进行组合，然后转换为集合的形式查看这个集合的长度，如果长度为1，那么就说明这组的单个字符相同，代码如下：

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        a = str()
        if strs:
            for i in zip(*strs):
                if len(set(i))==1:
                    a+=i[0]
                else:
                    return a
        
        return a

4.有效的括号

这道题也是有很简单的方法，只是不好想到。这一类括号匹配问题，总是会存在{}，（）,[ ]这三类括号中的一个(如果出现[)、{ ]的话那就取代不了)，所以我们只需要把这三类括号进行不断的取代为空'' ,如果最后取代完成了之后这个字符串变为空的话就可以输出True，反正输出False，代码如下：

class Solution:
    def isValid(self, s):
        while '{}' in s or '()' in s or '[]' in s:
            s = s.replace('{}', '')
            s = s.replace('[]', '')
            s = s.replace('()', '')
        return s == ''

5.删除有序数组中的重复项

我们可以去通过循环吧前一个和后面一个数字进行比较，但是有一个问题，那就是最后一个数字不知道跟谁比较，所以我们需要去添加一个字符'a'作为一个参照，这类题我们在c语言基本做到烂了，下面看代码吧：

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums.append('a')
        k=0
        for i in range(len(nums)-1):
            if nums[i]!=nums[i+1]:
                nums[k]=nums[i]
                k+=1
        return k

6.移除元素

对于这类题，做法跟上面那道题是差不多的，看代码吧：

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        k=0
        for i in range(len(nums)):
            if nums[i]!=val:
                nums[k]=nums[i]
                k+=1
          
        return k

7.最后一个单词的长度

class Solution(object):
    def lengthOfLastWord(self, s):
        """
        :type s: str
        :rtype: int
        """
        count=0
        k=0
        for i in range(len(s)-1,-1,-1):
            if k==1:
                k=0
            if s[i]==' ':
                k+=1
            else:
                count+=1
                k=2
            if k==3:
                break
        return count

我们可以直接倒序去检测，当遇到空格的时候k就+1，当k=1的时候，k就回到0，就这样一直下去，直到遇到非空格的时候（此时是最后一个单词）此时k的值为0，然后count就开始计数，k就赋值为2，直到再次遇到空格的时候说明最后一个单词计数完成了，就应该结束循环，此时k=2+1=3，结束循环

8.爬楼梯

其实这道题，最开始我也是没什么思路，但是当我往后面写了几个数字就发现规律了，也就是1,2,3,5,8,13……也就是说后面的一个等于前面的两个之和，简直就是跟斐波那契数列一样，这时候我们就可以去写代码了。

本质方法：你可以想象一下，在总数为n个阶梯，当你遇到最后两个阶梯或者最后一个阶梯的时候，你是可以直接一步跨过去的，好，那在此之前你是不是跨了n-1个阶梯或者n-2个阶梯呢？所以我们可以假设夸n个阶梯有f(n) 种方法，所以这不就有了 f(n)=f(n-1)+f(n-2)，这不是斐波那契数列嘛！！！

class Solution(object):
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        a,b=1,1
        while n>1:
            a,b=b,a+b
            n-=1
        return b

9.合并两个有序数组

这道题非常简单，直接把num1倒数n项直接换成num2就行了，然后用sort() 函数直接排序就是了，代码如下：

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        if n!=0:
            nums1[-n:]=nums2
        nums1.sort()

10.杨辉三角

杨辉三角的规律如下所示，所以我们需要先生成numRows个列表，直接按照杨辉三角的规律去添加就行了。看代码：

class Solution(object):
    def generate(self, numRows):
        """
        :type numRows: int
        :rtype: List[List[int]]
        """
        li=[[1] for i in range(numRows)]
        for i in range(1,numRows):
            for j in range(1,i):
                if i>1:
                    li[i].append(li[i-1][j-1]+li[i-1][j])
            li[i].append(1)
        return li

10.验证回文串

思路很直接，先转换为小写，然后把里面的数字字符和字母字符提取出来就行了，最后就是正序和倒序比较，上代码：

class Solution(object):
    def isPalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        st=str()
        s=s.lower()
        for i in range(len(s)):
            if 'a'<=s[i]<='z' or '0'<=s[i]<='9':
                st+=s[i]
        if st==st[::-1]:
            return True
        else:
            return False

11.买卖股票的最佳时机

这道题我们可以去依次设置最小值min和差值最大值max，当遇到比当前数字min的情况就进行赋值，当与到差值比当前max差值还大的时候进行赋值，代码如下：

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        max=0
        min=prices[0]
        for p in prices[1:]:
            if min>p:
                min=p
                continue
            if max<p-min:
                max=p-min
        return max

12.多数元素

方法很简单，我们先把这个数组进行排序，然后输出其中的中位数就行了,代码如下：

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums.sort()
        return nums[int(len(nums)/2)]

13.位1的个数

这类题的方法是先把这个二进制数转换为十进制数，再把这个十进制数转换为字符串形式，很直接，用int() 函数把这个二进制转换为十进制，然后用bin（）函数把这个十进制转换为二进制字符串形式，代码如下：

class Solution:
    def hammingWeight(self, n: int) -> int:
        n=bin(int(n,2))
        return n.count('1')

14. 同构字符串

这道题也是灵活去利用zip（）函数，先要去判断这两个字符串集合化以后数量是不是相同，然后通过zip函数把这两个字符串结合到一起再进行集合化，如果集合化的数量与原来的数量相同的话那么就是同构字符串。

class Solution(object):
    def isIsomorphic(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        if len(set(s))==len(set(t)):
            k=len(set(s))
            li=set((zip(s,t)))
            if len(li)==k:
                return True
            else:
                return False
        else:
            return False

15.存在重复元素

这类题也是非常简单的，利用集合的去重功能，我们直接把原来的长度与集合化后的长度进行比较，如果相同那么就不存在重复元素，反之。代码如下：

class Solution(object):
    def containsDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        if len(nums)==len(set(nums)):
            return False
        return True

16.存在重复元素 II

这道题可以利用字典的功能去解决，先去创建一个空字典，我们利用enumerate函数分别获取到这个数字的下标和数值，然后以数值为键，下标为值，加入到字典里面去，当遇到相同的键时，去判断当前的值与已在字典的值的差是否小于k，满足条件就返回True,直到整个数组都循环了一遍还没有找到的话就返回False，代码如下：

class Solution(object):
    def containsNearbyDuplicate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        di={}
        for i,j in enumerate(nums):
            if j in di and i-di[j]<=k:
                return True
            else:
                di[j]=i
        return False

17.搜索插入位置

这里就要考虑到当前target是否大于这个数组的最大值或者小于最小值，还有这个数组是否为空等情况。代码如下：

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        if target in nums:
            return nums.index(target)
        else:
            for i in range(len(nums)):
                if target<nums[i]:
                    nums.insert(i,target)
                    return i
                elif i==len(nums)-1 and i!=0:
                    return i+1
                elif nums[i]>target and len(nums)==1:
                    return i
                elif nums[i]<target and len(nums)==1:
                    return i+1

18.二进制求和

思路很简单，把二进制数转换为十进制再进行相加，然后通过bin函数转换为二进制字符串输出就行了。

class Solution(object):
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        a=int(a,2)
        b=int(b,2)
        c=a+b
        c=bin(c)
        c=c[2:]
        return c

19.有效的字母异位词

对于这道题，我们可以通过字典的键值对性质去处理（字符为键，数量为值），依次去统计这两个字符串字母出现的次数，最后去判断这两个字典是否相等就行了，代码如下：

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        a={}
        b={}
        for i in s:
            if i in a:
                a[i]=a.get(i,0)+1
            else:
                a[i]=0
        for j in t:
            if j in b:
                b[j]=b.get(j,0)+1
            else:
                b[j]=0
        return a==b

20.丢失的数字

这组数字理论上是有n+1个数字的，但是又一个数字没有在里面，所以只有n个数字，我们只需要通过循环去一一匹配就行了，如果发现有数字没有在这个数组里面就返回这个数字。

class Solution(object):
    def missingNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        for i in range(len(nums)+1):
            if i not in nums:
                return i

好了，以上就是今天的全部内容了，我们下一期再见！！

分享一张壁纸：