力扣-搜索二维矩阵

题目

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)。

相关推荐
pianmian19 分钟前
python数据结构基础(7)
数据结构·算法
好奇龙猫2 小时前
【学习AI-相关路程-mnist手写数字分类-win-硬件:windows-自我学习AI-实验步骤-全连接神经网络(BPnetwork)-操作流程(3) 】
人工智能·算法
sp_fyf_20243 小时前
计算机前沿技术-人工智能算法-大语言模型-最新研究进展-2024-11-01
人工智能·深度学习·神经网络·算法·机器学习·语言模型·数据挖掘
香菜大丸3 小时前
链表的归并排序
数据结构·算法·链表
jrrz08283 小时前
LeetCode 热题100(七)【链表】(1)
数据结构·c++·算法·leetcode·链表
oliveira-time3 小时前
golang学习2
算法
南宫生4 小时前
贪心算法习题其四【力扣】【算法学习day.21】
学习·算法·leetcode·链表·贪心算法
懒惰才能让科技进步5 小时前
从零学习大模型(十二)-----基于梯度的重要性剪枝(Gradient-based Pruning)
人工智能·深度学习·学习·算法·chatgpt·transformer·剪枝
Ni-Guvara5 小时前
函数对象笔记
c++·算法
泉崎6 小时前
11.7比赛总结
数据结构·算法