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

可以使用递归函数来求列表的嵌套层数。具体思路是，如果一个列表为空，那么它的嵌套层数为 1；否则，它的嵌套层数应该是其中元素的嵌套层数的最大值再加 1。

以下是 Python 代码实现：

def nested_depth(lst):
    if not isinstance(lst, list):  # 非列表类型的元素，嵌套层数为 0
        return 0
    elif not lst:  # 空列表，嵌套层数为 1
        return 1
    else:  # 非空列表，嵌套层数为最大嵌套层数加 1
        return max(nested_depth(item) for item in lst) + 1

在上述代码中，`isinstance()` 函数用于判断一个对象是否为列表类型；`not lst` 判断列表是否为空。`max()` 函数用于求出列表中元素的最大值。

以下是一些示例：

print(nested_depth(3))  # 输出 0
print(nested_depth([]))  # 输出 1
print(nested_depth([1, [2, 3], [4, [5, 6], 7]]))  # 输出 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`函数内部又调用了自身，实现了函数嵌套。