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

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

有三种思路：

1. 暴力求解，从上到下每一行，从左到右每一列，依次比较，时间复杂度O(n2)

2. 对方法1进行优化，每行都是已排序的，则可以针对每一行都使用二分查找法，时间复杂度O(nlogn)

3. 利用题目给的规律，右上角array[i][j]的元素为该行最大，该列最小，

    如果target大于该元素，则target不可能在本行，只可能在下一行，即i++

    如果target小于该元素，则target不可能在本列，只可能在左一列，即j--

    如果target等于该元素，则返回true

    同理，从左下角开始也行。

代码如下：

class Solution {
public:
    // 暴力求解 逐行搜索
    bool find_one_by_one(int target, vector<vector<int> >& array){
        for(int i = 0; i < array.size(); ++i){
            for(int j = 0; j < array[0].size(); ++j){
                if(target == array[i][j]){
                    return true;
                }
            }
        }
        return false;
    }
    // 每行都是递增 针对每一行 使用二分查找
    bool find_binary(int target, vector<vector<int> >& array){
        for(int i = 0; i < array.size(); i++){
            int l = 0;
            int r = array[i].size()-1;
            while(l <= r){
                int mid = (l + r)/2;
                if(target == array[i][mid]){
                    return true;
                }
                else if(target < array[i][mid]){
                    r = mid - 1;
                }
                else{
                    l = mid + 1;
                }
            }
        }
        return false;
    }
    /*
        从右上角 或左下角， 下面以右上角开始为例：
        如果target大于当前值，array[i][j] 是当前行的最大值，则target可能在下一行 即j++
        如果target小于当前值，array[i][j] 是当前列的最小值，则target可能在左一列 即i--
        相等则返回true
    */ 
    bool find_from_right_top(int target, vector<vector<int> >& array){
        int rows = array.size();
        if(0 == rows){
            return false;
        }
        int cols = array[0].size();
        int i = 0;
        int j = cols - 1;
        while(i < rows && j >= 0){
            if(target == array[i][j]){
                return true;
            }
            else if(target < array[i][j]){
                j--;
            }
            else{
                i++;
            }
        }
        return false;
    }
    
    bool Find(int target, vector<vector<int> > array) {
        //return find_one_by_one(target, array);
        //return find_binary(target, array);
        return find_from_right_top(target, array);
    }
};