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

可以使用递归函数来求列表的嵌套层数。下面是一个示例的 Python 代码：

def get_nested_depth(lst):
    if not isinstance(lst, list):
        return 0
    max_depth = 0
    for item in lst:
        if isinstance(item, list):
            depth = get_nested_depth(item)
            if depth > max_depth:
                max_depth = depth
    return max_depth + 1

使用这个函数，你可以传入一个列表，它会返回该列表的嵌套层数。例如：

nested_list = [1, [2, [3, [4]]]]
depth = get_nested_depth(nested_list)
print(depth)  # 输出 4

这里的 `get_nested_depth` 函数首先检查传入的参数是否为列表，如果不是，则直接返回 0。然后，它遍历列表中的每个元素，如果某个元素是列表，则递归调用 `get_nested_depth` 函数，获取其嵌套层数，并与当前的最大深度比较，更新最大深度值。最后，返回最大深度值加 1，即为列表的嵌套层数。

相关问题

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`函数内部又调用了自身，实现了函数嵌套。