leetcode 刷题记录，数组部分，代码随想录刷题顺序
看了好多攻略，打算第一遍刷题顺序跟着 代码随想录 ：数组、链表、哈希表、字符串、双指针法、栈与队列、二叉树、回溯算法 、贪心算法、动态规划、单调栈
题外话：小白一枚，打算刷题提高编程能力，由于现在在公司算法部门实习，所以使用python语言，打算明年秋招之前用java或者c++再刷一遍。下面纯记录个人刷题日记及代码。
两个月过去了……没刷几题，寒假回家躺平了，最近开始正式刷题了，看看能不能找到暑期实习吧，不打算学java了，还是老老实实冲算法吧！
代码随想录：代码随想录 (programmercarl.com)
DAY 1
704.二分查找
704. 二分查找 - 力扣（LeetCode）
class Solution1:
def search(self, nums, target):
left, right = 0, len(nums) - 1
while left <= right:
middle = (left + right) // 2
if nums[middle] < target:
left = middle + 1
elif nums[middle] > target:
right = middle - 1
else:
return middle
return -1
emp1 = Solution1()
emp1.search([-1,3,5,7,9,14,55,48],55)
#输出：635.搜索插入位置
class Solution3:
def search(self, nums, target):
left, right = 0, len(nums) - 1
while left <= right:
middle = (left + right) // 2
if nums[middle] < target:
left = middle + 1
elif nums[middle] > target:
right = middle - 1
else:
return middle
return right + 1
emp3 = Solution3()
emp3.search([-1,3,5,7,9],8)
#输出：434.在排序数组中查找元素的第一个和最后一个位置
class Solution4:
def search(self, nums, target):
def result(nums,target):
left, right = 0, len(nums) - 1
while left <= right:
middle = (left + right) // 2
if nums[middle] < target:
left = middle + 1
elif nums[middle] > target:
right = middle - 1
else:
return left
return -1
index = result(nums,target)
if index==-1:return [-1,-1]
left,right=index,index
while left -1 >=0 and nums[left - 1] == target: left -=1
while right+1 < len(nums) and nums[right + 1] == target:right +=1
print([left,right])
emp4 = Solution4()
nums=[-1,3,5,6,7,9,9,9,9,9]
target=9
emp4.search(nums,target)
#输出：[5,9]69.x 的平方根
方法一：
class Solution5:
def mySqrt(self, x: int) -> int:
l, r, ans = 0, x, -1
while l <= r: #不能漏掉l=r的情况
mid = (l + r) // 2
if mid * mid <= x:
ans = mid
l = mid + 1
else:
r = mid - 1
return ans
emp5 = Solution5()
emp5.mySqrt(9)
#输出：3方法二：
class Solution6:
def mySqrt(self, x):
if x == 0:
return 0
x0,C = float(x),float(x)
while True:
xi = 0.5 * (x0 + C/x0)
if abs(x0 - xi) < 1e-7:
break
x0 = xi
return int(x0)
emp6 = Solution6()
emp6.mySqrt(10)
#输出：3
DAY 2
27.移除元素
方法一：双指针法，快指针、慢指针
class Solution8:
def removeElement(self, nums,val):
fast = 0
slow = 0
for fast in range(len(nums)):
if nums[fast] == val:
continue
else:
nums[slow] = nums[fast]
slow +=1
return slow
emp8 = Solution8()
nums=[3,2,2,3]
val = 3
length=emp8.removeElement(nums,val)
for i in range(length):
print(nums[i])
#输出：2
# 2方法二：双指针法、左指针、右指针
class Solution9:
def removeElement(self, nums,val):
right = len(nums)-1
left = 0
while left <= right:
if nums[left] == val:
nums[left] = nums[right]
right -= 1
else:
left += 1
return nums[0:left]
emp9 = Solution9()
nums=[3,2,2,2,3,6,7,5,3]
val = 2
emp9.removeElement(nums,val)
#输出：[3, 3, 5, 7, 3, 6]26.删除有序数组中的重复项
class Solution10:
def removeDuplicates(self, nums):
fast = 1
slow = 0
for fast in range(len(nums)):
if nums[fast] == nums[slow]:
fast +=1
else:
slow +=1
nums[slow] = nums[fast]
return nums[0:slow]
emp10 = Solution10()
nums=[3,2,2,2,3,6,7,5,3]
emp10.removeDuplicates(nums)
#输出：[3, 2, 3, 6, 7, 5]283.移动零
class Solution11:
def moveZeroes(self, nums):
right = 0
left = 0
for right in range(len(nums)):
if nums[right]:
nums[left],nums[right] = nums[right],nums[left]
left += 1
right +=1
return nums
emp11 = Solution11()
nums=[3,0,2,0,3,6,0]
emp11.moveZeroes(nums)
#输出：[3, 2, 3, 6, 0, 0, 0]844.比较含退格的字符串
class Solution12:
def backspaceCompare(self,s,t):
def build(str):
ret = list()
for i in str:
if i != '#':
ret.append(i)
elif ret:
ret.pop() #保证ret里面有字符才能pop
return ret
return build(s) == build(t)
emp12 = Solution12()
s='a##c'
t='#a#c'
emp12.backspaceCompare(s,t)
#输出：True977.有序数组的平方
方法一：直接排序
class Solution13:
def sortedSquares(self, nums):
return sorted(num * num for num in nums)
emp13 = Solution13()
nums=(2,3,4,7,8,-1,-3)
emp13.sortedSquares(nums)
#输出：[1, 4, 9, 9, 16, 49, 64]方法二：双指针法，重点是有序数组，最大值是最右边或者最左边、左右指针
class Solution14:
def sortedSquares(self, nums):
n = len(nums)
result = [-1]*n
i,j,k = 0,n-1,n-1
while i <= j:
lm = nums[i]**2
rm = nums[j]**2
if lm > rm:
result[k] = lm
i +=1
else:
result[k] = rm
j -=1
k -=1
return result
emp14 = Solution14()
nums=(-3,-1,0,4,6,9)
emp14.sortedSquares(nums)
#输出：[0, 1, 9, 16, 36, 81]DAY 3
209.长度最小的子数组
滑动窗口、双指针法
class Solution15:
def minSubArrayLen(self, nums,target):
res = float("inf") #设为无穷大
sum = 0
i = 0
for j in range(len(nums)):
sum += nums[j]
while sum >= target:
res = min(res,j-i+1)
sum -= nums[i]
i += 1
if res == float("inf"):
return 0
else:
return res
emp15 = Solution15()
nums = (2,3,1,2,4,3)
target = 7
emp15.minSubArrayLen(nums,target )
#输出：2DAY 4
904.水果成篮
class Solution16:
def totalFruit(self, fruits: List[int]) -> int:
ans = i = 0
count = collections.Counter()
for j, x in enumerate(fruits):
count[x] += 1
while len(count) >= 3:
count[fruits[i]] -= 1
if count[fruits[i]] == 0:
del count[fruits[i]]
i += 1
ans = max(ans, j - i + 1)
return ans
emp16 = Solution16()
fruits = (2,3,1,2,2,1,3)
emp16.totalFruit(fruits)
#输出：4DAY 5/6
双休 没学
DAY 7
76. 最小覆盖子串
76. 最小覆盖子串
这个对我来说有点困难啊啊啊
首先是我不懂enumerate返回的是什么类型的数据，然后测试了下：
s = "ADOBECODEBANC"
print(list(enumerate(s)))
for j,c in enumerate(s):
print(j,c)输出是：
用了滑窗方法，借鉴了力扣里面大佬的题解思路，官方题解没有python版本
滑动窗口思想 - 最小覆盖子串 - 力扣（LeetCode）
class Solution17:
def minWindow(self, s: str, t: str) -> str:
need = collections.defaultdict(int)
for c in t:
need[c] += 1 #记录了遍历到的所有元素，而只有need[c]>0时，代表c就是所需元素
needCnt = len(t) #记录所需元素的总数量
i = 0 #记录起始位置
res = (0, float('inf')) #用两个元素，方便之后记录起终点
#三步骤：
#1. 增加右边界使滑窗包含t
for j,c in enumerate(s):
if need[c] >0:
needCnt -= 1
need[c] -= 1 #这行放在外面不可以，看19行 need[c] == 0
#2. 收缩左边界直到无法再去掉元素 !注意，处理的是i
if needCnt == 0:
while True:
c = s[i]
if need[c] == 0: #表示再去掉就不行了(need>0)
break
else: #need里面＜0的都是不需要的，将他们＋1，且去掉，滑窗右移
need[c] += 1
i += 1
#if j-i < res[1] - res[0]: #这里是否减一都可以，只要每次都是这样算的就行，反正最后也是输出子串而非长度
res = (i,j)
#3. i多增加一个位置，准备开始下一次循环(注意这步是在 needCnt == 0里面进行的 )
need[s[i]] += 1
needCnt += 1 #由于 移动前i这个位置 一定是所需的字母，因此NeedCnt才需要+1
i += 1
return s[res[0]: res[1]+1]
emp17 = Solution17()
s = "ADOBECODEBANC"
t = "ABC"
emp17.minWindow(s,t)
#输出：'BANC'
困难程度的题对我来说确实是困难，花了5个小时才勉强看懂算法思路，过段时间估计又忘了……
DAY 8
59. 螺旋矩阵 II
方法一：不需额外考虑中心数的情况，边界只考虑n是否达到n*n
class Solution19:
def generateMatrix(self, n: int) -> [[int]]:
l, r, t, b = 0, n - 1, 0, n - 1
mat = [[0 for _ in range(n)] for _ in range(n)]
num, tar = 1, n * n
while num <= tar:
for i in range(l, r + 1): # left to right
mat[t][i] = num
num += 1
t += 1
for i in range(t, b + 1): # top to bottom
mat[i][r] = num
num += 1
r -= 1
for i in range(r, l - 1, -1): # right to left
mat[b][i] = num
num += 1
b -= 1
for i in range(b, t - 1, -1): # bottom to top
mat[i][l] = num
num += 1
l += 1
return mat
emp19 = Solution19()
n = 3
emp19.generateMatrix(n)
#输出：[[1, 2, 3], [8, 9, 4], [7, 6, 5]]方法二：需要额外考虑中心数，边界用左右和上下共同约束，都是左闭右开区间
class Solution20:
def generateMatrix(self, n: int) -> [[int]]:
left,right,up,down = 0,n-1,0,n-1
number = 1
mat = [[0]*n for _ in range(n) ]
while left < right and up < down:
for i in range(left,right):
mat[up][i] = number
number += 1
for j in range(up,down):
mat[j][right] = number
number += 1
for i in range(right,left,-1):
mat[down][i] = number
number += 1
for j in range(down,up,-1):
mat[j][left] = number
number += 1
left += 1
right -= 1
up += 1
down -= 1
# 如果阶数为奇数，额外填充一次中心
if n % 2:
mat[n // 2][n // 2] = number
return mat
emp20 = Solution20()
n = 3
emp20.generateMatrix(n)
#输出：[[1, 2, 3], [8, 0, 4], [7, 6, 5]]两种方法用了不同的初始化0矩阵的方法
54.螺旋矩阵
逆向推还是推不出来，我太菜了
方法一：根据上题方法二改动的
还是没明白为啥while循环体内还要嵌套个if判断条件，整不明白
class Solution22:
def spiralOrder(self, matrix):
if not matrix or not matrix[0]:
return list()
ans = []
rows, columns = len(matrix), len(matrix[0])
left,right,up,down = 0,columns - 1,0,rows - 1
while left <= right and up <= down:
for i in range(left,right + 1):
ans.append(matrix[up][i])
for j in range(up + 1,down + 1):
ans.append(matrix[j][right])
if left < right and up < down: #就是这里不明白
for i in range(right - 1,left,-1):
ans.append(matrix[down][i])
for j in range(down,up,-1):
ans.append(matrix[j][left])
left += 1
right -= 1
up += 1
down -= 1
return ans
emp22 = Solution22()
matrix = [[1, 2, 3], [4,5,6], [7, 8,9]]
emp22.spiralOrder(matrix)
#输出：[1, 2, 3, 6, 9, 8, 7, 4, 5]
方法二：我是看不懂的，python这语法我都看不懂了，只知道这个方法好像很厉害的样子
class Solution21:
def spiralOrder(self, matrix):
ans = []
while matrix:
ans += matrix.pop(0) # 向右
if matrix and matrix[0]:
ans += [row.pop(-1) for row in matrix] # 向下
else: return ans
if matrix: ans += matrix.pop(-1)[::-1] # 向左
else: return ans
if matrix and matrix[0]: ans += [row.pop(0) for row in matrix][::-1] # 向上
else: return ans
return ans
emp21 = Solution21()
matrix = [[1, 2, 3], [4,5,6], [7, 8,9]]
emp21.spiralOrder(matrix)
#输出：[1, 2, 3, 6, 9, 8, 7, 4, 5]