Matrix on Hang Zhang

rotateImage

Thu, 28 Nov 2024 00:00:00 +0000

48. 旋转图像

分析

转置矩阵：
- 遍历上三角区域 (i, j) ，交换每对对称元素 matrix[i][j] 和 matrix[j][i]
水平翻转矩阵：
- 遍历每一行，交换每行左右两端对称的元素

时间复杂度

转置矩阵需要 O(n^2)
水平翻转需要 O(n^2)

总时间复杂度 O(n^2)

空间复杂度

在原地修改矩阵，空间复杂度为 O(1)

C++代码

class Solution
{
public:
    void rotate(vector<vector<int>>& matrix)
    {
        int n = matrix.size();

        // 1. 转置矩阵
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < i; ++j)
                std::swap(matrix[i][j], matrix[j][i]);

        // 2. 水平翻转矩阵
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n / 2; ++j)
                std::swap(matrix[i][j], matrix[i][n - 1 - j]);
    }
};

search2dMatrix

Thu, 28 Nov 2024 00:00:00 +0000

74. 搜索二维矩阵

分析

由于矩阵按行列有序，可以将整个二维矩阵视为一个长度为 n * m 的一维数组，并在这个一维数组上进行二分查找

矩阵映射为一维数组：
- 矩阵的第 i 行和第 j 列的元素 matrix[i][j]，在一维数组中对应的索引为 i * m + j
- 反之，一维数组的索引 k 对应矩阵中的元素为 matrix[k / m][k % m]
二分查找：
- 初始时，定义查找区间的左右端点为 l = 0 和 r = m * n - 1
- 每次取中点 mid，将其映射到二维矩阵元素 matrix[mid / m][mid % m] ，与 target 比较：
  - 若该值大于等于 target，收缩右边界 r = mid
  - 若该值小于 target，收缩左边界 l = mid + 1
- 循环结束时，检查索引 r 对应的矩阵元素是否等于 target

时间复杂度

每次二分查找都会将查找范围缩小为原来的一半，总体复杂度为 O(log(m * n))

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target)
    {
        int n = matrix.size(), m = matrix[0].size(); // 矩阵行数和列数
        int l = 0, r = n * m - 1; // 二分区间 [l, r]
        while (l < r)
        {
            int mid = (l + r) >> 1; // 中点
            if (target <= matrix[mid / m][mid % m])
                r = mid; // 收缩右边界
            else
                l = mid + 1; // 收缩左边界
        }
        // 判断最终位置是否是目标值
        return matrix[r / m][r % m] == target;
    }
};

search2dMatrixII

Thu, 28 Nov 2024 00:00:00 +0000

240. 搜索二维矩阵II

分析

利用矩阵的排序特性，可以从矩阵的右上角（或左下角）开始搜索：

选择右上角 (0, m - 1) 为起点：
- 如果当前位置的值等于目标值，返回 true
- 如果当前位置的值小于目标值，则向下移动一行（增加行索引）
- 如果当前位置的值大于目标值，则向左移动一列（减少列索引）
退出条件：
- 如果行索引越界 x > n 或列索引越界 y < 0，说明矩阵中没有目标值，返回 false

时间复杂度

每次移动都会排除当前行或列的一部分，最多移动 m + n 次，因此时间复杂度为 O(m + n)

空间复杂度

空间复杂度为 O(1)

C++代码

class Solution
{
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target)
    {
        int n = matrix.size(), m = matrix[0].size();
        if (n == 0 || m == 0) return false;

        int x = 0, y = m - 1; // 从右上角开始
        while (x < n && y >= 0)
        {
            if (matrix[x][y] == target)
                return true; // 找到目标值
            else if (matrix[x][y] < target)
                ++ x; // 目标值更大，向下移动
            else
                -- y; // 目标值更小，向左移动
        }
        return false; // 未找到目标值
    }
};

spiralMatrix

Thu, 28 Nov 2024 00:00:00 +0000

54. 螺旋矩阵

分析

初始化变量：
- 使用 count 记录已访问的元素个数，初始为 0
- 将已访问的元素标记为 INF，以避免重复访问
- 初始化起始位置为 (x, y) = (0, -1)
按顺时针方向遍历：
- 按照右、下、左、上的顺序依次遍历矩阵
- 检查下一步是否越界或访问到标记值，如果满足条件则改变方向
收集结果：
- 在每次遍历过程中，将当前值加入结果数组 res
返回结果：
- 当遍历的元素数量 count 等于矩阵元素总数时，返回结果

时间复杂度

需要遍历矩阵中的所有元素，总时间复杂度 O(n * m)

空间复杂度

在矩阵内原地标记访问过的元素，无需额外空间，空间复杂度为 O(1)

C++代码

class Solution
{
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix)
    {
        int n = matrix.size();    // 矩阵行数
        int m = matrix[0].size(); // 矩阵列数

        int count = 0; // 记录访问过的元素数量
        int INF = 0x3f3f3f3f; // 标记值，用于标记已访问的元素
        std::vector<int> res; // 存放结果的数组

        int x = 0, y = -1; // 起始位置在矩阵外部
        while (count < n * m)
        {
            // 向右遍历
            while (y + 1 < m && matrix[x][y + 1] != INF)
            {
                res.push_back(matrix[x][y + 1]); // 记录元素
                matrix[x][y + 1] = INF;         // 标记为已访问
                ++ y;                            // 移动列
                ++ count;                        // 更新已访问数量
            }

            // 向下遍历
            while (x + 1 < n && matrix[x + 1][y] != INF)
            {
                res.push_back(matrix[x + 1][y]);
                matrix[x + 1][y] = INF;
                ++ x;
                ++ count;
            }

            // 向左遍历
            while (y - 1 >= 0 && matrix[x][y - 1] != INF)
            {
                res.push_back(matrix[x][y - 1]);
                matrix[x][y - 1] = INF;
                -- y;
                ++ count;
            }

            // 向上遍历
            while (x - 1 >= 0 && matrix[x - 1][y] != INF)
            {
                res.push_back(matrix[x - 1][y]);
                matrix[x - 1][y] = INF;
                -- x;
                ++ count;
            }
        }
        return res;
    }
};

setMatrixZeroes

Wed, 27 Nov 2024 00:00:00 +0000

73. 矩阵置零

分析

标记行和列：
- 用第一行和第一列作为标记位置
- 如果矩阵中的元素 matrix[i][j] == 0，则将 matrix[i][0] 和 matrix[0][j] 置为 0 ，分别标记第 i 行和第 j 列需要被置 0
特殊处理首行和首列：
- 因为第一行和第一列被用作标记，置 0 的操作可能覆盖原始信息
- 使用两个额外变量 r 和 c 分别标记首行和首列是否需要置 0
置零操作：
- 根据第一列的标记，从第二行开始，将需要置 0 的行的所有元素置为 0
- 根据第一行的标记，从第二列开始，将需要置 0 的列的所有元素置为 0
处理首行和首列：
- 如果 r == 0，将第一行全部置 0
- 如果 c == 0，将第一列全部置 0

时间复杂度

时间复杂度：O(m * n)

空间复杂度

使用矩阵本身作为标记，无额外空间开销，空间复杂度为 O(1)

C++代码

class Solution
{
public:
    void setZeroes(vector<vector<int>>& matrix)
    {
        int n = matrix.size(), m = matrix[0].size();
        int r = 1, c = 1;

        // 标记需要置零的行和列
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < m; ++j)
                if (matrix[i][j] == 0)
                {
                    if (i == 0) r = 0;
                    if (j == 0) c = 0;
                    matrix[i][0] = 0;
                    matrix[0][j] = 0;
                }

        // 根据标记置零
        for (int i = 1; i < n; ++i)
            if (matrix[i][0] == 0)
                for (int j = 1; j < m; ++j)
                    matrix[i][j] = 0;

        for (int j = 1; j < m; ++j)
            if (matrix[0][j] == 0)
                for (int i = 1; i < n; ++i)
                    matrix[i][j] = 0;

        // 处理首行和首列
        if (r == 0)
            for (int j = 0; j < m; ++j)
                matrix[0][j] = 0;

        if (c == 0)
            for (int i = 0; i < n; ++i)
                matrix[i][0] = 0;
    }
};