文心一言 VS 讯飞星火 VS chatgpt （297）-- 算法导论22.1 1题

最新推荐文章于 2025-08-09 20:08:31 发布

原创

最新推荐文章于 2025-08-09 20:08:31 发布 · 9.4k 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #文心一言 #chatgpt

一、给定有向图的邻接链表，需要多长时间才能计算出每个结点的出度(发出的边的条数)？多长时间才能计算出每个结点的入度(进入的边的条数)？如果要写代码，请用go语言。

文心一言：

计算出度

对于有向图的邻接链表表示，每个节点通常存储为一个结构体，其中包含一个指向其所有邻接节点的链表的指针（或切片）。计算每个节点的出度非常简单，因为出度直接对应于该节点指向的邻接链表（或切片）的长度。

时间复杂度：O(V + E)，其中V是节点数，E是边数。虽然这个复杂度看起来似乎与边的数量有关，但在实际计算过程中，我们只需遍历每个节点及其邻接链表一次，因此总体上是线性的，因为每个节点和每条边都被访问一次。

Go代码示例：

package main

import "fmt"

// 定义图的节点
type Node struct {
   
   
    ID   int
    Out  []*Node // 指向的节点列表，即出度
}

// 计算每个节点的出度
func calculateOutDegrees(nodes []*Node) map[int]int {
   
   
    outDegrees := make(map[int]int)
    for _, node := range nodes {
   
   
        outDegrees[node.ID] = len(node.Out)
    }
    return outDegrees
}

func main() {
   
   
    // 示例图
    nodes := []*Node{
   
   
        {
   
   ID: 1, Out: []*Node{
   
   {
   
   ID: 2}, {
   
   ID: 3}}},
        {
   
   ID: 2, Out: []*Node{
   
   {
   
   ID: 4}}},
        {
   
   ID: 3, Out: []*Node{
   
   }},
        {
   
   ID: 4, Out: []*Node{
   
   {
   
   ID: 1}}}, // 创建一个环
    }

    outDegrees := calculateOutDegrees(nodes)
    for id, degree := range outDegrees {
   
   
        fmt.Printf("Node %d has out-degree %d\n", id, degree)
    }
}

计算入度

计算入度稍微复杂一些，因为我们需要知道有多少条边指向了某个节点。在邻接链表表示中，这通常不是直接可用的信息。一种常见的方法是使用一个额外的数据结构（如map）来跟踪每个节点的入度。

时间复杂度：O(E)，因为我们需要遍历每条边一次来更新每个节点的入度。

Go代码示例：

package main

import "fmt"

// 假设Node定义与上面相同

// 计算每个节点的入度
func calculateInDegrees(nodes []*Node) map[int]int {
   
   
    inDegrees := make(map[int]int)
    for _, node := range nodes {
   
   
        for _, outNode := range node.Out {
   
   
            inDegrees[outNode.ID]++
        }
    }
    return inDegrees
}

func main() {
   
   
    // 使用与上面相同的nodes定义

    inDegrees := calculateInDegrees(nodes)
    for id, degree := range inDegrees {
   
   
        fmt.Printf("Node %d has in-degree %d\n", id, degree)
    }
}

在上面的calculateInDegrees函数中，我们遍历了每个节点的邻接链表，并对每个邻接节点的入度进行了加一操作。这样，在遍历完成后，我们就得到了每个节点的入度。

在这里插入图片描述

讯飞星火：

计算每个节点的出度和入度的复杂度都是O(V+E)，其中V是顶点的数量，E是边的数量。这是因为我们需要遍历所有的边来计算每个节点的出度和入度。

以下是使用Go语言编写的代码：

package main

import (
	"fmt"
)

type Graph struct {
   
   
	vertices int
	adjList  [][]int
}

func NewGraph(vertices int) *Graph {
   
   
	g := &Graph{
   
   
		vertices: vertices,
		adjList:  make([][]int, vertices),
	}
	return g
}

func (g *Graph) AddEdge(src, dest int) {
   
   
	g.adjList[src] = append(g.adjList[src], dest)
}

func (g *Graph) OutDegree() []int {
   
   
	outDegrees := make([]int, g.vertices)
	for src := 0; src < g.vertices; src++ {
   
   
		outDegrees[src] = len(g.adjList[src])
	}
	return outDegrees
}

func (g *Graph) InDegree() []int {
   
   
	inDegrees := make([]int, g.vertices)
	for src := 0; src < g