leetcode74. Search a 2D Matrix

最新推荐文章于 2024-09-16 06:54:08 发布

大大kc

最新推荐文章于 2024-09-16 06:54:08 发布

阅读量182

点赞数

分类专栏： leetcode 文章标签： leetcode 二分查找

本文链接：https://blog.csdn.net/rxt2012kc/article/details/61196055

版权

leetcode 专栏收录该内容

187 篇文章 0 订阅

订阅专栏

这篇博客讨论了如何高效地在一个m x n的矩阵中搜索值，其中矩阵的每一行从左到右递增，且每行的第一个数大于前一行的最后一个数。提出了两种解法，包括两次二分查找和一次二分查找策略。

摘要由CSDN通过智能技术生成

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;
    }
}