具有重复项的二进制搜索在未知键和列表处产生错误结果

Question

我正在尝试解决二进制搜索问题，其中 output 是排序列表中键首次出现的位置。

我设法解决了第一部分，我通过使用二进制搜索找到了键出现在排序列表中的任何位置。 但是第二部分，也就是它第一次出现的地方，对于一个未知的键和排序列表来说是错误的。

二分查找重复项的代码：

import math
import random

def binary_search(keys, query):
    low = 0
    high = len(keys) - 1


    def searchdef(keys, query, low, high):
        if low > high:
            return -1, 0, 0
        x = math.floor(low + (high-low)/2)
        if query != keys[x]:
            if query > keys[x]:
                for i in range(0, len(keys)-1):
                    return searchdef(keys, query, x+1, high)
            if query < keys[x]:
                return searchdef(keys, query, low, x-1)
        else:
            return x, high, low

    def finddup2(x, low):
        z = x-1
        while query == keys[z] and z != -1:
            return min(z, finddup2(z, low))
        else: return x
    
        

    x, high, low = searchdef(keys, query, low, high)
    ans = finddup2(x, low)
    return ans     



if __name__ == '__main__':
    
    num_keys = int(input())
    input_keys = list(map(int, input().split()))
    assert len(input_keys) == num_keys

    num_queries = int(input())
    input_queries = list(map(int, input().split()))
    assert len(input_queries) == num_queries

    for q in input_queries:
        print(binary_search(input_keys, q), end=' ')

我试图通过使用线性搜索对代码进行压力测试，但经过多次检查后它会产生递归错误。

压力测试代码：

import math
import random

def binary_search(keys, query):
    low = 0
    high = len(keys) - 1


    def searchdef(keys, query, low, high):
        if low > high:
            return -1, 0, 0
        x = math.floor(low + (high-low)/2)
        if query != keys[x]:
            if query > keys[x]:
                for i in range(0, len(keys)-1):
                    return searchdef(keys, query, x+1, high)
            if query < keys[x]:
                return searchdef(keys, query, low, x-1)
        else:
            return x, high, low

    
    def finddup2(x, low):
        z = x-1
        while query == keys[z] and z != -1:
            return min(z, finddup2(z-1, low))
        else: return x
    
        

    x, high, low = searchdef(keys, query, low, high)
    ans = finddup2(x, low)
    return ans     


def search(arr, N, x):
 
    for i in range(0, N):
        if (arr[i] == x):
            return i
    return -1

if __name__ == '__main__':

    def random_no():
        num_keys = int(50)
        input_keys = random.sample(range(1, 100), 50)
        input_keys.sort()
        assert len(input_keys) == num_keys

        num_queries = int(1)
        input_queries = [random.choice(input_keys)]
        assert len(input_queries) == num_queries
        return input_keys, input_queries

    input_keys, input_queries = random_no()

    def check(input_keys, input_queries):
        for q in input_queries:
            a = binary_search(input_keys, q)
            b = search(input_keys, len(input_keys), q)
            print(a, end=' ')
            print(b, end=' ')
            while a == b:
                print(a, end=' ')
                print(b, end=' ')
                print("ok")
                input_keys, input_queries = random_no()
                check(input_keys, input_queries)
            else:
                print(input_keys)
                print(q)
                print(a, end=' ')
                print(b, end=' ')               
                print("wrong")
                
    

    check(input_keys, input_queries)

我得到的错误：

RecursionError: maximum recursion depth exceeded in comparison

我想知道我的代码出了什么问题，以及为什么压力测试也不起作用。

编辑：

一些更改后我的新代码：

import math
import random

def binary_search(keys, query):
    low = 0
    high = len(keys) - 1


    def searchdef(keys, query, low, high):
        if low > high:
            return -1, high, low
        x = math.floor(low + (high-low)/2)
        if query != keys[x]:
            if query > keys[x]:
                return searchdef(keys, query, x+1, high)
            if query < keys[x]:
                return searchdef(keys, query, low, x-1)
        else:
            return x, high, low
    
    def finddup2(x, low):
        z = x-1
        if query == keys[z] and z != -1:
            return min(z, finddup2(z, low))
        else: return x
    
        

    x, high, low = searchdef(keys, query, low, high)
    ans = finddup2(x, low)
    return ans     



if __name__ == '__main__':
    
    num_keys = int(input())
    input_keys = list(map(int, input().split()))
    assert len(input_keys) == num_keys

    num_queries = int(input())
    input_queries = list(map(int, input().split()))
    assert len(input_queries) == num_queries

    for q in input_queries:
        print(binary_search(input_keys, q), end=' ')

黑盒测试后仍然返回错误答案。 我的压力测试找不到导致错误答案的值。 请你帮助我好吗？

编辑 2：我想出了一个小改动。 现在，代码返回正确答案，但超出了时间限制。 我请求帮助。

import math

def binary_search(keys, query):
    low = 0
    high = len(keys) - 1


    def searchdef(keys, query, low, high):
        if low > high:
            return -1
        if query < keys[low]:
            return -1
        if query > keys[high]:
            return -1
        if low <= high :
            x = math.floor(low + (high-low)/2)
            if query == keys[x]:
                while query == keys[x-1] and x != 0:
                    x -=1
                return x
            if query > keys[x]:
                return searchdef(keys, query, x+1, high)
            if query < keys[x]:
                return searchdef(keys, query, low, x-1)    
        

    x = searchdef(keys, query, low, high)
    return x



if __name__ == '__main__':
    
    num_keys = int(input())
    input_keys = list(map(int, input().split()))
    assert len(input_keys) == num_keys

    num_queries = int(input())
    input_queries = list(map(int, input().split()))
    assert len(input_queries) == num_queries

    for q in input_queries:
        print(binary_search(input_keys, q), end=' ')

Answer 1

二分查找的问题在于return min(z, finddup2(z-1, low))跳过了一个索引： z已经比当前索引少了一个，所以你不应该再从中减去 1 。 它应该是return min(z, finddup2(z, low))

其次，当找不到值且x == -1时，不应调用 function finddup2 。 所以：

    x, high, low = searchdef(keys, query, low, high)
    if x == -1:
        return -1
    ans = finddup2(x, low)
    return ans     

还有很多其他的评论，比如为什么你有一个while循环在它的第一次迭代中返回。 它应该只是一个if 。 此外， for循环在其第一次迭代中有一个return值，因此根本不应该存在该循环。 使finddup2递归不是一个好主意，因为这可能会占用大量堆栈空间。 让它迭代。

压力测试代码的问题在于它递归调用自身并导致堆栈溢出。

建议更正您的测试代码：

    def random_no(num_keys=50, num_queries=10):
        input_keys = random.sample(range(1, 100), num_keys)
        input_keys.sort()
        input_queries = random.choices(input_keys, k=num_queries)
        return input_keys, input_queries

    def check(input_keys, input_queries):
        for q in input_queries:
            a = binary_search(input_keys, q)
            b = search(input_keys, len(input_keys), q)
            if a != b:
                print(input_keys)
                print(q)
                print(a, b, "wrong")
                raise ValueError("wrong result")
    

    for _ in range(100):
        input_keys, input_queries = random_no()
        check(input_keys, input_queries)

    print("all done")

时间效率

function finddup2在空间（堆栈）和时间方面都是低效的。 在最坏的情况下，它必须扫描输入列表的一半，这使得它成为 O() 并扼杀了二分搜索算法的优势，二分搜索算法的时间复杂度为 O(log)。 但是O(log) + O() = O()，所以它已经退化为线性搜索的性能。

此外，使用math将浮点数转换为 integer 比仅使用 integer 除法运算符 ( // ) 更糟糕。

为了提高效率，您应该确保二分搜索算法继续向下钻取树，直到确定找到最左边的数字为止。

这是不需要finddup2的binary_search的改编版。 请注意，您不需要将keys和query作为 arguments 传递给您的内部 function，因为无论如何它都可以访问这些名称：

def binary_search(keys, query):
    low = 0
    high = len(keys) - 1

    def searchdef(low, high):
        if low > high:
            if low >= len(keys) or keys[low] != query:
                return -1
            return low
        x = (low + high) // 2
        if query > keys[x]: 
            return searchdef(x + 1, high)
        else:  # Continue also when equal!
            return searchdef(low, x - 1)
            
    return searchdef(low, high)