leetcode|初级算法-数组

96
邓莎
0.1 2018.09.05 13:26 字数 1813

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]

03 总结

本文解锁了leetcode初级算法题库中数组板块的全部题目,并对每道题的解题思路和代码进行说明,供你参考,也便于我日后复习总结。

下期我们将继续解锁其他板块的题目,一起进步吧!

数据分析
Web note ad 1