LeetCode 74. 搜索二维矩阵

74. 搜索二维矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：

• 每行中的整数从左到右按升序排列。
• 每行的第一个整数大于前一行的最后一个整数。

示例 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
• -104 <= matrix[i][j], target <= 104

二、方法一

一次二分查找

class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length;
        if (n == 0) {
            return -1;
        }
        if (n == 1) {
            return nums[0] == target ? 0 : -1;
        }
        int l = 0;
        int r = n - 1;
        while (l <= r) {
            int mid = l + ((r - l) >> 1);
            if (nums[mid] == target) {
                return mid;
            }
            if (nums[0] <= nums[mid]) {
                if (nums[0] <= target && target < nums[mid]) {
                     r = mid - 1;
                } else {
                    l = mid + 1;
                }
            } else {
                if (nums[mid] < target && target <= nums[n - 1]) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
        }
        return -1;
    }
}

复杂度分析

• 时间复杂度：O(logmn)，其中 m 和 n 分别是矩阵的行数和列数。

• 空间复杂度：O(1)。

三、方法二

两次二分查找

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int row = binSearchCol(matrix, target);
        if (row < 0) {
            return false;
        }
        return binSearchRow(matrix[row], target);
    }

    public int binSearchCol(int[][] matrix, int target) {
        int l = 0;
        int r = matrix.length - 1;
        while (l < r) {
            int mid = l + ((r - l + 1) >> 1);
            if (matrix[mid][0] <= target) {
                l = mid;
            } else {
                r = mid - 1;
            }
        }
        return l;
    }

    public boolean binSearchRow(int[] matrix, int target) {
        int l = 0;
        int r= matrix.length - 1;
        while (l <= r) {
            int mid = l + ((r - l) >> 1);
            if (matrix[mid] == target) {
                return true;
            } else if (matrix[mid] < target) {
                l = mid + 1;
            } else {
                r = mid - 1;
            }
        }
        return false;
    }
}

复杂度分析

• 时间复杂度：O(logm+logn)=O(logmn)，其中 m 和 n 分别是矩阵的行数和列数。

• 空间复杂度：O(1)。