牛客网66题-二维数组中元素查找【优化】

题目描述

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

题目要求及分析

时间限制：1秒 空间限制：32768K
分析：我们先按照IPO的思维分析这道题，输入是一个整数和一个二维数组，首先要想到的是数据的有效性，有可能都是空值或是其中某一个是空值，至于需要不需要判断输入的数值性，这个可以加入，但不是这道题目的重点，样例：

eg1:
input:   7     [[1 4 7],[2 7 0],[3 6 9]]
output:  True
eg2:
input: 7    [[]]
output: False

使用语言：python

python

解法1

最容易想到的就是暴力破解，遍历所有元素，比较得知是否含有目标元素，若有，则返回True，若不存在则在最后返回False。
时间复杂度 n * n

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

牛客网给出结果(一次提交)：
运行时间：368ms
占用内存：5624k
接下来我们试着去优化：确定这个数组是否包含输入整数，其实可以将问题看成简单的0根求解问题，就可以用到二分法。接下来对每一行采用二分法，如解法2.

解法2

时间复杂度 nlogn

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        height,width = len(array), len(array[0])
        for i in range(height):
            left,right = 0, width-1
            while left <= right:
                mid = (left+right) // 2
                if array[i][mid] == target:
                    return True
                elif array[i][mid] > target:
                    right = mid - 1
                else: 
                    left = mid + 1
        return False

牛客网给出结果(一次提交)：
运行时间：326ms
占用内存：5856k

解法3

上面是针对每一行使用二分法，但也可以对整体使用二分法。这里对整体排序使用sorted(list)

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        height,width = len(array), len(array[0])
        a = []
        for i in range(height):
            a.extend(array[i])
        temp = sorted(a)
        left,right = 0, len(temp)-1
        while left <= right:
            mid = (left+right) // 2
            if temp[mid] == target:
                    return True
                elif temp[mid] > target:
                    right = mid - 1
                else: 
                    left = mid + 1
        return False

牛客网给出结果(一次提交)：
运行时间：363ms
占用内存：5720k

这里对整体排序使用list.sort()

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        height,width = len(array), len(array[0])
        temp = []
        for i in range(height):
            temp.extend(array[i])
        temp.sort()
        left,right = 0, len(temp)-1
        while left <= right:
            mid = (left+right) // 2
            if temp[mid] == target:
                return True
            elif temp[mid] > target:
                right = mid - 1
            else: 
                left = mid + 1
        return False

牛客网给出结果(一次提交)：
运行时间：432ms
占用内存：5752k

虽然排序不是这里的重点，但python中针对列表排序有两种方法，list.sort()或是sorted(llist)，sort()是python中list内置的方法，sorted()是python内置的全局方法来对可迭代的序列生成新的序列。python中没有给出具体的实现方法，这里可以自己实现一种排序（正好对排序方法复习下）：
先使用快排试一下

# -*- coding:utf-8 -*-
class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        height,width = len(array), len(array[0])
        temp = []
        for i in range(height):
            temp.extend(array[i])
        temp = self.QuickSort(temp,0,len(temp)-1)
        left,right = 0, len(temp)-1
        while left <= right:
            mid = (left+right) // 2
            if temp[mid] == target:
                return True
            elif temp[mid] > target:
                right = mid - 1
            else: 
                left = mid + 1
        return False
    def QuickSort(self, myList,start,end):
        #判断low是否小于high,如果为false,直接返回
        if start < end:
            i,j = start,end
            #设置基准数
            base = myList[i]

            while i < j:
                #如果列表后边的数,比基准数大或相等,则前移一位直到有比基准数小的数出现
                while (i < j) and (myList[j] >= base):
                    j = j - 1

                #如找到,则把第j个元素赋值给第个元素i,此时表中i,j个元素相等
                myList[i] = myList[j]

                #同样的方式比较前半区
                while (i < j) and (myList[i] <= base):
                    i = i + 1
                myList[j] = myList[i]
            #做完第一轮比较之后,列表被分成了两个半区,并且i=j,需要将这个数设置回base
            myList[i] = base

            #递归前后半区
            self.QuickSort(myList, start, i - 1)
            self.QuickSort(myList, j + 1, end)
        return myList

牛客网给出结果(一次提交)：
运行时间：470ms
占用内存：5704k

效果差别不大

解法4

让我们再理解下题目，利用好题目中的信息，每一行都是从左到由递增，每一列都是从上到下递增，因此我们可以左上角或右上角开始寻找（保证在比较大小的时候，数据范围是一个二值化的过程，即不在上面就是下面）。以左下角为例，如果array[row][cloumn] >target，则target 必定在当前元素所在列的上面，即row-1。当array[row][cloumn] <target，则target必定在当前元素所在行的右侧，即column+1。
时间复杂度为n

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

牛客网给出结果(一次提交)：
运行时间：309ms
占用内存：5624k