力扣-搜索二维矩阵

题目

74. 搜索二维矩阵

这道题和在一维数组中查找目标值很像,不过这里的数组变成了二维数组。

在解这道题之前先讲一下怎么在升序一维数组里面用二分查找法找不大于某个目标值(target)的最大索引。例如在数组nums = {1, 3, 5, 7, 9}里面要查找目标值 target = 6,应返回的索引为 2。

java 复制代码
// 查找 nums 中小于等于 target 的最大下标,例如当 nums = {1, 3, 5, 7}, target = 4 时,要返回的坐标为1
    public int findRow (int[] nums, int target){
        int left = 0, right = nums.length - 1;
        // maxIndex 用于保存最终要返回的索引值。
        int maxIndex =  -1;
        int mid = -1;
        while (left < right){
            mid = left + (right - left + 1) / 2;
            if (nums[mid] <= target){
                maxIndex = mid;
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }

        return maxIndex;
    }

思路

因为该二维数组中每行元素都为升序,每列元素也都为升序,因此可以通过两次二分查找来求解。第一次二分法找到对应的行的位置,第二次二分查找找到对应列的位置。

java 复制代码
public boolean searchMatrix(int[][] matrix, int target) {
        boolean flag = false;

        // 边界条件
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }

        int row = matrix.length, col = matrix[0].length;

        // 找行的位置
        int left = 0, right = row - 1;
        // 保存要找的元素在哪一行
        int maxRowIndex = -1;
        int mid = 0;
        while (left <= right) {
            mid = left + (right - left) / 2;
            // 找到
            if (matrix[mid][0] <= target){
                maxRowIndex = mid;
                left = mid + 1;
            }
            else {
                right = mid - 1;
            }
        }

        // 找列的位置
        if (maxRowIndex == -1) {
            return false;
        }
        else{
            int leftCol = 0, rightCol = col - 1;
            int midCol = 0;
            while (leftCol <= rightCol){
                midCol = leftCol + (rightCol - leftCol) / 2;
                if (matrix[maxRowIndex][midCol] == target) {
                    flag = true;
                    break;
                }
                else if (matrix[maxRowIndex][midCol] < target){
                    leftCol = midCol + 1;
                }
                else {
                    rightCol = midCol - 1;
                }
            }
        }

        // 找列的位置
        return flag;
    }

将代码封装一下。

java 复制代码
public boolean searchMatrix(int[][] matrix, int target) {
        boolean flag = false;

        // 边界条件
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return false;
        }

        int maxIndex = searchRow(matrix, target);
        if (maxIndex == -1) {
            return false;
        }
        return searchCol(matrix, target, maxIndex);

    }

  // 寻找对应行的位置
 public int searchRow (int[][] nums, int target){
      int rows = nums.length, cols = nums[0].length;

      int left = 0, right = rows - 1;
      int mid = -1;
      int maxIndex = -1;
      while (left <= right){
          mid = left + (right - left) / 2;
          if (nums[mid][0] <= target){
              maxIndex = mid;
              left = mid + 1;
          }
          else {
              right = mid - 1;
          }
      }

      return maxIndex;
 }

 // 在每一行中查找对应列的位置
 public boolean searchCol (int[][] nums, int target, int maxIndex){
      int left = 0, right = nums[0].length - 1;
      int mid = -1;
      while (left <= right){
          mid = left + (right - left) / 2;
          if (nums[maxIndex][mid] == target){
              return true;
          }
          else if (nums[maxIndex][mid] < target){
              left = mid + 1;
          }
          else {
              right = mid - 1;
          }
      }

      return false;
 }

时空复杂度

时间复杂度分析:

searchMatrix方法首先检查边界条件,这是一个常数时间的操作,所以时间复杂度为O(1)。

searchRow方法使用了二分查找来确定目标值可能存在的最大行索引。在最坏情况下,需要遍历所有的行来确定最大行索引,但由于使用了二分查找,所以每次比较都可以将搜索范围减半。因此,时间复杂度为O(log m),其中m是矩阵的行数。

searchCol方法也在一个特定的行中使用二分查找来搜索目标值。同样地,时间复杂度为O(log n),其中n是矩阵的列数。

因此,整个searchMatrix方法的时间复杂度是O(log m + log n),可以简化为O(log(mn)),其中mn是矩阵中的元素总数。

空间复杂度分析:

这段代码没有使用额外的数据结构来存储中间结果,除了几个变量(如left、right、mid、maxIndex等)来辅助二分查找过程。

这些变量都是局部变量,并且它们的数量不随输入规模的增长而增长。

因此,空间复杂度为O(1),即常数空间复杂度。

总结:

时间复杂度:O(log(mn)),其中mn是矩阵中的元素总数。

空间复杂度:O(1)。

相关推荐
Microsoft Word17 分钟前
c++基础语法
开发语言·c++·算法
天才在此30 分钟前
汽车加油行驶问题-动态规划算法(已在洛谷AC)
算法·动态规划
莫叫石榴姐1 小时前
数据科学与SQL:组距分组分析 | 区间分布问题
大数据·人工智能·sql·深度学习·算法·机器学习·数据挖掘
Guofu_Liao2 小时前
大语言模型---梯度的简单介绍;梯度的定义;梯度计算的方法
人工智能·语言模型·矩阵·llama
茶猫_2 小时前
力扣面试题 - 25 二进制数转字符串
c语言·算法·leetcode·职场和发展
肥猪猪爸4 小时前
使用卡尔曼滤波器估计pybullet中的机器人位置
数据结构·人工智能·python·算法·机器人·卡尔曼滤波·pybullet
readmancynn5 小时前
二分基本实现
数据结构·算法
萝卜兽编程5 小时前
优先级队列
c++·算法
盼海5 小时前
排序算法(四)--快速排序
数据结构·算法·排序算法
一直学习永不止步5 小时前
LeetCode题练习与总结:最长回文串--409
java·数据结构·算法·leetcode·字符串·贪心·哈希表