用递归函数求列表的嵌套层数

以下是 Python 代码实现：

def get_depth(lst):
    if not isinstance(lst, list):
        return 0
    if len(lst) == 0:
        return 1
    return max(get_depth(item) for item in lst) + 1

解释一下代码：

- 这个函数的核心思想是递归，如果一个列表里面还有列表，那么它的层数就比外层多一层，我们可以通过递归来实现。
- 首先判断传入的参数 `lst` 是否是列表类型，如果不是，那么说明这不是一个嵌套列表，返回 0 表示没有嵌套。
- 如果传入的列表是空列表，说明这是一个空的嵌套列表，返回 1 表示只有一层嵌套。
- 如果传入的列表不是空列表且是嵌套列表，那么就递归遍历列表中每个元素，获取每个元素的嵌套层数，取其中最大值再加上 1，即为该列表的嵌套层数。
- 最后返回嵌套层数。

测试一下：

lst = [1, 2, [3, 4, [5, 6]]]
print(get_depth(lst))  # 输出 3

相关问题

python 递归函数列表嵌套

可以使用递归函数来处理列表嵌套的问题，例如：

def flatten(lst):
    result = []
    for i in lst:
        if isinstance(i, list):
            result.extend(flatten(i))
        else:
            result.append(i)
    return result

lst = [1, 2, [3, 4, [5, 6], 7], 8, [9]]
print(flatten(lst))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

在这个例子中，我们定义了一个名为“flatten”的递归函数，它接受一个列表作为参数，并返回一个扁平化的列表。对于给定的列表中的每个元素，我们检查它是否是一个列表。如果是，我们递归调用“flatten”函数，并将其返回的结果添加到结果列表中。否则，我们将元素本身添加到结果列表中。最后，我们返回结果列表。

在这个例子中，我们使用了“isinstance”函数来检查元素是否是一个列表。如果是，我们递归调用“flatten”函数。如果不是，我们将元素本身添加到结果列表中。

分别写一个递归函数和函数嵌套调用的C语言代码

在C语言中，递归函数是指函数直接或间接地调用自身的过程。下面是一个经典的斐波那契数列的递归函数示例：

#include <stdio.h>

// 递归函数计算斐波那契数列
int fibonacci(int n) {
   if (n <= 1)
       return n;
   else
       return fibonacci(n - 1) + fibonacci(n - 2);
}

int main() {
   int num = 10; // 要计算的斐波那契数的位置
   printf("The %dth Fibonacci number is: %d\n", num, fibonacci(num));
   return 0;
}

在这个例子中，`fibonacci`函数会一直调用自身直到基本情况 `n <= 1` 被满足。

至于函数嵌套调用，就是在一个函数内部再调用另一个函数。这里有一个简单的例子，计算阶乘：

#include <stdio.h>

// 函数嵌套调用计算阶乘
int factorial(int n) {
   if (n == 0 || n == 1)
       return 1;
   else
       return n * factorial(n - 1);
}

int main() {
   int num = 5;
   printf("Factorial of %d is: %d\n", num, factorial(num));
   return 0;
}

在这段代码中，`factorial`函数内部又调用了自身，实现了函数嵌套。