leetcode数组类

按这篇文章顺序刷题：有没有人一起从零开始刷力扣 ，本系列博客记录刷题中的知识点，坚持做题和总结~
(ง •_•)ง

一、数组的遍历

题目1：414

# 解题思路：
# 1. 去重
# 2. 小于3位数，返回最大值
# 3. 大于等于2位数，返回第三大的数
class Solution:
    def thirdMax(self, nums: List[int]) -> int:
        new = set(nums)
        if len(new)<3:
            return max(new)
        else:
            new.remove(max(new))
            new.remove(max(new))
            return max(new)

题目2：485

# 解题思路：
# 1. 转化为字符串
# 2. 用0切分字符串
# 3. 计算字符串长度
class Solution:
    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
        new = ''
        count = []
        for i in nums:
            new += str(i)
        new_nums = new.split('0')
        for i in new_nums:
            count.append(len(i))
        return max(count)

# 我写的太麻烦了...实际这样写就可以
return len(max(''.join(map(str,nums)).split('0')))

题目3：495

# 解题思路：
# 1. 比较两次攻击的时间间隔，和，duration
# 2. 若两次攻击时间间隔＞duration，则经历完整duration
# 3. 反之，则只经历两次攻击的间隔时长

# 注意：最后一次攻击能经历一个duration，所以return要加上这部分，不要忘记
class Solution:
    def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:
        if not timeSeries:
            return 0
        ans=0
        for i in range(1,len(timeSeries)):
            ans += min(timeSeries[i]-timeSeries[i-1],duration)
        return ans+duration

题目4：628

# 解题思路：答案只存在两种情况中：有负数的话情况1种，没有负数的话情况1种
# 注意：不需要判断是否有负数，繁琐，直接max()就好了
class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        nums.sort()
        return max(nums[-1]*nums[-2]*nums[-3],nums[0]*nums[1]*nums[-1])

# 注：替代sort()的写法
class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        # 定义三个依次最大的数(还是要动手自己写才知道易错点，第一次写时 把这里写成float('inf')了，最后测试的结果全是inf = = 我好菜..)
        max1 = float('-inf')
        max2 = float('-inf')
        max3 = float('-inf')

        # 定义两个依次最小的数
        min1 = float('inf')
        min2 = float('inf')

        for num in nums:
            if num>max1:
                max3 = max2
                max2 = max1
                max1 = num
            elif num>max2:
                max3 = max2
                max2 = num
            elif num>max3:
                max3 = num

            if num<min1:
                min2 = min1
                min1 = num
            elif num<min2:
                min2 = num
        return max(max1*max2*max3,min1*min2*max1)

二、统计数组中的元素

题目5：41

# 答案示例解法：原地哈希
class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        # 解题思路：原地哈希
        # 第i-1位置放i，例：1在0位，2在1位，3在4位...

        # 数组长度
        size = len(nums)

        for i in range(size):
            # 判断值是否是索引；然后值-位不对应，则换位
            while 1<=nums[i]<=size and nums[i]!=nums[nums[i]-1]:
                self.__swap(nums,i,nums[i]-1)
        
        # 判断值-位对应与否，返回第一个不相等的数
        for i in range(size):
            if i+1 != nums[i]:
                return i+1

        return size+1
        
	# 类中函数定义需要加self，类外函数定义不需要
    def __swap(self,nums,index1,index2):
        nums[index1],nums[index2]=nums[index2],nums[index1]

# 自己乱写的版本...
class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        positive = []
        for i in nums:
            if i>0:
                positive.append(i)
        ans = 1
        while ans in positive:
            ans += 1
        if positive==[]:
            ans=ans
        elif ans == max(positive):
            ans = ans + 1
        else:
            ans=ans
        return ans

题目6：442（和上道题是同类型）

# 解法1：和上道题相同，原地哈希排序，然后判断值不配位的数字
class Solution:
    def findDuplicates(self, nums: List[int]) -> List[int]:
        size = len(nums)
        for i in range(size):
            while 1<=nums[i]<=size and nums[i]!=nums[nums[i]-1]:
                self.__swap(nums,i,nums[i]-1)
        
        ans = []
        for i in range(size):
            if i+1 != nums[i]:
                ans.append(nums[i])

        ans.sort()
        return ans

               
    def __swap(self,nums,index1,index2):
        nums[index1],nums[index2]=nums[index2],nums[index1]

# 解法2：这个解法是看别人的答案，很巧妙。
# 思路：
# （1）题干说数值取自[1,n] 就暗示可以利用元素值，将其看作是索引，我们只需要判断这个索引是不是被对应过2次就可以了
# （2）判断是否对应2次的依据就是，根据正负号。我们可以将数值看作索引对应到一个值，然后把对应到的值变成负号。
# （3）如果这个索引被第二次对应，则对应到的值此时已经是负，则直接添加到答案列表中就好了。
class Solution:
    def findDuplicates(self, nums: List[int]) -> List[int]:
        ans=[]
        for n in nums:
            if nums[abs(n)-1] > 0 :
                nums[abs(n)-1] *= -1
            else:
                ans.append(abs(n))
                ans.sort()
        return ans

题目7：448（和上道题也是同类型）

# 原地哈希排序
class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        # 原地哈希
        # 计算数组长度，有多少个数
        n  = len(nums)
        for i in range(n):
            while 1<=nums[i]<=n and nums[i] != nums[nums[i]-1]:
                self.__swap(nums,i,nums[i]-1)

        ans=[]
        for i in range(n):
            if i+1 !=nums[i]:
                ans.append(i+1)
        return ans
        
    def __swap(self,nums,index1,index2):
        nums[index1],nums[index2]=nums[index2],nums[index1]

# -1法求解
class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        # -1求解
        for i in nums:
            if nums[abs(i)-1]>0:
                nums[abs(i)-1] *= -1
        
        ans=[]
        for i in range(len(nums)):
            if nums[i]>0:
                ans.append(i+1)
        return ans