leetcode | 初级算法-数组

关注

原创最新推荐文章于 2026-03-17 12:30:34 发布 489 阅读 AI 写同款· GEO 优化 ›

LeetCode初级算法练习——数组篇数组篇26. 从排序数组中删除重复项给定一个有序数组，你需要原地删除其中的重复内容，使每个元素只出现一次,并返回新的长度。不要另外定义一个数组，您必须通过用 O(1) 额外内存原地修改输入的数组来做到这一点。示例：给定数组: nums = [1,1,2], 你的函数应该返回新长度 2, 并且原数组nums的前两个元素必须是1和2 不需要理会新的数组长度后面的元素Given a sorted ar... 阅读详情

01 起

最近“不务正业地”刷了一波leetcode上的算法题，初级算法已经刷完50%，战况如下，

刷题固然爽快，但及时总结才是进步之道，下面就数组部分的题目进行回顾和总结。

注意，刷题使用的语言是Python3，"数组"这个数据结构在Python中对应的就是"列表"list。

初级算法中数组类题目共11道，如下，我们一道一道来总结

02 解题

下面我们逐个击破数组部分的11道题。

2.1 从排序数组中删除重复项

题目：给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

思路：审题在于”排序数组“和”原地算法“，对于排序数组，可以用set()实现去重并返回原顺序，另外，可以直接遍历对比num[i]，num[i+1]，若相同则去掉nums[i+1]

class Solution:
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums)<2:
            return len(nums)
        i=0
        while i<len(nums)-1:
            if nums[i]==nums[i+1]:
                nums.remove(nums[i+1])
            else:
                i+=1
        return len(nums)

2.2 买卖股票的最佳时机 II

题目：给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）

思路：因为可以尽可能多地交易(买卖)，又不能同时参与多笔交易，因此为了获得最大利润，可以采取如下措施：只要前一天价格低于当天，就在前一天买入股票并在当天卖出，即，遍历每天的股价，若第i天股价低于第i+1天，则在第i天买入，第i+1天卖出

class Solution:
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        profit=0
        for i in range(len(prices)-1):
            if prices[i]<prices[i+1]:
                profit+=prices[i+1]-prices[i]
        return profit

2.3 旋转数组

题目：给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数

思路：k可能大于数组长度，于是先i=k%l，再将数组后i个元素平移到数组左边

class Solution:
    def rotate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: void Do not return anything, modify nums in-place instead.

        """
        # 算法一:未考虑k>len(nums)的情况，运行时长64ms
        """
        l=len(nums)
        nums[:]=nums[l-k:l]+nums[:l-k]
        
        """
        算法三：此算法最高效，考虑k>len(nums)的情况，通过取余数来化解，运行时长55ms
        """
        l=len(nums)
        i=k%l
        nums[:]=nums[-i:]+nums[:-i]

2.4 存在重复

题目：给定一个整数数组，判断是否存在重复元素。如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false

思路：非常简单，python的set()函数可以对列表去重，我们只需要对比set前后列表的长度是否相同即可

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

2.5 只出现一次的数字

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

思路：三种思路，一是笨办法，一一对比；二是异或操作，相同两数异或为0，某数异或0为其本身；三是灵活运用set()

class Solution:
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        
        """
        算法一：如果nums过长，时间复杂度较高，不过此算法可以找出多个“只出现一次的元素”
        """
        for i in range(len(nums)):
            if nums[i] not in nums[:i]+nums[i+1:]:
                result=nums[i]
        return result
        
        """
        算法二核心思想：异或，异或操作是在二进制上的异或操作，相同两数异或=0，数异或0=数本身。
        于是定义一个整数，初始化为0，并用该数依次与列表中元素进行异或操作，最后的结果肯定就是只出现过一次的那个数(异或次序并不影响最终结果，因此不论列表元素如何排列，相同两数异或总是为0)
        此算法只对 只有一个“只出现一次的元素” 的数列适用
        """
        num=0
        for i in nums:
            num ^= i
        return num

        """
        算法三核心思想：set(list)将筛除重复元素
        此算法只对 只有一个“只出现一次的元素” 的数列适用
        """
        num=sum(list(set(nums)))*2-sum(nums)
        return num

2.6 两个数组的交集 II

题目：给定两个数组，编写一个函数来计算它们的交集

思路：两种方法，一是每比较一次，就删除数组中被比较的元素；二是直接利用Counter()计数，然后&运算

class Solution:
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        
        """
        思路一：每比较一次，就删除数组中被比较的元素
        实现方法：字典计数，比较后字典对应key的计数-1
        """
        result=[]
        count={}
        for num in nums1:
            count[num]=count.get(num,0)+1
        
        for num in nums2:
            if num in count.keys() and count[num]: #if 0等价于false
                result.append(num)
                count[num]-=1
        return result
        
        """
        思路二：直接利用Counter()计数，然后&运算(&运算返回a、b的counter结果中(key,value)对的交集)
        """
        from collections import Counter
        return (list((Counter(nums1)&Counter(nums2)).elements()))

2.7 加一

题目：给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位，数组中每个元素只存储一个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。

思路：将列表转为数字，再加一。列表转数字，两个方法，
方法一：string和int之间的转换，将列表中个数字加到空字符串，然后将最终的字符串转为数字再+1，再将此结果转为字符串，最后将字符串各元素append到列表中输出
方法二：遍历list各元素，按nums[i]10*(len(nums)-i+1)求和得到列表表示的数字
这里采用方法一

class Solution:
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        resStr="";res=0;resList=[]
        for i in digits:
            resStr+=str(i)
        res=str(int(resStr)+1)
        for i in res:
            resList.append(int(i))
        return resList

2.8 移动零

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

思路：两种方法。思路一：遍历nums各元素i，若i为0，将i放在最后一位，i之后的元素前移一位，此方法理解上比较直观，但时间复杂度较高；思路二：遍历nums各元素i，若i为0，直接删除该元素，并在末尾补0，这种方法简单直接高效。

class Solution:
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: void Do not return anything, modify nums in-place instead.
        """
        
        """
        思路一：遍历nums各元素i，若i为0，将i放在最后一位，i之后的元素前移一位
        560ms
        """
        n=len(nums)
        i=0;z=0
        while i<n-z:
            if nums[i]==0:
                z+=1
                for j in range(i,n-1):
                    nums[j]=nums[j+1]
                nums[n-1]=0
                if nums[i]!=0:
                    i+=1
            else:
                i+=1
        
        """
        思路二：遍历nums各元素i，若i为0，直接删除该元素，并在末尾补0
        76ms
        """
        z=0  #计数0的个数，防止连续0中后面的0被跳过
        for i in range(len(nums)):
            if nums[i-z]==0:
                del nums[i-z]
                nums.append(0)
                z+=1

2.9 两数之和

题目：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用

思路：两种方法。思路一：subNums存储i索引之后的list，校验target-nums[i]是否在subNums中，若存在则返回i和subNums中的索引值，此方法当数组很长时，耗时较长；思路二：是思路一的改进版，调用迭代器enumerate()进行迭代，加快运算速度；dict存储nums各元素和对应的索引值

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        
        """
        思路一：subNums存储i索引之后的list，对比
        缺点：当nums较长时，运算时间较长
        """
        subNums=[]
        result=[]
        for i in range(len(nums)):
            subNums=nums[i+1:] #计算量减半，每次只取nums[i]之后的元素，因为之前的元素已经计算过了
            if target-nums[i] in subNums:
                result.append(i)
                result.append(i+1+subNums.index(target-nums[i]))
        return result
        
        """
        思路二：enumerate()，调用迭代器进行迭代，加快运算速度；dict存储nums各元素和对应的索引值
        """
        dictNum={}
        for i, num in enumerate(nums):
            if target-num in dictNum.keys():
                return i,dictNum[target-num]
            dictNum[num]=i #dict存储nums各元素和对应的索引值

2.10 有效的数独

题目：判断一个 9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。数独空白格用 ‘.’ 表示。

数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。

思路：按题意，数独最大是9X9的，用三个列表存储各行、各列、各方块的元素情况，初始化为空，判断某数字是否存在于某行+某列+某方块中，若存在，返回False，否则将此元素新增到行列方块中
难点：第i行、第j列的元素在第几个方块中？>>3*(i//3)+j//3

class Solution:
    def isValidSudoku(self, board):
        """
        :type board: List[List[str]]
        :rtype: bool
        """
        rows=[[] for i in range(9)]
        cols=[[] for i in range(9)]
        boxs=[[] for i in range(9)] #用三个列表存储各行、各列、各方块的元素情况，初始化为空
        
        for i,row in enumerate(board): #enumerate迭代器，算法效率更高
            for j,num in enumerate(row): #注意区分row rows
                if num!="." and num in rows[i]+cols[j]+boxs[3*(i//3)+j//3]:
                    return False
                rows[i].append(num)
                cols[j].append(num)
                boxs[3*(i//3)+j//3].append(num)
        return True

2.11 旋转图像

题目：给定一个 n × n 的二维矩阵表示一个图像，将图像顺时针旋转 90 度。必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

思路：根据规律，将矩阵转置，然后反转每行实现

class Solution:
    def rotate(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: void Do not return anything, modify matrix in-place instead.
        """
        n=len(matrix)
        for i in range(n): #手动转置矩阵
            for j in range(i+1,n): #注意j的遍历范围
                tmp=matrix[i][j] #用一个变量来存储中间态，这个idea很普遍！
                matrix[i][j]=matrix[j][i]
                matrix[j][i]=tmp
        for i in range(n):
            matrix[i]=matrix[i][::-1]