剑指Offer第1题详解（附Java、Python实现代码）

《剑指Offer》第 1 题详解

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

1. Python 实现

1.1 暴力实现

直接遍历一遍数组，即可判断目标target是否存在。

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        l1=len(array)
        for i in range(l1):
            for j in range(len(array[i])):
                if array[i][j]==target:
                    return True

或者是下面这样

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        l1=len(array)
        for i in range(l1):
            if target in array[i]:
                return True

复杂度分析
时间复杂度：O(n^2)，因为最坏情况下，数组中的元素都需要遍历一次。
空间复杂度：O(1)

1.2 二分查找（与一维的二分查找有区别）

数组从左到右递增，从上到下递增。
也就是说，这是一个有序的数组，二分是不二之选。
假设arr数组，val，tar如下图所示：
如果我们把二分值定在右上角或者左下角，就可以进行二分。

1.2.1 初始值在右上角

1）设初始值为右上角元素，arr[0][5] = val，目标tar = arr[3][1]
2）接下来进行二分操作：
3）如果val == target,直接返回
4）如果 tar > val, 说明target在更大的位置，val左边的元素显然都是 < val，间接 < tar，说明第 0 行都是无效的，所以val下移到arr[1][5]
5）如果 tar < val, 说明target在更小的位置，val下边的元素显然都是 > val，间接 > tar，说明第 5 列都是无效的，所以val左移到arr[0][4]
6）继续步骤2）

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

复杂度分析
时间复杂度：O(m+n) ，其中m为行数，n为列数，最坏情况下，需要遍历m+n次。
空间复杂度：O(1)

1.2.2 初始值在右下角

---

1）设初始值为左下角元素，arr[4][0] = val，目标tar = arr[3][1]
2）接下来进行二分操作：
3）如果val == target,直接返回
4）如果 tar > val, 说明target在更大的位置，val右边的元素显然都是 > val，间接 > tar，说明要么在最后一行要么没有，所以val右移到arr[4][1]
5）如果 tar < val, 说明target在更小的位置，val上边的元素显然都是 < val，间接 < tar，说明最后一列都是无效的，所以val上移到arr[3][1]
6）继续步骤2）

def Find(target, array):
    # write code here
    l1 = len(array)
    l2 = len(array[0])
    if l1 == 0 | l2 == 0:
        return False
    i = l1-1
    r = 0
    while r < l2 and i >= 0:
        if target < array[i][r]:
            i-=1
        elif target > array[i][r]:
            r+=1
        else:
            return True
    return False
print(Find(8,[[1,2,8,9],[2,4,9,12],[4,7,10,13],[6,8,11,15]]))

2. Java 二分实现

2.1 初始值在右上角

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

运行时间：95ms

占用内存：17428k

2.2 初始值在左下角

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