【每日一题】力扣 剑指 Offer 04. 二维数组中的查找

---

题目

题目链接：剑指 Offer 04. 二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 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。

限制：

• 0 <= n <= 1000
• 0 <= m <= 1000

解题思路

这题我只想到了两种思路，不过都不是最优的

👉暴力

看了一下范围，额。。。先暴力出来吧。

两重循环暴力找出目标数即可，这没什么说的

👉二分

因为这题的标签有二分嘛，所以就往二分的方向想，但我只能想到二分查找，而且还是一维的。

这种思路就是遍历每层数组，把数组传入二分查找，如果最终没有查找到返回 false

这里贴出y总的模板

bool check(int x) {/* ... */} // 检查x是否满足某种性质

// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;    // check()判断mid是否满足性质
        else l = mid + 1;
    }
    return l;
}
// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (check(mid)) l = mid;
        else r = mid - 1;
    }
    return l;
}

👉线性查找

还有一种最优解，在这个二维数组右上方开始查找，和二分的思路相似。

• 如果当前的值比目标数小，那么就需要向左移动
• 如果当前的值比目标数大，那么就需要向下移动
• 如果相等，可以直接返回 true

这种思路我觉得非常妙，因为从右上方开始的位置，左边的数一定比自己小，下面的数一定比自己大，可以用这个方法判断目标数的位置。

代码（C++）

暴力

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        /*暴力*/
        for (int i = 0; i < matrix.size(); i ++ ) {
            for (int j = 0; j < matrix[i].size(); j ++ ) {
                if (matrix[i][j] == target)
                    return true;
            }
        }
        return false;
    }
};

二分

class Solution {
public:
    bool bsort(vector<int> matrix, int target) {
        int l = 0, r = matrix.size() - 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (matrix[mid] == target)
                return true;
            else if (matrix[mid] < target)
                l = mid + 1;
            else if (matrix[mid] > target)
                r = mid - 1;
        }
        return false;
    }

    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        /*二分*/
        for (int i = 0; i < matrix.size(); i ++ ) {
            bool f = bsort(matrix[i], target);
            if (f)
                return true;
        }
        return false;
    }
};

线性查找

class Solution {
public:
    bool bsort(vector<vector<int>> matrix, int target) {
        int i = 0, j = matrix[0].size() - 1;
        while (i < matrix.size() && j >= 0) {
            if (matrix[i][j] == target)
                return true;
            else if (matrix[i][j] < target)
                i ++;
            else
                j --;
        }
        return false;
    }

    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if (matrix.size() == 0)
            return false;
        return bsort(matrix, target);
    }
};

总结

这题用暴力真的没什么意义，可以用方法二练习二分的模板，方法三确实是一个很好的思路。

通过方法三可以有一些拓展，以后遇到二维排序数组的查找可以用这种思路解决，时间复杂度只有O(n)。