二维数组中的查找

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

解题方法1：

    从数组的右上角或者左下角开始找，然后每次的比较可以删除一行或者一列，这样的效率是最高的。

解题方法2：

   因为是二维数组，所以可以把每行看成一个元素进行二分查找，而每次的查找只需要遍历当前的中间行就可以了，这样的效率没有上一种解法的效率高

 下面给出方法1的代码：我是从右上角开始找的

        bool Find(int target, vector<vector<int> > array)
    {
        int row = array.size();//数组的行树
        int col = array[0].size()-1;//数组的列数-1方便下面计算
        int i = 0;
        while (i < row&&col >= 0)//行数从0开始递增，列数从最大开始递减
        {
            if (target==array[i][col])//如果找到的话，返回true
            {
                return true;
            }
            else if (target < array[i][col])//如果小于右上角的元素的话，删去最右边的列（并不是正真的删除）
            {
                --col;
            }
            else//如果大于右上角元素的话删除最上面的行（并不是真正的删除）
            {
                ++i;
            }
        }
        return false;
    }

方法2的代码如下

        bool Find(int target, vector<vector<int> > array)
    {
        int row = array.size();//数组的行树
        int col = array[0].size();//数组的列数
        int left = 0;
        int right = row;
        while (left <right)
        {
            //midlle=(right+left)/2;
            int middle = (right - left) / 2 + left;//这样写可以避免溢出
            for (int i = 0; i < col; i++)//遍历中间的行
            {
                if (array[middle][i] == target)
                    return true;
            }
            if (array[middle][0]>target)//和中间行的元素做比较
            {
                 right= middle-1;
            }
            else
            {
                left = middle + 1;
            }
        }
        return false;
    }

下面给出完整的代码和测试结果：

#include<iostream>
#include<vector>
using namespace std;
class Solution
{
public:
    bool FindFast(int target, vector<vector<int> > array)//效率高
    {
        int row = array.size();//数组的行树
        int col = array[0].size() - 1;//数组的列数-1方便下面计算
        int i = 0;
        while (i < row&&col >= 0)//行数从0开始递增，列数从最大开始递减
        {
            if (target == array[i][col])//如果找到的话，返回true
            {
                return true;
            }
            else if (target < array[i][col])//如果小于右上角的元素的话，删去最右边的列（并不是正真的删除）
            {
                --col;
            }
            else//如果大于右上角元素的话删除最上面的行（并不是真正的删除）
            {
                ++i;
            }
        }
        return false;
    }
    bool FindSlow(int target, vector<vector<int> > array)//效率低
    {
        int row = array.size();//数组的行树
        int col = array[0].size();//数组的列数
        int left = 0;
        int right = row;
        while (left <right)
        {
            //midlle=(right+left)/2;
            int middle = (right - left) / 2 + left;//这样写可以避免溢出
            for (int i = 0; i < col; i++)//遍历中间的行
            {
                if (array[middle][i] == target)
                    return true;
            }
            if (array[middle][0]>target)//和中间行的元素做比较
            {
                 right= middle-1;
            }
            else
            {
                left = middle + 1;
            }
        }
        return false;
    }
};
int main()
{
    vector<vector<int>> array;//初始化数组
    for (int i = 0; i < 4; i++)
    {
        vector<int> row;
        for (int j = i; j < i + 4; j++)
        {
            row.push_back(j);
        }
        array.push_back(row);
    }
    Solution s;
    cout <<"方法1查找6---->"<< s.FindFast(6, array)<<endl;
    cout <<"方法2查找6---->" << s.FindSlow(6, array) << endl;
    system("pause");
    return 0;
}

测试结果：