LeetCode笔记——74搜索二维矩阵

题目：

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

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

示例 1:

输入:
matrix = [
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
target = 3
输出: true

示例 2:

输入:
matrix = [
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
target = 13
输出: false

代码一：网上大神的代码，包括代码一和代码二。原文链接：https://blog.csdn.net/DERRANTCM/article/details/47142931

思路：这个代码的思想是先利用二分法找到该数字可能在的行，然后利用二分查找到可能在的列。

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }
        int row = matrix.length;
        int column = matrix[0].length;
        int low = 0;
        int high = row - 1;
        int mid = 0;
        // 找结果所在的列
        while (low <= high) {
            mid = low + (high - low) / 2;
            if (target < matrix[mid][column - 1]) {
                high = mid - 1;
            } else if (target > matrix[mid][column - 1])  {
                low = mid + 1;
            }
            else
            { return true;
           }
        }
        // 决定列所在的最终位置
        int targetRow = mid;
        if (matrix[mid][column - 1] < target) {
            targetRow++;
        }
        // 目标列超出，无结果
        if (targetRow >= row) {
            return false;
        }
        low = 0;
        high = column - 1;
        // 找所在的行，找到返回true，没有返回false
        while (low <= high) {
            mid = low + (high - low) / 2;
            if (target < matrix[targetRow][mid]) {
                high = mid - 1;
            } else if (target > matrix[targetRow][mid]) {
                low = mid + 1;
            } else
            { return true;
            }
        }
        return false;
    }
}

---

代码二：

以下是另一种思路的程序：

思路：将要查找的数与矩阵右上角的数进行比较。如果该数大于要查找的数，就删除该数所在的那一列；如果该数小于要查找的数，就删除该数所在的那一行。

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
     
 
        // 输入条件判断
        if (matrix == null || matrix.length < 1 || matrix[0].length < 1) {
            return false;
        }
 
        int rows = matrix.length; // 数组的行数
        int cols = matrix[0].length; // 数组行的列数  这个很奇怪，原始代码是1，结果编译出错，改成0之后就通过了。。
 
        int row = 0; // 起始开始的行号
        int col = cols - 1; // 起始开始的列号
 
        // 要查找的位置确保在数组之内
        while (row >= 0 && row < rows && col >= 0 && col < cols) {
            if (matrix[row][col] == target) { // 如果找到了就直接退出
                return true;
            } else if (matrix[row][col] > target) { // 如果找到的数比要找的数大，说明要找的数在当前数的左边
                col--; // 列数减一，代表向左移动
            } else { // 如果找到的数比要找的数小，说明要找的数在当前数的下边
                row++; // 行数加一，代表向下移动
            }
        }
 
        return false;
    }
 
    }

执行最快的代码：

执行最快的代码看起来好像也是使用二分查找的思想

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if(null == matrix || matrix.length == 0 || matrix[0].length == 0){
            return false;
        }
        int lo = 0, hi = matrix.length - 1;
        while(lo <= hi){
            int mid = (lo+hi)/2;
            if(matrix[mid][0] == target){
                return true;
            }
            if(matrix[mid][0] > target){
                hi = mid - 1;
            }
            else{
                lo = mid + 1;
            }
        }
        if(lo > matrix.length || lo == 0){
            return false;
        }
        int row = lo - 1;
        lo = 0;
        hi = matrix[0].length - 1;
        while(lo <= hi){
            int mid = (lo+hi)/2;
            if(matrix[row][mid] == target){
                return true;
            }
            if(matrix[row][mid] < target){
                lo = mid + 1;
            }
            else{
                hi = mid - 1;
            }
        }
        return false;
    }
}