二分法查找一个有序的二维矩阵

如何在以下有序二维矩阵中查找一个数：

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

alist = [
    list(range((m - 1) * 100 + 1, (100 * m) + 1))
    for m in range(1, 101)
]

方法一：把二维矩阵分解成一维的二分法查找，就是进行m次的二分法查找。时间复杂度：O(mlogn)

def search_1(alist, target):
    # 特殊情况处理
    if len(alist) == 0 or len(alist[0]) == 0:
        return False

    x, y = len(alist), len(alist[0]) - 1
    for i in range(x):
        left, right = 0, y
        while left <= right:
            mid = (left + right) // 2
            if alist[i][mid] > target:
                right = mid - 1
            elif alist[i][mid] < target:
                left = mid + 1
            else:
                return i, mid
    return False

方法二：从矩阵的左下角开始查询，如果该值大于target，则其右所有的数都会大于target，因此该行就不再需要检查而直接跳到上一行（i-=1）；如果该值小于target，则其上所有的数都会小于target，因此该列就不再需要检查而直接跳到下一列（j+=1）。时间复杂度：O(m+n)

def search_2(alist, target):
    x = len(alist) - 1
    y = 0
    while x >= 0 and y < len(alist[0]):
        if alist[x][y] == target:
            return x, y
        elif alist[x][y] > target:
            x -= 1
        else:
            y += 1
    return False

方法三：先在第一维的第一个数进行二分法查找，如果该值小于target，则左边的所有数都比target小，因此target在二维数组的右边，可能和该值在同一组里，也可能在右边的组里，通过对比下一组的第一个数来确定是否处于同一组，如果在同一组，则又是一维的二分法查找。时间复杂度：O(logm + logn)

def search_3(alist, target):
    # 特殊情况
    if len(alist) == 0 or len(alist[0]) == 0:
        return False

    left_x, right_x = 0, len(alist) - 1
    # 对每一组的第一个数进行二分法查找
    while left_x <= right_x:
        mid_x = (left_x + right_x) // 2
        if alist[mid_x][0] < target:
            # 如果是最后一组，或者下一组的第一个数比target大，则与target同一组
            if mid_x == right_x or alist[mid_x + 1][0] > target:
                # 此处已确定在具体哪一组了，然后再在这一组里进行二分法查找
                left_y, right_y = 1, len(alist[mid_x]) - 1
                while left_y <= right_y:
                    mid_y = (left_y + right_y) // 2
                    if alist[mid_x][mid_y] > target:
                        right_y = mid_y - 1
                    elif alist[mid_x][mid_y] < target:
                        left_y = mid_y + 1
                    else:
                        return mid_x, mid_y
                return False
            else:
                left_x = mid_x + 1
        elif alist[mid_x][0] > target:
            right_x = mid_x - 1
        else:
            return mid_x, 0
    return False

方法四：先拿矩阵的中点（alist[mid_x][mix_y]）与target比较，如果大于target，则右边的所有数都比target大，因此target在矩阵的左边，有可能和矩阵中点同一组，也有可能在左边的组里，通过对比前一组的最后一个值可以判断是否为同一组，如果为同一组，则在同一组剩下未确定的数中进行二分法查找，如果不在同一组，再次从左边组里进行重复以上操作。如果矩阵中点小于target，则左边组的所有数都比target小，因此target在矩阵的右边，有可能和矩阵中点在同一组，也有可能在右边组里，通过对比后一组的第一个值判断是否为同一组，如果为同一组，则在同一组剩下未确定的数中进行二分法查找。时间复杂度：O(logm + log(n/2))

def search_4(alist, target):
    # 特殊情况
    if len(alist) == 0 or len(alist[0]) == 0:
        return False

    left_x, left_y = 0, 0
    right_x, right_y = len(alist) - 1, len(alist[0]) - 1
    while left_x <= right_x and left_y <= right_y:
        mid_x = (left_x + right_x) // 2
        mid_y = (left_y + right_y) // 2
        if alist[mid_x][mid_y] > target:
            # 判断是否为第一组，如果不是再判断是否同一组, 通过上一组的最后一个数进行判断
            if mid_x == left_x or alist[mid_x - 1][right_y] < target:
                # 已经确定在同一组，在该组剩下未确定的数中进行二分法查找
                right_y = mid_y - 1
                while left_y <= right_y:
                    mid_y = (left_y + right_y) // 2
                    if alist[mid_x][mid_y] > target:
                        right_y = mid_y - 1
                    elif alist[mid_x][mid_y] < target:
                        left_y = mid_y + 1
                    else:
                        return mid_x, mid_y
                return False
            # 不在同一组，继续两个维度的二分法
            elif alist[mid_x - 1][right_y] > target:
                right_x = mid_x - 1
            else:
                return mid_x - 1, right_y
        elif alist[mid_x][mid_y] < target:
            # 判断是否为第最后组，如过不是再判断是否在同一组, 通过下一组的第一个数进行判断
            if mid_x == right_x or alist[mid_x + 1][left_y] > target:
                # 已经确定在同一组，在该组剩下未确定的数中进行二分法查找
                left_y = mid_y + 1
                while left_y <= right_y:
                    mid_y = (left_y + right_y) // 2
                    if alist[mid_x][mid_y] > target:
                        right_y = mid_y - 1
                    elif alist[mid_x][mid_y] < target:
                        left_y = mid_y + 1
                    else:
                        return mid_x, mid_y
                return False
            # 不在同一组，继续两个维度的二分法
            elif alist[mid_x + 1][left_y] < target:
                left_x = mid_x + 1
            else:
                return mid_x + 1, left_y
        else:
            return mid_x, mid_y
    return False

方法三与方法四存在共同的地方，要留意一个点就是判断前一组或后一组的时候，先判断是否为第一组或最后一组。

以下是对100x100的有序二维数组进行查询

if __name__ == '__main__':
    import timeit

    alist = [
        list(range((m - 1) * 100 + 1, (100 * m) + 1))
        for m in range(1, 101)
    ]
    target = 10000
    setup = 'from __main__ import search_1, search_2, search_3,search_4, alist, target'
    number = 100000
    print(round(timeit.timeit('search_1(alist, target)', setup=setup, number=number), 2))
    print(round(timeit.timeit('search_2(alist, target)', setup=setup, number=number), 2))
    print(round(timeit.timeit('search_3(alist, target)', setup=setup, number=number), 2))
    print(round(timeit.timeit('search_4(alist, target)', setup=setup, number=number), 2))

    """
    target = 1:     target = 100     target = 9901       target = 10000
     0.14           0.18             12.16               11.93
     1.91           3.79             0.04                1.89
     0.13           0.26             0.4                 0.3
     0.32           0.37             0.45                0.42
    """

用timeit计算每种方法的运算时间，每种方法执行100000次，所占的时间如上所示：

总体来看，查询速度, 方法一 < 方法二 < 方法四 < 方法三，方法三和方法四的查询速度比前面两种方法快得多，因为方法三和方法四两个维度都使用了数组的有序性。但是方法四的时间复杂度比方法三还小，为什么比方法三还慢呢？个人理解是，方法四每次m循环都进行了2次比较，而方法三只有大于target的时候才进行2次比较，所以四种方法中，方法三的查询速度是最快的。