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

题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
本题考查的知识点是：数组、查找

首先回顾下常用的查找算法：顺序查找和二分查找
顺序查找：逐个的查找，找到返回true或该元素下标，找不到则返回false或-1；
二分查找：前提是有序数组中查找，从中间元素开始，若找到则返回true或该元素下标，如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。

int BinarySerach(vector<int>&vec,int target)
{
	int n=vec.size();
	int mid;
	int low=0;
	int high=m-1;
	while(low<=high)
	{
		mid=low+(high-low)/2;
		if(vec[mid]==target)
		{
			return mid;
		}
		else if(vec[mid]>value)
		{
			high=mid-1;
		}
		else
		{
			low=mid+1;
		}
	}
	return -1;
}

接下来其入正题：
方法一：
我们可以直接用顺序查找的方法解决这道题：
时间复杂度为O（n^2）
空间复杂度O（1）

bool Find(int target, vector<vector<int> > array) {
	int m = array.size();
	int n = array[0].size();
	if (m == 0 || n == 0) return false;
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j < n; j++)
		{
			if (array[i][j] == target)
			{
				return true;
			}
		}
	}
	return false;
}

但是，我们没有利用题目中的一些重要信息：数组从左到右递增，从上到下递增。这个时候，二分法可以适用

方法二：
对每一列进行二分查找
时间复杂度：O(n*lgn)
空间复杂度：O(1)

int m = array.size();
	int n = array[0].size();
	if (m == 0 || n == 0) return false;
	for (int i = 0; i < m; i++)
	{
		for (int begin = 0, end = m - 1, j = m / 2; begin <= end;)
		{
			if (array[i][j] == target)
			{
				return true;
			}
			else if (array[i][j] > target)
			{
				end = j - 1;
			}
			else 
			{
				begin = j + 1;
			}
			j = begin + (end - begin) / 2;
		}
	}
	return false;
}

方法三：
矩阵是有序的：利用二维数组由上到下，由左到右递增的规律。
左下角元素m是行中最小的，是一列中最大的。

当m == target时，查到结果，直接返回；
当m > target时，因为m是一行中最小的，所以向上移动一行，继续查找；
当m < target时，因为m是一列中最大的，所以向右移动一列，继续查找

我们选取左下角为起始位置：
时间复杂度：O(m+n) ，其中m为行数，n为列数，最坏情况下，需要遍历m+n次。
空间复杂度：O(1)

 bool Find(int target, vector<vector<int> > array) {
        int m=array.size();
        int n=array[0].size();
        if(m==0||n==0) return false;
        int i=m-1;
        int j=0;
        while(i>=0&&j<n)
        {
            if(array[i][j]==target) 
            {
                return true;
                break;
            }
           else if (array[i][j] < target)
           {
               j++;
           }
            else
            {
                i--;
            }
        }
        return false;
    }

下面的方法是摘自牛客上“遗忘201901051244512”的题解
拓展：双折半查找

二维数组分为上下左右四个边界top，bottom，left，right：
对上边界top进行折半查找，假设终止点为E，则可以将二维数组位于终止点E右边的矩形Rr排除，因为终止点E小于其右边相邻的元素E+1，而E+1是右边矩形Rr的最小元素(左上元素)
同理，对下边界bottom折半，可以排除二维数组位于终止点E左边的矩形Rl排除，
对左边界left折半，可以排除二维数组位于终止点E下边的矩形Rb排除，
对右边界right折半，可以排除二维数组位于终止点E上边的矩形Rt排除，
一轮过去，边界范围缩小，对由新边界组成的矩形重复以上操作，直到范围缩小为只有一个元素。

十字分割法
我首先想到的是这种方法，不过要注意这种方法无论是从思维还是实现过程都比较麻烦，实战慎用。

1.分析：在主对角线方向上进行查找操作，直到一个元素大于目标，该终止点的左上区域与右下区域都可以排除，再递归剩下的左下、右上两个区域。
2.代码

// Solution 2: 运行时间：12ms 占用内存：1624k
bool Find_2(int target, vector<vector<int> > array) {
    if (array.empty())return false;
    if (array[0].empty())return false; //处理空数组

    //初始化栈
    typedef struct {
        int xmin=0,ymin=0,xmax,ymax;
    } stack_elem;
    stack_elem temp, newTemp;
    stack<stack_elem> s;
    temp.xmax = temp.ymax = array.size()-1;
    s.push(temp); 

    while (!s.empty()){
        newTemp = temp = s.top();
        s.pop();
        int x=temp.xmin, y=temp.ymin;


        while (true){
            // 首先确定区域是否可能包含目标值
            if (array[temp.xmin][temp.ymin]>target || array[temp.xmax][temp.ymax]<target) break; 
            if (temp.xmin>temp.xmax || temp.ymin>temp.ymax) break; 

            // 遍历过程节点分为几类
            if (array[x][y] == target) return true; // 情况1： 找到目标值
            if (array[x][y] > target){ //情况2：找到大于目标值的节点，缩小大区域为两个小区域
                newTemp.xmax = x-1;
                newTemp.ymin = y;
                if (newTemp.xmin<=newTemp.xmax && newTemp.ymin<=newTemp.ymax)
                    s.push(newTemp);
                temp.ymax = y-1;
                temp.xmin = x; 
                y = temp.ymin;
            }
            else if (x == temp.xmax){ //情况3：处理非正方形区域某一边界先溢出的情况
                temp.ymin = y+1;
                x = temp.xmin;
                ++y;
            }
            else if (y == temp.ymax){
                temp.xmin = x+1;
                y = temp.ymin;
                ++x;
            }
            else {++x,++y;} // 情况4：继续查找
        } 
    }
    return 0;
}

3.复杂度
时间复杂度：采用二分查找时为O(lgn)、采用顺序查找时为O(nlgn)
空间复杂度：O(1)