[Java恶补day24] 74. 搜索二维矩阵

给你一个满足下述两条属性的 m x n 整数矩阵：

每行中的整数从左到右按非严格递增顺序排列。

每行的第一个整数大于前一行的最后一个整数。

给你一个整数 target ，如果 target 在矩阵中，返回 true ；否则，返回 false 。

示例 1：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3

输出：true

示例 2：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13

输出：false

提示：

m == matrix.length

n == matrix[i].length

1 <= m, n <= 100
− 10 4 -10^4 −104 <= matrix[i][j], target <= 10 4 10^4 104

知识点：

数组、矩阵、二分查找、排除法

解1（非常暴力）：

核心思想：定义辅助数组存储所有元素（因为每一行的第一个元素大于上一行的最后一个元素，因此可以这么操作） ，然后对这个辅助数组进行二分查找。

时间复杂度： O ( m n ) O(mn) O(mn)。

空间复杂度： O ( m n ) O(mn) O(mn)。

java 复制代码

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        //获取行数、列数
        int m = matrix.length;
        int n = matrix[0].length;
        //定义辅助数组，存储所有元素
        int[] nums = new int[m * n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                nums[i * n + j] = matrix[i][j];
            }
        }

        //定义二分查找的指针
        int low = 0;
        int high = m * n - 1;
        //只要两个指针不重合，就继续循环
        while (low <= high) {
            //获取中位数
            int mid = (low + high) / 2;
            //判断是否存在
            if (nums[mid] == target) {
                return true;
            } else if (nums[mid] > target) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        //未找到
        return false;
    }
}

解2（排除法）：

核心思想：同 #240. 搜索二维矩阵Ⅱ。

时间复杂度： O ( m + n ) O(m+n) O(m+n)。

空间复杂度： O ( 1 ) O(1) O(1)。未使用辅助数组，仅使用int类型的辅助变量。

java 复制代码

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        //获取行数、列数
        int m = matrix.length;
        int n = matrix[0].length;
        //从右上角开始找
        int i = 0;
        int j = n - 1;
        //只要还有元素，就继续循环
        while (i < m && j >= 0) {
            //找到元素，返回
            if (matrix[i][j] == target) {
                return true;
            }
            //若当前元素＞target，则遍历前面一列
            else if (matrix[i][j] > target) {
                j--;
            }
            //否则，遍历下面一行
            else {
                i++;
            }
        }
        //此时表明不存在元素
        return false;
    }
}

解3（二分查找）：

核心思想：在形式上将矩阵所有元素放在一个数组中 （因为每一行的第一个元素大于上一行的最后一个元素，因此可以这么操作），在实际上通过matrix[i/n][i%n]获取mid在matrix中对应的元素，然后使用二分查找

时间复杂度： O ( l o g ( m n ) ) O(log (mn)) O(log(mn))。

空间复杂度： O ( 1 ) O(1) O(1)。未使用辅助数组。

java 复制代码

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        //获取行数、列数
        int m = matrix.length;
        int n = matrix[0].length;

        //定义二分查找的指针
        int low = 0;
        int high = m * n - 1;
        //只要两个指针不重合，就继续循环
        while (low <= high) {
            //获取中位数
            int mid = (low + high) / 2;
            //获取矩阵对应的mid元素
            int item = matrix[mid / n][mid % n];
            //判断是否存在
            if (item == target) {
                return true;
            } else if (item > target) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        //未找到
        return false;
    }
}

参考：

1、灵神题解