两种思路
一种是：
把每一行看成有序递增的数组，
利用二分查找，
通过遍历每一行得到答案，
时间复杂度是nlogn
public class Solution {
    public boolean Find(int [][] array,int target) {
        
        for(int i=0;i<array.length;i++){
            int low=0;
            int high=array[i].length-1;
            while(low<=high){
                int mid=(low+high)/2;
                if(target>array[i][mid])
                    low=mid+1;
                else if(target<array[i][mid])
                    high=mid-1;
                else
                    return true;
            }
        }
        return false;

    }
}

另外一种思路是：
利用二维数组由上到下，由左到右递增的规律，
那么选取右上角或者左下角的元素a[row][col]与target进行比较，
当target小于元素a[row][col]时，那么target必定在元素a所在行的左边,
即col--；
当target大于元素a[row][col]时，那么target必定在元素a所在列的下边,
即row++；
public class Solution {
    public boolean Find(int [][] array,int target) {
        int row=0;
        int col=array[0].length-1;
        while(row<=array.length-1&&col>=0){
            if(target==array[row][col])
                return true;
            else if(target>array[row][col])
                row++;
            else
                col--;
        }
        return false;

    }
}

最高效最简洁的写法15行给你

分析题目：

本题规则特点：

思路：

    def Find( self, target, array):
    # write code here
        if len(array) == 0:
            return False
        High = len(array)
        Wigth = len(array[0])
        high = High -1
        wight = 0
        while high >= 0 and wight < Wigth:
            cur = array[high][wight]
            if target == cur:
                return True
            elif target > cur:
                wight = wight + 1
            else:
                high = high - 1
        return False

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        rows = len(array) - 1
        cols= len(array[0]) - 1
        i = rows
        j = 0
        while j<=cols and i>=0:
            if target<array[i][j]:
                i -= 1
            elif target>array[i][j]:
                j += 1
            else:
                return True
        return False

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        // array是二维数组，这里没做判空操作
        int rows = array.size();
        int cols = array[0].size();
        int i=rows-1,j=0;//左下角元素坐标
        while(i>=0 && j<cols){//使其不超出数组范围
            if(target<array[i][j])
                i--;//查找的元素较少，往上找
            else if(target>array[i][j])
                j++;//查找元素较大，往右找
            else
                return true;//找到 
        }
        return false;
    }
};

public class Solution {
    public boolean Find(int target, int [][] array) {
        int rows = array.length;
        int cols = array[0].length;
        int i=rows-1,j=0;
        while(i>=0 && j<cols){
            if(target<array[i][j])
                i--;
            else if(target>array[i][j])
                j++;
            else
                return true;
        }
        return false;
    }
}

public class Solution {
    public boolean Find(int target, int [][] array) {
		int m = array.length;
        int n = array[0].length;
        int i = m-1,j = 0;
        while(true) {
        	if(i == -1 || j == n)    //进行边界判断，原来是在两个elseif里判断的，但是空数组的话会有异常
        		return false;
        	if(target == array[i][j])
        		return true;
        	else if(target < array[i][j])    //这里用elseif，原来用的是if，移位后array[i][j]发生改变，下面的判断有可能为true造成结果错误。使用elseif也会减少比较次数
        		i--;
        	else if(target > array[i][j])
        		j++;
        }
    }
}

/*
	算法思想：首先选取数组中右上角的数字，如果该数字等于要查找的数字，则查找过程结束；如果该数字大于要查找的数字，剔除这个数字所在的列；
    如果该数字小于要查找的数字，剔除这个数字所在的行。这样每一步都可以缩小查找范围，直到找到要查找的数字，或者查找范围为空为止。*/
    public class Solution {
    public boolean Find(int target, int [][] array) {
		//boolean found = false;
        int i = 0,j = array[0].length - 1;
        while(i <= array.length - 1  && j >= 0){
            if(array[i][j] == target){
                return true;
                //break;
            }else if(array[i][j] > target){
                j--;
                continue;
            }
            else{
                i++;
                continue;
            }
        }
        return false;
    }
}

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        for (auto &i : array){
            int left = 0;
            int right = i.size() - 1;
            while (left <= right) {
                int mild = (left + right) / 2;
                if (i[mild] > target) {
                    right = mild - 1;
                } else if (i[mild] < target) {
                    left = mild + 1;
                } else {
                    return true;
                }
            }
        }
        return false;
    }
};

将二级指针看成一个一维的指针数组，存放的是指向一维数组的地址
每层使用二分查找
bool search(int* arr,int target,int arrayColLen)
{
    int left=0,right=arrayColLen-1;
    int mid=0;
      while(left<=right)
        {
            mid=left+(right-left>>1);
            if(arr[mid]>target)
            {
                right=mid-1;
            }
            else if(arr[mid]<target)
            {
                left=mid+1;
            }
            else
            {
                return true;
            }
        }
    return false;
}
bool Find(int target, int** array, int arrayRowLen, int* arrayColLen ) {
    // write code here
   while (arrayRowLen--)
    {
        if (search(*array, target, *arrayColLen))
        {
            return true;
        }
        array++;
    }
    return false;
}

public class Solution {
    public boolean Find(int target, int [][] array) {
        int m =  array.length,n = array[0].length;
        int bottom = m - 1,left = 0;
        while(left < n && bottom >= 0){
            if(target == array[bottom][left]) return true;
            else if(target > array[bottom][left]) left++;
            else bottom--;
        }
        return false;
    }
}

public class Solution {
    
    /**
     * 二维数组中的查找
     * 要求空间复杂度o(m + n)
     * 思路：
     * 如果从左上角或者右下角的元素开始遍历 那么它所在的行列其他元素都是比它大或者比它小的不好舍弃
     * 所以我们选择从左下角或者右上角开始
     * 例如：从左下角开始
     * 1. 如果元素大于目标元素,那么所在行都比目标元素大行上移 舍弃一行
     * 2. 如果元素小于目标元素,那么所在列都比目标元素小 列右移舍弃一列
     * 3. 这样做到了遍历了所有元素
     * @param target
     * @param array
     * @return
     */
    public boolean Find(int target, int [][] array) {
        // 行
        int i = array.length - 1;
        // 列 列数 array[0].length
        int j = 0;
        while (i >= 0 && j < array[0].length){
            if(target == array[i][j]) return true;
            // 当前元素大于目标元素 舍弃行
            else if(target < array[i][j]) i--;
            // 当前元素小于目标元素 舍弃列
            else if(target > array[i][j]) j++;
        }
        return false;
    }
}

public class Solution {
    
    // 二分法
    // 时间复杂度: O(m+n)
    // 空间复杂度: O(1)
    public boolean Find(int target, int[][] array) {
        if (array == null || array.length == 0) {
            return false;
        }

        // 从右上角元素val开始
        // 若target==val, 返回true
        // 若target>val, val下移一行
        // 若target<val, val左移一列
        int i = 0, j = array[0].length - 1, val;
        while (i < array.length && j >= 0) {
            val = array[i][j];
            System.out.println(val);
            if (target == val) {
                return true;
            } else if (target > val) {
                i++;
                // System.out.println("i = " + i + ", j = "  + j);
            } else {
                j--;
                // System.out.println("i = " + i + ", j = "  + j);
            }
        }

        // 循环走完还没找到, 返回false
        return false;
    }

    // 也可以从左下角元素val开始
    // 若target==val, 返回true
    // 若target>val, j++
    // 若target<val, i--

    // 注意: 千万不能从左上角或右下角元素开始!!
    // 对于左上角而言, 它下边和右边的元素都大于target, 是无法缩小target范围的
    // 对于右下角而言, 它上边和左边的元素都小于target, 是无法缩小target范围的
}

public class Solution {
    public boolean Find(int target, int [][] array) {
        //二维数组同样采用二分查找的思想
        int m=array.length;//行
        int n=array[0].length;//列
        int i=0;
        int j=n-1;
        while(i>=0 && i<m && j>=0 && j<n){
            int mid=array[i][j];
            if(target<mid){
                j--;
            }else if(target>mid){
                i++;
            }else{
                return true;
            }
        }
        return false;
    }
}

//标准库很实用
class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        
        bool bfind = false;
        for(int i=0; i<array.size(); i++)
        {
            if(count(array[i].begin(), array[i].end(), target))
            {
                bfind = true;
                break;
            }
        }
        return bfind;
    }
};