leetcode 240. 搜索二维矩阵 II

题目描述：

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。

示例 1：

输入：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

示例 2：

输入：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 = 20
输出：false

提示：

m == matrix.length
n == matrix[i].length
1 <= n, m <= 300
-109 <= matrix[i][j] <= 109
每行的所有元素从左到右升序排列
每列的所有元素从上到下升序排列
-109 <= target <= 109

代码：

解法一：暴力O(n^2)

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int i, j;
        for(i = 0; i < matrix.length; i++){
            for(j = 0; j < matrix[i].length; j++){
                if(target == matrix[i][j]){
                    return true;
                }
            }
        }
        return false;
    }
}

解法二：对每行进行二分查找，O(mlogn)

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int i, j, result = -1;
        for(i = 0; i < matrix.length; i++){//遍历每一行
            // 对每一行的数组进行二分查找
            result = -1;
            result = binarySearch(matrix[i], target);
            if(result >= 0)return true;
        }
        return false;
    }

// 二分查找函数,非递归
    public int binarySearch(int[] arr, int target){
        int low = 0, high = arr.length-1, mid;
        while(low <= high){
            mid = (low + high) >> 1;
            if(arr[mid] < target)
                low = mid+1;
            else if(arr[mid] > target)
                high = mid - 1;
            else
                return mid;
        }
        return -1;
    }
}

解法三:比较查找 O(m+n)

从右上角开始往左下查找

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int i = 0, j = matrix[i].length - 1;
        while(i <= matrix.length-1 && j >= 0){//没有超过边界
            if(matrix[i][j] == target)
                return true;
            else if(matrix[i][j] > target)
                j--;//往左走
            else if(matrix[i][j] < target)
                i++;//往下走
        }
        return false;
    }
}

解法四：行二分查找+列二分查找O(logm+logn)=O(logmn)

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        int n = matrix.size(), m = matrix[0].size();
        // 二分查找第一列，查找target所在行  从右往左查找模板
        int l = 0, r = n-1;
        while(l < r){
            int mid = l + (r-l+1>>1);
            if(matrix[mid][0] <= target) l = mid;
            else r = mid - 1;
        }
        int t = l;
        // 二分查找，查找target所在行，查找结束时判断边界值是否等于target 从左往右查找模板
        l = 0, r = m-1;
        while(l < r){
            int mid = l + (r-l>>1);
            if(matrix[t][mid] < target) l = mid + 1;
            else r = mid;
        }
        return matrix[t][l] == target;
    }
};

解法五：将数组拼接成一维数组，进行二分查找O(log(nm))

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;
        while(l < r){
            int mid = l + (r-l>>1);
            int x = matrix[mid/m][mid%m];
            if(x < target) l = mid+1;
            else r = mid;
        }
        return matrix[l/m][l%m] == target;
    }
};