Python—使用递归在嵌套列表中查找最大值和最小值之和

这是我到目前为止得到的一切。。。 我不知道我做错了什么

首先是我的助手函数

def max_min(l):

    if isinstance (l[0], list):
        result = max_min(l[0])

    elif len(l) == 2:
        if l[0] < l[1]:
            result = l[0], l[1]
        else:
            result = l[1], l[0]

    else:
        Min, Max = max_min(l[1:])
        if l[0] <= Min:
            result = l[0], Max
        elif l[0] >= Max:
            result = Min, l[0]
        else:
            result = Min, Max

    return result

它给了我

（2,7）

，这是我期望的

（1,7）

---

我没有主意了。。。任何人都可以为我指出方向吗？

当程序到达嵌套列表时，它会停止计算其他元素。如果isinstance（l[0]，list）块确保如果存在嵌套列表，则不会计算其余元素，因为从未调用

Min，Max=Max\u Min（l[1:]）

您可以使用以下内容修复

if

块：

if isinstance (l[0], list):
    Nested_Min, Nested_Max = max_min(l[0])
    Remainder_Min, Remainder_Max = max_min(l[1:])
    Min = Nested_Min if Nested_Min < Remainder_Min else Remainder_Min
    Max = Nested_Max if Nested_Max > Remainder_Max else Remainder_Max
    result = Min, Max

这样，对于单个元素列表，您的函数不会失败。最后，在开头添加如下内容：

if not l:
    return ()

请尝试以下方法：

def min_max(l):
    if isinstance(l, list):
        t = [min_max(v) for v in l]
        return min([m[0] for m in t]), max([m[1] for m in t])
    else:
        return l, l

样本输出：

>>> l = [6, 3, 7, 5, 5, 2, [3, 2], 1]
>>> min_max(l)
(1, 7)
>>>

---

请注意，空列表或子列表将导致错误，因此如果您关心它，可能需要添加检查。

要展开我的评论，您仍然需要使用递归来展平列表，因为您混合了整数和列表，代码如下所示：

def flatten(l):
    tmp = []
    for i in l:
        if isinstance(i, int):
            tmp.append(i)
        elif isinstance(i, list):
            tmp += flatten(i)
        else:
            raise AttributeError("found unexpected type {t}".format(t=type(i)))
    return tmp

---

您的递归函数可以同时简化和改进。有关详细信息，请参见以下内容：

#! /usr/bin/env python3


def main():
    array = [6, 3, 7, 5, 5, 2, [3, 2], 1]
    print(sum_min_max(array))


def sum_min_max(array):
    return (lambda a, b: a + b)(*get_min_max(array))


def get_min_max(array, minimum=+float('inf'), maximum=-float('inf')):
    if array:
        head, *tail = array
        if isinstance(head, (list, tuple)):
            minimum, maximum = get_min_max(head, minimum, maximum)
        else:
            if head < minimum:
                minimum = head
            if head > maximum:
                maximum = head
        minimum, maximum = get_min_max(tail, minimum, maximum)
    return minimum, maximum


if __name__ == '__main__':
    main()

#/usr/bin/env蟒蛇3
def main（）：
数组=[6,3,7,5,5,2,3,2,1]
打印（总和最小值最大值（数组））
def总和最小值最大值（阵列）：
返回值（λa，b:a+b）（*获取最小值最大值（数组））
def get_min_max（数组，最小值=+float（'inf'），最大值=-float（'inf'））：
如果阵列：
头，*尾=数组
如果isinstance（头，（列表，元组））：
最小值、最大值=最小值、最大值（水头、最小值、最大值）
其他：
如果压头<最小值：
最小值=水头
如果水头>最大值：
最大值=水头
最小值、最大值=获取最小值、最大值（尾部、最小值、最大值）
返回最小值，最大值
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
main（）

使用递归对应用程序至关重要吗？将其转换为单个列表，然后对其进行排序并获取第一个和最后一个元素会简单得多通过调试器运行您的代码，查看其行为与预期不符的地方。这是家庭作业吗？没有理由在真实代码中这样做。是的，这是家庭作业。。。好吧，练习~我们不允许在超过once@user984343. 在这种情况下，这就是XY问题。有比递归更好的选择。然而，你自己尝试并几乎成功的要点是。这绝对不是事实。那些函数会在嵌套列表中呕吐。我收回我以前的评论，事实上它们是incorrect@sedavidw你错了。试试这个：

min（[2[1,3]]）

。这将给出

2

，而不是

1

。确定。在Py2中工作，但答案不正确。甚至不知道它如何将列表与int.@TomKarzes进行比较。你完全正确。原因是一团糟。这是因为按字典顺序，“int”<“list”。不是开玩笑：@user984343。在这种情况下，也许选择这个答案是正确的。

def flatten(l):
    tmp = []
    for i in l:
        if isinstance(i, int):
            tmp.append(i)
        elif isinstance(i, list):
            tmp += flatten(i)
        else:
            raise AttributeError("found unexpected type {t}".format(t=type(i)))
    return tmp

#! /usr/bin/env python3


def main():
    array = [6, 3, 7, 5, 5, 2, [3, 2], 1]
    print(sum_min_max(array))


def sum_min_max(array):
    return (lambda a, b: a + b)(*get_min_max(array))


def get_min_max(array, minimum=+float('inf'), maximum=-float('inf')):
    if array:
        head, *tail = array
        if isinstance(head, (list, tuple)):
            minimum, maximum = get_min_max(head, minimum, maximum)
        else:
            if head < minimum:
                minimum = head
            if head > maximum:
                maximum = head
        minimum, maximum = get_min_max(tail, minimum, maximum)
    return minimum, maximum


if __name__ == '__main__':
    main()