关于寻找任意嵌套列表的最大深度

Question

我目前正在使用 Python 中的递归函数，但遇到了麻烦。如题，问题是返回任意嵌套列表的最大深度。

这是我目前所拥有的：

def depthCount(lst):
    'takes an arbitrarily nested list as a parameter and returns the maximum depth to which the list has nested sub-lists.'

    var = 0

    if len(lst) > 0:

        if type(lst[0]) == list:
            var += 1
            depthCount(lst[1:])

        else:
            depthCount(lst[1:])

    else:
        return var

我觉得问题出在我的递归调用上（这可能很明显）。当列表到达末尾时，它确实会返回 var ，但是当我有一个非空列表时，事情就会出错。什么都没有返回。

我切错了吗？我应该在递归调用中的切片之前做些什么吗？

问题也可能与我的基本情况有关。

Answer 1

如果它们只是嵌套列表，例如[[[], []], [], [[]]]，这是一个不错的解决方案：

def depthCount(lst):
    return 1 + max(map(depthCount, lst), default=0)

如果您不使用 Python 3.4，您可以使用以下细微变化，其中引入了 default 参数：

def depthCount(lst):
    return len(lst) and 1 + max(map(depthCount, lst))

它们的计数方式也不同。第一个认为空列表为深度 1，第二个为深度 0。第一个很容易适应，不过，只需将默认值设为 -1。

---

如果它们不只是嵌套列表，例如 [[[1], 'a', [-5.5]], [(6,3)], [['hi']]])，以下是对此的改编：

def depthCount(x):
    return 1 + max(map(depthCount, x)) if x and isinstance(x, list) else 0

def depthCount(x):
    return int(isinstance(x, list)) and len(x) and 1 + max(map(depthCount, x))

确保您了解后者的工作原理。如果你还不知道，它会教你and 如何在 Python 中工作:-)

---

接受“纯递归”挑战：

def depthCount(x, depth=0):
    if not x or not isinstance(x, list):
        return depth
    return max(depthCount(x[0], depth+1),
               depthCount(x[1:], depth))

当然，额外的参数有点难看，但我认为没关系。

Answer 2

当列表到达末尾时它确实会返回 var，但是当我有一个非空列表时，事情就会出错。什么都没有返回。

那是因为您没有 return 语句，除了空列表的 else 基本情况。如果你在函数末尾没有碰到return，就意味着函数返回None。

但除此之外，您还有另一个问题。你开始var = 0，然后可能在做var += 1……但你没有将它传递给递归调用，或者使用递归调用的任何结果。所以递归调用根本没有用处。

你的意思可能是这样的：

def depthCount(lst):
    'takes an arbitrarily nested list as a parameter and returns the maximum depth to which the list has nested sub-lists.'

    if len(lst) > 0:

        if type(lst[0]) == list:
            return 1 + depthCount(lst[1:])
        else:
            return depthCount(lst[1:])

    else:
        return 0

但这实际上仍然不正确。列表的深度计数比其最深元素的深度计数多 1。仅仅检查它的 second 元素对你没有任何好处。你需要检查他们的所有。所以，你真正想要的是这样的：

def depthCount(lst):
    'takes an arbitrarily nested list as a parameter and returns the maximum depth to which the list has nested sub-lists.'
    if isinstance(lst, list):
        return 1 + max(depthCount(x) for x in lst)
    else:
        return 0

---

如果您想用 second 层递归替换该迭代 for x in lst，当然可以，但我看不出有什么好的理由这样做；它只是无缘无故地使代码更加复杂。例如：

def max_child_count(lst):
    if lst:
        return max(depth_count(lst[0]), max_child_count(lst[1:]))
    else:
        return 0

def depth_count(lst):
    if isinstance(lst, list):
        return 1 + max_child_count(lst)
    else:
        return 0

---

这可能仍然不正确。它绝对是正确的，例如，[1, [2,3], [4, [5]]]。但是它应该为[] 做什么？从你的问题我看不出来。如果它应该返回0 或1，您显然需要适当地更改if。如果这是非法输入，那么它已经在做正确的事情了。 （并且应该还回答了它应该做什么的问题，例如，[[[], []], [], [[]]]，但请确保您也考虑过这种情况。）

Answer 3

因此，本质上，您所指的数据结构是k-ary 树，也称为 n 叉树，具有任意分支。这是确定最大值的代码。具有任意分支的 n 叉树的深度。

def maxdepth(tree):
    if isleaf(tree):
        return 1
    maximum = 0
    for child in children(tree):
        depth = maxdepth(child)
        if depth > maximum:
            maximum = depth
    return maximum + 1

您可以通过不同的测试输入here查看运行代码。