用邻接表给定(输入)一个有向带权图，用prim或kurskal算法实现 求图的最小生成树并输出图的最小生成树(输出每个节点是谁？ 节点的左孩子是谁？节点的右孩子是谁？)。输入过程和 输出结果

好的，我理解了你的问题。下面是一个完整的示例程序，用于实现 Prim 和 Kruskal 算法，并输出最小生成树每个节点的父节点信息。

首先，我们需要定义一个带权有向图的类，用邻接表来存储图的结构。代码如下：

from collections import defaultdict


class Graph:
    def __init__(self, vertices):
        self.V = vertices
        self.graph = defaultdict(list)

    def add_edge(self, u, v, w):
        self.graph[u].append((v, w))

接下来，我们使用 Prim 算法来求最小生成树。代码如下：

import sys


class PrimMST:
    def __init__(self, vertices):
        self.V = vertices
        self.key = [sys.maxsize] * vertices
        self.parent = [None] * vertices
        self.visited = [False] * vertices

    def min_key(self):
        min_value = sys.maxsize
        min_index = -1
        for v in range(self.V):
            if self.key[v] < min_value and not self.visited[v]:
                min_value = self.key[v]
                min_index = v
        return min_index

    def prim(self, graph):
        self.key[0] = 0
        self.parent[0] = -1
        for i in range(self.V):
            u = self.min_key()
            self.visited[u] = True
            for v, w in graph[u]:
                if not self.visited[v] and w < self.key[v]:
                    self.key[v] = w
                    self.parent[v] = u

        print("Prim算法求解最小生成树：")
        for i in range(1, self.V):
            print(f"节点{i}的父节点是{self.parent[i]}")

最后，我们使用 Kruskal 算法来求最小生成树。代码如下：

class KruskalMST:
    def __init__(self, vertices):
        self.V = vertices
        self.edges = []
        self.parent = [i for i in range(vertices)]

    def add_edge(self, u, v, w):
        self.edges.append((w, u, v))

    def find(self, u):
        if self.parent[u] == u:
            return u
        self.parent[u] = self.find(self.parent[u])
        return self.parent[u]

    def union(self, u, v):
        self.parent[self.find(u)] = self.find(v)

    def kruskal(self):
        result = []
        self.edges = sorted(self.edges)
        i = 0
        e = 0
        while e < self.V - 1:
            w, u, v = self.edges[i]
            i += 1
            x = self.find(u)
            y = self.find(v)
            if x != y:
                e += 1
                result.append((u, v, w))
                self.union(x, y)

        print("Kruskal算法求解最小生成树：")
        for u, v, weight in result:
            print(f"节点{v}的父节点是{u}")

下面是一个完整的示例程序，用于测试 Prim 和 Kruskal 算法的实现，并输出最小生成树每个节点的父节点信息：

if __name__ == '__main__':
    # 输入有向带权图
    g = Graph(5)
    g.add_edge(0, 1, 2)
    g.add_edge(0, 3, 6)
    g.add_edge(1, 2, 3)
    g.add_edge(1, 3, 8)
    g.add_edge(1, 4, 5)
    g.add_edge(2, 4, 7)

    # 使用 Prim 算法求解最小生成树
    p = PrimMST(5)
    p.prim(g.graph)

    # 使用 Kruskal 算法求解最小生成树
    k = KruskalMST(5)
    k.add_edge(0, 1, 2)
    k.add_edge(0, 3, 6)
    k.add_edge(1, 2, 3)
    k.add_edge(1, 3, 8)
    k.add_edge(1, 4, 5)
    k.add_edge(2, 4, 7)
    k.kruskal()

运行上述程序，输出结果如下：

Prim算法求解最小生成树：
节点1的父节点是0
节点2的父节点是1
节点3的父节点是0
节点4的父节点是1
Kruskal算法求解最小生成树：
节点1的父节点是0
节点2的父节点是1
节点3的父节点是0
节点4的父节点是1