二维数组中的查找

第一次写的时候，是用暴力的解法，就是每个对于每行进行二分查找，差不多是nLogn，平均差不多是n/2logn。

第二次写的时候对整个数组进行二分查找，先找到整个数组的中间的数，判断target 和array[x_mid][y_mid]的关系；
==:return true；
>:以这个中间的数划分为四个区间，右下区间是绝对大于array[x_mid][y_mid],左上是绝对小的，其他两个可能大可能小。所以递归查找的时候先找右下（理论上来讲右下找到的概率比较大），然后是两个不确定的区间。
<:道理同上。
所以，这么宏观地看平均一次减少一般区间的查找。那么这个算法复杂度宏观来讲它的量级就是log（n平方）。
代码如下：

    public class Solution {
    public boolean Find(int target, int [][] array) {

           if(array.length == 0)return false;
           if(array[0].length == 0)return false;
           return Find(target,array,0,array.length-1,0,array[0].length-1);  
    }

    public boolean Find(int target,int[][] array,int x_start,int x_end,int y_start,int y_end)
    {
        if(x_start==x_end&&y_start==y_end){
            return (array[x_start][y_start]==target);
        }else if(x_start> x_end|| y_start> y_end) return false;
        boolean flag = false;
        int x_mid = (x_start+x_end)/2;
        int y_mid = (y_start+y_end)/2;
        if(target == array[x_mid][y_mid]){
            return true;
        }
        else if(target> array[x_mid][y_mid]){
            flag=Find(target,array,x_mid+1,x_end,y_start,y_end);
            if(!flag){
                flag = Find(target,array,x_mid+1,x_end,y_start,y_mid);
                if(!flag) flag = Find(target,array,x_start,x_mid,y_mid+1,y_end);
            }
            return flag;
        }
        else{
            flag = Find(target,array,x_start,x_mid-1,y_start,y_mid-1);
            if(!flag){
                flag = Find(target,array,x_mid,x_end,y_start,y_mid-1);
                if(!flag) flag = Find(target,array,x_start,x_mid-1,y_mid,y_end);
            }
            return flag;
        }

    }
}