【无标题】

递归在数组上的使用
数组求和

def array_sum(arr):
    if len(arr) == 0:
        return 0
    else:
        return arr[0] + array_sum(arr[1:])

递归在JSON上的使用
JSON键值查找

def find_key(json_obj, target_key):
    if isinstance(json_obj, dict):
        for key, value in json_obj.items():
            if key == target_key:
                return value
            else:
                result = find_key(value, target_key)
                if result is not None:
                    return result
    elif isinstance(json_obj, list):
        for item in json_obj:
            result = find_key(item, target_key)
            if result is not None:
                return result
    return None

递归在二叉树上的使用

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def binary_tree_sum(root):
    if root is None:
        return 0
    else:
        return root.val + binary_tree_sum(root.left) + binary_tree_sum(root.right)

递归在多叉树上的使用

class TreeNode:
    def __init__(self, val=0, children=[]):
        self.val = val
        self.children = children

def multiway_tree_sum(root):
    if root is None:
        return 0
    else:
        sum_val = root.val
        for child in root.children:
            sum_val += multiway_tree_sum(child)
        return sum_val

递归在网状结构上的使用
网状结构一般是一种复杂的数据结构，可以包含多个层级和交叉关系，递归在此类结构上的使用要根据具体情况设计。

递归在图形上的使用

```bash
class Graph:
    def __init__(self):
        self.graph = {}

    def add_edge(self, u, v):
        if u not in self.graph:
            self.graph[u] = []
        self.graph[u].append(v)

    def dfs(self, vertex, visited):
        visited[vertex] = True
        print(vertex, end=' ')

        for i in self.graph[vertex]:
            if not visited[i]:
                self.dfs(i, visited)

    def dfs_traversal(self):
        vertices = list(self.graph.keys())
        visited = {v: False for v in vertices}

        for vertex in vertices:
            if not visited[vertex]:
                self.dfs(vertex, visited)


# 示例用法
g = Graph()
g.add_edge(0, 1)
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(2, 0)
g.add_edge(2, 3)
g.add_edge(3, 3)

print("图的DFS遍历:")
g.dfs_traversal()

上述代码实现了图的深度优先搜索（DFS）遍历，通过递归访问与当前节点相邻的未访问节点，直到遍历完所有节点为止。

解题思路：

# 递归在数组上的使用

# 函数array_sum用于计算数组中所有元素的和。
# 基本情况：当数组为空时，返回0，表示没有元素需要求和。
# 递归情况：将数组的第一个元素与其余部分传递给递归函数，继续求和。
# 递归过程中，每次都将数组的规模缩小，直到最终到达基本情况，然后逐层返回计算结果，得到最终的数组和。

# 递归在JSON上的使用

# 函数find_key用于在JSON对象中查找指定的键值对应的值。
# 如果当前对象是字典类型，则遍历所有键值对，检查是否有目标键，如果找到，则返回对应的值。
# 如果当前对象是列表类型，则遍历列表中的每个元素，递归调用find_key函数查找目标键。
# 递归过程中，不断深入JSON的嵌套结构，直到找到目标键或遍历完所有元素。
# 如果找到目标键，返回对应的值，否则返回None表示未找到。

# 递归在二叉树上的使用

# 定义了一个TreeNode类，表示二叉树的节点。
# 函数binary_tree_sum用于计算二叉树中所有节点值的和。
# 基本情况：当当前节点为空（即为叶子节点）时，返回0。
# 递归情况：计算当前节点的值，加上左子树和右子树的和。
# 递归过程中，逐层遍历二叉树的每个节点，对每个节点进行递归求和。
# 最终返回根节点的值加上左子树和右子树的和，得到整个二叉树的节点值之和。

# 递归在多叉树上的使用

# 定义了一个TreeNode类，表示多叉树的节点，其中每个节点可以有多个子节点。
# 函数multiway_tree_sum用于计算多叉树中所有节点值的和。
# 基本情况：当当前节点为空（即为叶子节点）时，返回0。
# 递归情况：计算当前节点的值，加上所有子节点的和。
# 递归过程中，逐层遍历多叉树的每个节点，对每个节点进行递归求和。
# 最终返回根节点的值加上所有子节点的和，得到整个多叉树的节点值之和。

# 递归在网状结构上的使用

# 网状结构一般是一种复杂的数据结构，没有统一的递归模式。递归的使用在具体的网状结构中可能不同。
# 在处理网状结构时，需要根据具体情况设计递归的方式和逻辑。

# 递归在图形上的使用

# 定义了一个Graph类，表示图形结构。
# 函数dfs用于深度优先搜索遍历图形结构，并输出遍历的结果。
# 函数dfs_traversal用于调用dfs函数对图进行遍历。
# 基本情况：如果当前节点已被访问过，则不再进行递归遍历。
# 递归情况：对当前节点进行访问，并递归遍历与当前节点相邻且未被访问的节点。
# 递归过程中，通过递归调用dfs函数，不断深入图形结构，直到遍历完所有节点。
# 输出结果为图的深度优先遍历顺序。