LeetCode 查找 Search a 2D Matrix

最新推荐文章于 2025-05-19 23:44:29 发布

原创最新推荐文章于 2025-05-19 23:44:29 发布 · 424 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

234 篇文章

订阅专栏

本文介绍了一种在二维矩阵中查找特定元素的方法，提供了三种不同的搜索策略，包括行优先搜索、二分搜索以及逐步逼近法，并给出了C++和Java的实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

思想：

方法一：先确定该元素可能在的行，再在该行找该元素。

时间复杂度O(max(m,n))。

class Solution {
public:
    bool searchMatrix(vector<vector<int> > &matrix, int target) {
        int m = matrix.size();
        int n = matrix[0].size();
        int i,row = 1;
        if(target < matrix[0][0])
            return false;
        for(i=1;i<m;i++) {
            if(target < matrix[i][0]) {
                row = i;
                break;
            }
            if(target == matrix[i][0]) {
                row = i+1;
                break;
            }
        }
        if(i == m) row = m;
        for(i=0;i<n;i++) {
            if(matrix[row-1][i] == target) return true;
        }
        return false;
    }
};

方法二：对上面查找优化，使用二分法。

时间复杂度O(max(lgm,lgn))。

c++:

class Solution {
public:
    bool searchMatrix(vector<vector<int> > &matrix, int target) {
        int m = matrix.size();
        int n= matrix[0].size();
        if(target < matrix[0][0])
            return false;
        //binary_search row
        int left,right,row,middle;
        left = 0, right = m - 1;
        while(left <= right) {
            middle = (left+right)/2;
            if(target == matrix[middle][0]) {
                return true;
            }else if(target > matrix[middle][0]) {
                left = middle + 1;
            }else if(target < matrix[middle][0]) {
                right = middle - 1;
            }
        }
        //binary_search col
        row = target >= matrix[middle][0] ? middle : middle - 1;
        left = 0, right = n - 1;
        while(left <= right) {
            int middle = (left+right)/2;
            if(target == matrix[row][middle]) {
                return true;
            }else if(target > matrix[row][middle]) {
                left = middle + 1;
            }else if(target < matrix[row][middle]) {
                right = middle - 1;
            }
        }
        return false;
    }
};

java:

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if(target < matrix[0][0]) return false;
        int mid = 0;
        
        // binary search row
        int rowLeft = 0;
        int rowRight = matrix.length - 1;
        int row;
        while(rowLeft <= rowRight) {
            mid = (rowLeft + rowRight) / 2;
            if(matrix[mid][0] == target) return true;
            else if(matrix[mid][0] < target) {
                rowLeft = mid + 1;
            }else {
                rowRight = mid - 1;
            }
        }
        row = target >= matrix[mid][0] ? mid : mid - 1;
        
        // binary search col
        int colLeft = 0;
        int colRight = matrix[0].length - 1;
        int col;
        while(colLeft <= colRight) {
            mid = (colLeft + colRight) / 2;
            if(matrix[row][mid] == target) return true;
            else if(matrix[row][mid] > target) {
                colRight = mid - 1;
            }else {
                colLeft = mid + 1;
            }
        }
        return false;        
    }
}

方法三：利用已经偏序的特性，直接定位在右上角，步步判断。代码非常简洁，但最坏的时间复杂度O(m+n)，比上面的都高。

c++:

class Solution {
public:
    bool searchMatrix(vector<vector<int> > &matrix, int target) {
        int i=0, j=matrix[0].size() - 1;
        while(i < matrix.size() && j >= 0) {
            if(target == matrix[i][j]) return true;
            else if (target < matrix[i][j]) j--;
            else i++;
        }
        return false;
    }
};

java:

public class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int m = matrix.length - 1;
        int n = matrix[0].length - 1;
        
        int i = 0, j = n;
        while(i <= m && j >= 0) {
            if(matrix[i][j] == target) {
                return true;
            }else if(matrix[i][j] > target) {
                --j;
            }else {
                ++i;
            }
        }
        
        return false;
    }
}