递归线性搜索 - 返回列表索引

Question

我有一个函数 search，它在列表 ('l') 中搜索键，如果找到则返回 True，否则返回 False。如果找到，我希望它返回 key 的索引，如果没有找到，则返回 False，但我对我的 return 语句应该是什么感到困惑。这是我的代码：

def search(l,key):
    """
    locates key in list l.  if present, returns location as an index; 
    else returns False.
    PRE: l is a list.
    POST: l is unchanged; returns i such that l[i] == key; False otherwise.
    """

    if l:   # checks if list exists
        if l[0] == key:     # base case - first index is key
            return True

        s = search(l[1:], key)      # recursion
        if s is not False:          
            return s

    return False            # returns false if key not found

任何帮助将不胜感激，谢谢。

Answer 1

对于您的基本情况，您刚刚在索引 0 处找到了该项目，对吧？返回 0。

if l[0] == key:     # base case - first index is key
    return 0

对于递归部分，让我们考虑返回什么。假设该项目的索引为 5。由于我们通过递归调用传递了一个移动了一个元素的列表，它会找到它并返回 4。（4，而不是 5。你明白为什么吗？）

我们需要在返回之前添加一个来取消移动索引。

s = search(l[1:], key)      # recursion
if s is not False:          
    return s + 1

Answer 2

您需要跟踪索引。因为您的最终返回值 [如果发生 True 搜索] 是布尔值，因此您必须更改它。
我想下面的代码应该可以帮助你，但要彻底测试它，因为我只是试图理解意图并且没有彻底测试逻辑 -

def search(l,key,idx=0):
"""
locates key in list l.  if present, returns location as an index; 
else returns False.
PRE: l is a list.
POST: l is unchanged; returns i such that l[i] == key; False otherwise.
"""

if l:   # checks if list exists
    if l[0] == key:     # base case - first index is key
    return idx

    s = search(l[1:], key, (idx + 1))      # recursion
    if s is not False:          
        return s

return False            # returns false if key not found

Answer 3

问题是您正在切片列表的尾部，而没有保留有关切片发生位置的任何信息。

事实上，您根本不需要对列表进行切片，因为您只需在列表中进行索引查找即可。

线性搜索的算法是原始递归的，所以如果你能想出一个迭代的解决方案，递归的解决方案是很容易达到的（反之亦然）。

所以迭代解决方案可能看起来像这样：

for every integer i between zero and length of list
    if the element at position i in the list is equal to the key
        return i
else
   return "I couldn't find it"

我们将迭代解决方案转换为递归解决方案基本上意味着将循环转换为函数调用，其参数是下一次循环迭代的值。循环变量是i 和正在搜索的列表。为了让你从这个练习中学习，我就先不说了。

Answer 4

您的 API 设计存在严重缺陷。

>>> False == 0
True

您的教练正在为您准备惊喜。例如：

where = search(["non-foo", "not-foo"], "foo") # returns False
if where == 0:
    print "foo is in pole position"
    # but "foo" isn't even a candidate

让它在失败时返回None。试试这个：

>>> def search(alist, key, pos=None):
...     if pos is None: pos = len(alist) - 1
...     if pos < 0: return None
...     if key == alist[pos]: return pos
...     return search(alist, key, pos - 1)
...
>>> search([1,2,3], 4) # -> None
>>> search([1,2,3], 3)
2
>>> search([1,2,3], 2)
1
>>> search([1,2,3], 1)
0
>>> search([], 1) # -> None
>>>

此方法的其他特点： (1) 向您介绍“隐藏”参数的概念，该参数可用于在非递归函数中使用局部变量的情况。 (2) 避免所有字符串切片的成本。

==========================================

为了@inspectorG4dget 的利益，这是我对@anirvan 答案的重构：

def xsearch(l,key,idx=0):
    if l:   # checks if list exists
        if l[0] == key:     # base case - first index is key
            return idx
        s = xsearch(l[1:], key, (idx + 1))      # recursion
        if s is not False:          
            return s
        #### and if s is False, it falls through and returns False ####
        #### so it can return s unconditionally!                   ####
    return False            # returns false if key not found

def ysearch(l,key,idx=0):
    if l:   # checks if list exists
        if l[0] == key:     # base case - first index is key
            return idx
        return ysearch(l[1:], key, (idx + 1))      # recursion
    return False            # returns false if key not found
    #### above statement is better put closer to the `if` ####

def zsearch(l,key,idx=0):
    if not l:   # checks if list exists
        return False
    if l[0] == key:     # base case - first index is key
        return idx
    return zsearch(l[1:], key, (idx + 1))      # recursion