leetcode74. Search a 2D Matrix

74. Search a 2D Matrix

Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:

Integers in each row are sorted from left to right.
The first integer of each row is greater than the last integer of the previous row.
For example,

Consider the following matrix:

[
  [1,   3,  5,  7],
  [10, 11, 16, 20],
  [23, 30, 34, 50]
]
Given target = 3, return true.

解法一

两次二分查找，先查找target所在哪个一维数组中，然后在该一维数组中进行二分查找。

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        // 异常处理，如果二维数组长度＝0或为null或者为{{}},返回false
        if(matrix.length == 0 || matrix == null || matrix[matrix.length - 1].length == 0) {
            return false;
        }

        int index = 0;
        int start = 0;
        int end = matrix.length - 1;
        int mid;
        // 如果数组的最后一个数小于target，或者第一个数大于target，返回false
        if(matrix[end][matrix[0].length - 1] < target || matrix[start][0] > target) {
            return false;
        }
        while (start < end - 1) {
            mid = start + (end - start) / 2;
            if (matrix[mid][0] == target) {
                return true;
            } else if (matrix[mid][0] < target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        // 判断第一个大于target的位置，则target所在的位置为该位置前的一个数组中，
        if (matrix[start][0] == target) {
            return true;
        } else if (matrix[end][0] == target) {
            return true;
        } else if(matrix[start][0] > target) {
            index = start - 1;
        } else if(matrix[end][0] > target) {
            index = end - 1;
        // 如果最后一个数组的第一个值仍比target小，则target所在的位置为最后一个数组
        } else {
            index = end;
        }

        // 找到target所在的数组，对该数组进行二分查找
        start = 0;
        end = matrix[index].length - 1;
        while (start < end - 1) {
            mid = start + (end - start) / 2;
            if (matrix[index][mid] == target) {
                return true;
            }
            if (matrix[index][mid] < target) {
                start = mid;
            }
            if (matrix[index][mid] > target) {
                end = mid;
            }
        }
        if (matrix[index][start] == target) {
            return true;
        } else if (matrix[index][end] == target) {
            return true;
        } else {
            return false;
        }
    }
}

解法二

一次二分查找，通过number = matrix[mid / column][mid % column]对应每一个数值。

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        // 异常处理，如果二维数组长度＝0或为null返回false
        if(matrix.length == 0 || matrix == null) {
            return false;
        }
        // 如果{{}}，返回false
        if (matrix[0].length == 0 || matrix[0] == null) {
            return false;
        }

        int row = matrix.length;
        int column = matrix[0].length;
        int start = 0;
        int end = row * column - 1;
        int mid, number;
        // 如果数组的最后一个数小于target，或者第一个数大于target，返回false。提升性能
        if(matrix[row - 1][column - 1] < target || matrix[0][0] > target) {
            return false;
        }

        while (start + 1 < end) {
            mid = start + (end - start) / 2;
            number = matrix[mid / column][mid % column];
            if (number == target) {
                return true;
            } else if (number < target) {
                start = mid;
            } else {
                end = mid;
            }
        }

        if (matrix[start / column][start % column] == target) {
            return true;
        } else if (matrix[end / column][end % column] == target) {
            return true;
        }
        return false;
    }
}