1. 把数组中的0移到末尾
给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作,不能拷贝额外的数组。
尽量减少操作次数。
将非0元素按读取顺序放在数组的前面,剩下的位置全放0。
class Solution:
def moveZeroes(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
index = 0
for num in nums:
if num != 0:
nums[index] = num
index += 1
while index < len(nums):
nums[index] = 0
index += 1
2. 改变矩阵维度
给出一个由二维数组表示的矩阵,以及两个正整数r
和c
,分别表示想要的重构的矩阵的行数和列数。
重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。
如果具有给定参数的reshape
操作是可行且合理的,则输出新的重塑矩阵;否则,输出原始矩阵。
输入:
nums =
[[1,2],
[3,4]]
r = 1, c = 4
输出: [[1,2,3,4]]
解释:行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。
class Solution:
def matrixReshape(self, nums: List[List[int]], r: int, c: int) -> List[List[int]]:
m, n = len(nums), len(nums[0])
if m * n != r * c:
return nums
reshape_nums = [[0 for _ in range(c)] for _ in range(r)]
index = 0
for i in range(r):
for j in range(c):
reshape_nums[i][j] = nums[index // n][index % n]
index += 1
return reshape_nums
3. 找出数组中最长的连续 1
给定一个二进制数组, 计算其中最大连续1的个数。
示例 1:
输入: [1,1,0,1,1,1]
输出: 3
解释: 开头的两位和最后的三位都是连续1,所以最大连续1的个数是 3.
class Solution:
def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
max_ = 0
cur = 0
for num in nums:
cur = 0 if num == 0 else cur + 1
max_ = max(max_, cur)
return max_
4. 有序矩阵查找
编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性:
每行的元素从左到右升序排列。
每列的元素从上到下升序排列。
现有矩阵 matrix 如下:
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5,返回 true。
给定 target = 20,返回 false。
从右上角开始:
class Solution:
def searchMatrix(self, matrix, target):
"""
:type matrix: List[List[int]]
:type target: int
:rtype: bool
"""
if not matrix or len(matrix) == 0 or len(matrix[0]) == 0:
return False
m = len(matrix)
n = len(matrix[0])
row = 0
col = n - 1
while row < m and col >= 0:
if target == matrix[row][col]:
return True
elif target < matrix[row][col]:
col -= 1
else:
row += 1
return False
5. 有序矩阵的 Kth Element
给定一个 n x n 矩阵,其中每行和每列元素均按升序排序,找到矩阵中第 k 小的元素。
请注意,它是排序后的第 k 小元素,而不是第 k 个不同的元素。
matrix = [
[ 1, 5, 9],
[10, 11, 13],
[12, 13, 15]
],
k = 8,
返回 13。
二分查找:利用数组中的最小值和最大值作为边界点,计算其中值,循环得到数组中小于中值得个数
class Solution:
def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
m, n = len(matrix), len(matrix[0])
lo, hi = matrix[0][0], matrix[m - 1][n - 1]
while lo <= hi:
mid = lo + (hi - lo) // 2
cnt = 0
for i in range(m):
for j in range(n):
if matrix[i][j] <= mid:
cnt += 1
if cnt < k:
lo = mid + 1
else:
hi = mid - 1
return lo
6. 一个数组元素在 [1, n] 之间,其中一个数被替换为另一个数,找出重复的数和丢失的数
集合 S 包含从1到 n 的整数。不幸的是,因为数据错误,导致集合里面某一个元素复制了成了集合里面的另外一个元素的值,导致集合丢失了一个整数并且有一个元素重复。
给定一个数组 nums 代表了集合 S 发生错误后的结果。你的任务是首先寻找到重复出现的整数,再找到丢失的整数,将它们以数组的形式返回。
输入: nums = [1,2,2,4]
输出: [2,3]
将 nums 中的元素 - 1 找到此元素对应的下标,并将此下标上的元素变为负数,依次循环数组,直到数组中某一元素对应的下标为负数,说明此数为重复的数。
数组中为正整数的数对应的下标 + 1 即为缺失的数。
class Solution:
def findErrorNums(self, nums):
n = len(nums)
dup = -1
for i in range(n):
index = abs(nums[i]) - 1
if nums[index] < 0:
dup = abs(nums[i])
else:
nums[index] *= -1
missing = -1
for i in range(n):
if nums[i] > 0:
missing = i + 1
return [dup, missing]
最直接的方法是先对数组进行排序,这种方法时间复杂度为 O(NlogN)。本题可以以 O(N) 的时间复杂度、O(1) 空间复杂度来求解。
主要思想是通过交换数组元素,使得数组上的元素在正确的位置上。
class Solution:
def findErrorNums(self, nums):
def swap(nums, i, j):
temp = nums[i]
nums[i] = nums[j]
nums[j] = temp
# 相当于给数组排序
for i in range(len(nums)):
# 数组中的元素不为 位置+1,并且此元素位置的数组不为此元素,则交换
while nums[i] != i + 1 and nums[nums[i] - 1] != nums[i]:
swap(nums, i, nums[i] - 1)
for i in range(len(nums)):
if nums[i] != i + 1:
return [nums[i], i + 1]
return None
7. 找出数组中重复的数,数组值在 [1, n] 之间
给定一个包含 n + 1 个整数的数组 nums,其数字都在 1 到 n 之间(包括 1 和 n),可知至少存在一个重复的整数。假设只有一个重复的整数,找出这个重复的数。
s输入: [1,3,4,2,2]
输出: 2
要求不能修改数组,也不能使用额外的空间。
二分查找解法:
class Solution:
def findDuplicate(self, nums: List[int]) -> int:
l = 1
h = len(nums) - 1
while l <= h:
mid = l + (h - l) // 2
cnt = 0
for i in range(len(nums)):
if nums[i] <= mid:
cnt += 1
if cnt > mid:
h = mid - 1
else:
l = mid + 1
return l
双指针解法,类似于有环链表中找出环的入口:
class Solution:
def findDuplicate(self, nums: List[int]) -> int:
slow = nums[0]
fast = nums[nums[0]]
while slow != fast:
slow = nums[slow]
fast = nums[nums[fast]]
fast = 0
while slow != fast:
slow = nums[slow]
fast = nums[fast]
return slow