如何使用递归python查找列表中最大的元素？

我不知道这个函数有什么问题？这是一个无限循环

i = 0

def find_max(seq):
if i == len(seq) - 1:
      return seq[0]
else:
      first = seq[i]
      i = i + 1
      max_of_rest = find_max(seq)
      return max(first, max_of_rest)

稍后谢谢

您可以查看以下内容：

i = 0

def find_max(seq):
    global i
    if i == len(seq) :
        return seq[0]
    else:
          first = seq[i]
          i = i + 1
          max_of_rest = find_max(seq)
          return max(first, max_of_rest)



print(find_max([-10,2,4,-5]))

您的代码有很多缩进问题，可能会跳过某些行的执行。 您的代码应该如下所示：

def find_max(seq):
    if len(seq) == 1:
        return seq[0]
    else:
        if seq[0] > seq[1]:
            seq.pop(1)
        else:
            seq.pop(0)
        return find_max(seq)

---

您错过了全局设置，因此函数中没有定义

i

。

请查看以下解决方案并遵循注释：

i = 0

def find_max(seq):
    global i
    if i == len(seq) - 1:
        return seq[0]
    else:
        first = seq[i]
        i = i + 1
        max_of_rest = find_max(seq)
        return max(first, max_of_rest)

---

您使用的是uneeded

i

变量，在递归中有基本大小写（您的第一个

if

）和递归大小写，在这种情况下，它将访问列表的第一个和第二个元素。由于您已经检查了列表

seq

是否有多个元素，因此您可以放心地访问列表的位置0和1

在您的特定情况下，您并没有真正使用递归，因为您从不减少案例，而是增加一个

i

变量，而递归是基于始终调用具有“更简单”或减少问题的相同函数

考虑到这一点，您的解决方案中有几点可以改进

def find_biggest(_list, max_element, first_run):
    """
    _list is a list of floats or integers or both,
    max element is used to store max value,
    first run checks if _list is not empty
    """
    if first_run and not _list:  # check if _list is not empty
        raise ValueError("_list should have float or integer values inside")

    first_run = False

    if not _list:  # exit from recursion, we checked all elements
        return max_element

    element = _list.pop()  # take one element

    if type(element) not in (int, float,):  # check element type
        raise TypeError("_list should contain only int or float values")

    if element >= max_element:  # check if it is more than max
        max_element = element

    return find_biggest(_list, max_element, first_run)  # next step of recursion


if __name__ == "__main__":
    # test
    print(find_biggest([-1, 4, 2, 3, 1, 0, 10, 3, 1, 7], 0, True))
    # print(find_biggest([], 0, True))  # empty case
    # print(find_biggest([-1, 4, 2, 3, "1", 0, 10, 3, 1, 7], 0, True))  # string in list

基于代码的完整解决方案如下所示

i = 0 # Not adviced

def find_max(seq):
    # Here you want to check length, making it
    # depend on i = problems
    if i == len(seq) - 1: 
        return seq[0]
    else:
        first = seq[i] # Remove all references to i
        i = i + 1 # Remove
        # Here you want to call the function with the list
        # except the element you know is lower, making the problem
        # smaller until you get to the base case
        # Instead you are calling find_max with the same
        # sequence you had (infinite loop) and returning a
        # totally different result.
        max_of_rest = find_max(seq)
        return max(first, max_of_rest)

def find_max（seq）：
如果len（seq）==0：
一无所获
如果len（seq）您的代码包含一个
缩进错误
，并且没有减少递归调用中的数据-因此数据永远不会变短-因此递归永远不会结束：

这将是一个固定的递归解决方案：

def find_max(seq):
    if i == len(seq) - 1:   # fixed indentation here and below
          return seq[0]
    else:
          first = seq[i]
          i = i + 1
          max_of_rest = find_max(seq)  # never reducing your data size, hence endless
          return max(first, max_of_rest)


这个问题对于递归解决方案来说是遗传性的，线性解决它要好得多（不需要
max（…）
调用）：


有关
m=m if value
的作用的解释，请参阅。
为什么要递归地执行此操作？你创建了大量的调用stackframes来使用buildin
max
多次调用，而
max（seq）
可以在线性时间内完成，并且所需内存更少？@Patrick，你可以递归地这样做来学习编程。为什么刚开始学习的人需要关于stackframes、大O和内存使用的建议？Mike递归编程有“好”和“坏”两个问题——树和链表浮现在脑海中。仅仅为了递归而对一个线性问题进行递归是很糟糕的。@Patrick然后我发现做一个建设性的评论，或者更好，像你做的那样发布一个答案，这是一个更好的方法，而不是为了提问而问一篇帖子。你的帖子会崩溃（索引器）因为：
find_max（[]）
并构建递归不需要的中间内部列表，但在其他情况下有效
def find_max(seq):
    if i == len(seq) - 1:   # fixed indentation here and below
          return seq[0]
    else:
          first = seq[i]
          i = i + 1
          max_of_rest = find_max(seq)  # never reducing your data size, hence endless
          return max(first, max_of_rest)

def find_max(seq):   
    if not seq:
        return None  # or raise ValueError if you want find_max([]) to crash
    if len(seq) == 1:
        return seq[0]
    else:
        return max(seq[0], find_max(seq[1:]))

def find_max_lin(seq):
    if not seq:
        return None
    m = seq[0]
    for value in seq[1:]:
        m = m if value < m else value
    return m

def find_max_builtin(seq): 
    # no need to create your own function for that though
    return max(seq)