目录

1.轮转数组

2.除自身以外数组的乘积

3.矩阵置零

4.螺旋矩阵

5.旋转图像

---

1.轮转数组

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

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) 时间复杂度内完成此题。

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 x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地算法。

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 ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

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 度的效果。

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()) 来反转这一行