剑指offer-二维数组中的查找

问题

题目：[二维数组中的查找]

思路

蛮力法肯定可以做。
但是考虑有序的特性，所以，二分查找。
但是，我做的是否还是犯了错误。那证明这题出的很成功嘛!
因为我是认为这个数组是这样的：
1.0 2.0 3.0
1.1 2.1 3.1
1.2 2.2 3.2
即每一行或者每一列都完全小于下一行或者下一列。
题目的意思只说了，从左至右有序，从上到下有序。上面的情况属于特例。
比如：
1,2,3,………………100
2,3,4,………………101
3,4,5,………………102
这同样满足题目要求，但是98这个数可能出现在任意一行当中。
所以，只能枚举行，然后二分。也是O(N*logN)可以接受。

代码

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int row = array.size();
        if(!row) return false;
        int col = array[0].size();
        if(!col) return false;

        if(target < array[0][0] || target > array[row-1][col-1])
            return false;

        for(int i = 0; i < row; ++i){
            bool found = biSearch(array[i], 0, col-1, target);
            if(found) return true;
        }
        return false;
    }
private:
    bool biSearch( const std::vector<int>& arr, int low, int high, int key ){
        while(low <= high){
            int mid = (low+high)/2;
            if(arr[mid] == key ) return true;
            else if( key < arr[mid] ) high = mid - 1;
            else low = mid + 1;
        }
        return false;
    }
};

当然，后面参考了别人的方法[二维数组的查找]，下面的图片也来自于该博客。

思路在图中其实也很明显。只不过这个题没有想得那么简单，因为如果一个数比每一行最大的数小，它不是只可能在这一行。而是也可能在下一行，要把这个弯绕过来。

上面的解法逻辑是这样，考虑每个矩阵的右上角元素，

• 如果target小于该元素，那么一定在右上角元素的左侧矩阵中寻找。
• 如果target大于该元素，那么一定在右上角元素的下侧矩阵中寻找。
  -如果target等于该元素，则返回即可。

上面的思路其实来自于二分查找。

代码(递归实现)

减治法，递归实现。

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int rowNum = array.size();
        if(!rowNum) return false;
        int colNum = array[0].size();
        if(!colNum) return false;

        if( target < array[0][0] || target > array[rowNum-1][colNum-1]) return false;
        return find( array, 0, colNum-1, rowNum, target );

    }
private:
    bool find(vector<vector<int> >& array, int cur_row, int cur_col, int row, int target ){
        if( cur_row == row ) return false;
        else if( cur_col == -1 ) return false;
        else{
            int& top = array[cur_row][cur_col];
            if( target == top ) return true;
            else if (target < top ) return find( array, cur_row, cur_col-1, row, target );
            else return find( array, cur_row+1, cur_col, row, target );
        }
    }
};

代码(非递归实现)

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int rowNum = array.size();
        if(!rowNum) return false;
        int colNum = array[0].size();
        if(!colNum) return false;

        int i = 0;
        int j = colNum - 1;
        while( i < rowNum && j >= 0 ){
            if( target == array[i][j] ) return true;
            else if( target < array[i][j] ) --j;
            else ++i;
        }
        return false;
    }
};