如何修复递归代码，使其具有与迭代版本相同的渐近运行时间（但仍然是递归的）

Question

I was struggling to figure out what changes need to be made to the recursive version of my code below so that the asymptotic run time just about matches the iterative version. Of course, the recursive version of the code still needs to be recursive, but I was stuck on how I should approach cutting down the run time on the recursion.

def binarySearch(alist, item): //ITERATIVE VERSION
    first = 0
    last = len(alist)-1
    found = False
    while first<=last and not found:
        midpoint = (first + last)/2
        if alist[midpoint] == item:
            found = True
        else:
            if item < alist[midpoint]:
                last = midpoint-1
            else:
                first = midpoint+1
    return found

def binarySearch(alist, item): //RECURSIVE VERSION
    if len(alist) == 0:
        return False
    else:
        midpoint = len(alist)/2
        if alist[midpoint]==item:
            return True
        else:
            if item<alist[midpoint]:
                return binarySearch(alist[:midpoint],item)
            else:
                return binarySearch(alist[midpoint+1:],item)

Tried to replicate my function recursively, but the asymptotic running time was much slower than the iterative version.

Answer 1

Your recursive version creates new lists -- which is detrimental to both time and space complexity.

So instead of slicing alist , use first and last like you did in the iterative version:

def binarySearch(alist, item, first=0, last=None):
    if last is None:
        last = len(alist) - 1
    if last < first:
        return False
    else:
        midpoint = (start + end) // 2
        if alist[midpoint] == item:
            return True
        elif item < alist[midpoint]:
            return binarySearch(alist, item, first, midpoint - 1)
        else:
            return binarySearch(alist, item, midpoint + 1, last)