《剑指offer》刷题笔记 JZ1

二维数组查找

题目描述

在一个二维数组array中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例

[[1,2,8,9],
[2,4,9,12],
[4,7,10,13],
[6,8,11,15]]
给定 target = 7，返回 true。
给定 target = 3，返回 false。

0 <= array.length <= 500
0 <= array[0].length <= 500

思路1 暴力破解

最先想到的就是将整个数组遍历一遍。

class Solution {
public:
 bool Find(int target, vector<vector<int> > array) {
     // 判断数组是否为空
     if (array.size() ==0 || array[0].size() ==0) return false;
     for (const auto& vec : array) {
         for (const int val : vec) {
             if (val == target) 
                 return true;
         }
     }
     return false;
 }
};

auto为C++11新增关键字，用于类型推导

思路2

根据题目中标亮的地方可以知道，如果存在满足题意的数，我们可以先遍历第一行，找到第一个大于目标的数（设这个数位于第$m_1$列），得到目标数所在的列的范围（1~$m_1$-1）,同理可以得到目标数所在的行的范围。

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        /*第二次出错，没有考虑空指针*/
        /*第三次出错，判断是否为空错误
        if(array.size()==0)
            return false;*/
        int n = array.size();
        int m = array[0].size();
        //是否为空指针
        if(n==0||m==0)
            return false;
        /*第一次出错，对行列上界更新逻辑错误
        int n1 = 0;
        int m1 = 0;
        */
        int n1 = n;
        int m1 = m;
        //列最大
        for(int i=0;i<n;i++)
        {
            if(array[i][0]==target)
                return true;
            if(array[i][0]>target)
                m1=i;
        }
        //行最大
        for(int i=0;i<m;i++)
        {
            if(array[0][i]==target)
                return true;
            if(array[0][i]>target)
                n1=i;
        }
        if(n1==1&&m1==1)
            return false;
        for(int i=0;i<n1;i++)
        {
            for(int j=0;j<m1;j++)
            {
                if(array[i][j]==target)
                    return true;
            }
        }
        return false;
    }
};

检查发现漏掉了一种情况，上述解法只单独考虑了小于所有数并直接返回，没有将大于所有数直接返回作为特殊条件列出。

官方题解 二分查找

假设arr数组，val，tar如下图所示：
如果我们把二分值定在右上角或者左下角，就可以进行二分。这里以右上角为例，左下角可自行分析：

1）设初始值为右上角元素，arr[0][5] = val，目标tar = arr[3][1]
2）接下来进行二分操作：
3）如果val == target,直接返回
4）如果 tar > val, 说明target在更大的位置，val左边的元素显然都是 < val，间接 < tar，说明第 0 行都是无效的，所以val下移到arr[1][5]
5）如果 tar < val, 说明target在更小的位置，val下边的元素显然都是 > val，间接 > tar，说明第 5 列都是无效的，所以val左移到arr[0][4]
6）继续步骤2）

class Solution {
public:
 bool Find(int target, vector<vector<int> > array) {
     // 判断数组是否为空
     int m = array.size();
     if (m == 0) return false;
     int n = array[0].size();
     if (n == 0) return false;
     int r = 0, c = n-1; // 右上角元素
     while (r<m && c>=0) {
         if (target == array[r][c]) {
             return true;
         }
         else if (target > array[r][c]) {
             ++r;
         }
         else {
             --c;
         }
     }
     return false;
 }
};

相较于我自己的解法，这个解法只对“边缘”进行遍历，时间复杂度更低，为O(m+n) ，其中m为行数，n为列数，最坏情况下，需要遍历m+n次。