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初级算法题库中数组板块的全部题目，并对每道题的解题思路和代码进行说明，供你参考，也便于我日后复习总结。
下期我们将继续解锁其他板块的题目，一起进步吧！
