目录
1.轮转数组
给定一个整数数组 nums，将数组中的元素向右轮转 k个位置，其中 k是非负数。
cpp
class Solution {
public:
void rotate(vector<int>& nums, int k) {
int n = nums.size();
k %= n; // 优化 k，避免多余轮转
// 翻转整个数组
reverse(nums.begin(), nums.end());
// 翻转前 k 个元素
reverse(nums.begin(), nums.begin() + k);
// 翻转剩余的部分
reverse(nums.begin() + k, nums.end());
}
};取模优化： 如果 k 大于数组长度 n，则 k % n 的结果与直接轮转 k 次的效果相同，减少不必要的操作。
数组翻转法： 通过三次翻转完成数组的轮转：
这种方法的时间复杂度为 O(n)O(n)O(n)，空间复杂度为 O(1)O(1)O(1)。
首先将整个数组翻转。
然后将前 k 个元素翻转。最后将剩下的部分翻转。
2.除自身以外数组的乘积
给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。
题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。请 不要使用除法，且在 O(n) 时间复杂度内完成此题。
cpp
class Solution {
public:
vector<int> productExceptSelf(vector<int>& nums) {
int n = nums.size();
vector<int> answer(n, 1);
// 计算前缀积
int prefix = 1;
for (int i = 0; i < n; ++i) {
answer[i] = prefix; // 当前元素的前缀积
prefix *= nums[i]; // 更新前缀积
}
// 计算后缀积并更新答案
int suffix = 1;
for (int i = n - 1; i >= 0; --i) {
answer[i] *= suffix; // 乘以当前元素的后缀积
suffix *= nums[i]; // 更新后缀积
}
return answer;
}
};前缀积：
遍历数组，计算每个元素的左侧所有元素的乘积。
存储在 answer[i] 中。
后缀积：
反向遍历数组，计算每个元素右侧所有元素的乘积。
将后缀积与 answer[i] 相乘，得到结果。
优化空间：在同一个数组 answer 中存储前缀积和最终结果，避免额外空间分配。
3.矩阵置零
给定一个 m xn 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法**。**
cpp
class Solution {
public:
void setZeroes(vector<vector<int>>& matrix) {
int m = matrix.size();
int n = matrix[0].size();
// 标记第一行和第一列是否需要置零
bool firstRowZero = false, firstColZero = false;
// 检查第一列是否有零
for (int i = 0; i < m; ++i) {
if (matrix[i][0] == 0) {
firstColZero = true;
break;
}
}
// 检查第一行是否有零
for (int j = 0; j < n; ++j) {
if (matrix[0][j] == 0) {
firstRowZero = true;
break;
}
}
// 用第一行和第一列作为标记
for (int i = 1; i < m; ++i) {
for (int j = 1; j < n; ++j) {
if (matrix[i][j] == 0) {
matrix[i][0] = 0;
matrix[0][j] = 0;
}
}
}
// 根据标记置零
for (int i = 1; i < m; ++i) {
for (int j = 1; j < n; ++j) {
if (matrix[i][0] == 0 || matrix[0][j] == 0) {
matrix[i][j] = 0;
}
}
}
// 处理第一列
if (firstColZero) {
for (int i = 0; i < m; ++i) {
matrix[i][0] = 0;
}
}
// 处理第一行
if (firstRowZero) {
for (int j = 0; j < n; ++j) {
matrix[0][j] = 0;
}
}
}
};标记需要置零的行和列：
我们不能直接修改矩阵，因为这样会影响后续的判断。因此，我们可以利用矩阵的第一行和第一列作为标记，用来记录哪些行和列需要置零。
具体步骤：
遍历矩阵，找到为零的元素，将对应的行和列的第一个元素置为零（即标记）。
再次遍历矩阵，使用标记的信息将对应的行和列置为零。
需要额外的变量来记录第一行和第一列是否需要置零，因为这两个被用作标记列。
时间复杂度和空间复杂度：
时间复杂度：O(m * n)，需要遍历两次矩阵。空间复杂度：O(1)，只使用了常数额外空间。
4.螺旋矩阵
给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
cpp
class Solution {
public:
vector<int> spiralOrder(vector<vector<int>>& matrix) {
vector<int> result;
if (matrix.empty() || matrix[0].empty()) return result;
int m = matrix.size();
int n = matrix[0].size();
int top = 0, bottom = m - 1, left = 0, right = n - 1;
while (top <= bottom && left <= right) {
// 从左到右遍历 top 边界
for (int j = left; j <= right; ++j) {
result.push_back(matrix[top][j]);
}
++top;
// 从上到下遍历 right 边界
for (int i = top; i <= bottom; ++i) {
result.push_back(matrix[i][right]);
}
--right;
// 从右到左遍历 bottom 边界
if (top <= bottom) {
for (int j = right; j >= left; --j) {
result.push_back(matrix[bottom][j]);
}
--bottom;
}
// 从下到上遍历 left 边界
if (left <= right) {
for (int i = bottom; i >= top; --i) {
result.push_back(matrix[i][left]);
}
++left;
}
}
return result;
}
};定义四个边界：
top：矩阵的上边界（初始为0）。
bottom：矩阵的下边界（初始为m-1）。
left：矩阵的左边界（初始为0）。
right：矩阵的右边界（初始为n-1）。
按顺时针顺序遍历：
从左到右遍历 top 边界，然后将 top 增加1。
从上到下遍历 right 边界，然后将 right 减少1。
从右到左遍历 bottom 边界（如果未越界），然后将 bottom 减少1。
从下到上遍历 left 边界（如果未越界），然后将 left 增加1。
终止条件：当 top > bottom 或 left > right 时，遍历结束。
5.旋转图像
给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。
要在原地旋转一个二维矩阵 matrix 顺时针 90 度，你可以通过以下两步操作来实现：
转置矩阵：首先，将矩阵沿主对角线转置，即将矩阵的行和列交换。这样，矩阵的第 i 行、第 j 列的元素会变成第 j 行、第 i 列的元素。 反转每一行：然后，反转每一行。因为转置之后，每一行的元素顺序相当于原来列的顺序，反转每一行就实现了顺时针旋转 90 度的效果。
cpp
class Solution {
public:
void rotate(vector<vector<int>>& matrix) {
int n = matrix.size();
// 步骤 1: 转置矩阵
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
swap(matrix[i][j], matrix[j][i]);
}
}
// 步骤 2: 反转每一行
for (int i = 0; i < n; ++i) {
reverse(matrix[i].begin(), matrix[i].end());
}
}
};转置矩阵：
对于每一对 (i, j)，我们将 matrix[i][j] 与 matrix[j][i] 交换。注意，我们从 i 开始循环到 n，从 i+1 开始进行交换，以确保只交换矩阵的上三角部分（即不交换已经交换过的元素）。
反转每一行：对于每一行，使用 reverse(matrix[i].begin(), matrix[i].end()) 来反转这一行