利用Go实现一个简易DAG服务的示例代码

package main

import (
	"fmt"
	"errors"
)

type Node struct {
	Key   string
	Edges map[string]*Node // 相邻节点
}

type DAG struct {
	Nodes map[string]*Node
}

func NewDAG() *DAG {
	return &DAG{
		Nodes: make(map[string]*Node),
	}
}

func NewNode(key string) *Node {
	return &Node{
		Key:   key,
		Edges: make(map[string]*Node),
	}
}

func (dag *DAG) AddNode(node *Node) {
	dag.Nodes[node.Key] = node
}

func (dag *DAG) AddEdge(from, to string) error {
	fromNode, fromExists := dag.Nodes[from]
	toNode, toExists := dag.Nodes[to]

	if !fromExists || !toExists {
		return errors.New("both nodes must exist")
	}

	// 先假设边已经添加，用于环检测
	fromNode.Edges[to] = toNode

	if dag.hasCycle() {
		delete(fromNode.Edges, to) // 如果检测到环，则撤销添加边的操作
		return errors.New("adding this edge would create a cycle")
	}

	return nil
}

// 使用深度优先搜索（DFS）检查是否存在环

func (dag *DAG) hasCycle() bool {
	visited := make(map[string]bool)
	recStack := make(map[string]bool)

	for nodeKey := range dag.Nodes {
		if dag.isCyclicUtil(nodeKey, visited, recStack) {
			return true
		}
	}
	return false
}

func (dag *DAG) isCyclicUtil(nodeKey string, visited, recStack map[string]bool) bool {
	if recStack[nodeKey] {
		return true
	}

	if visited[nodeKey] {
		return false
	}

	visited[nodeKey] = true
	recStack[nodeKey] = true

	node := dag.Nodes[nodeKey]
	for _, adjNode := range node.Edges {
		if dag.isCyclicUtil(adjNode.Key, visited, recStack) {
			return true
		}
	}

	recStack[nodeKey] = false
	return false
}

package main

import (
	"fmt"
)

func main() {
	// 创建一个新的DAG实例
	dag := NewDAG()

	// 创建节点
	nodeA := NewNode("A")
	nodeB := NewNode("B")
	nodeC := NewNode("C")
	nodeD := NewNode("D")

	// 向DAG中添加节点
	dag.AddNode(nodeA)
	dag.AddNode(nodeB)
	dag.AddNode(nodeC)
	dag.AddNode(nodeD)

	// 添加边
	err := dag.AddEdge("A", "B")
	if err != nil {
		fmt.Println("Failed to add edge A->B:", err)
	}
	err = dag.AddEdge("B", "C")
	if err != nil {
		fmt.Println("Failed to add edge B->C:", err)
	}
	err = dag.AddEdge("C", "D")
	if err != nil {
		fmt.Println("Failed to add edge C->D:", err)
	}

	// 尝试添加一个会造成环的边（D -> A）
	err = dag.AddEdge("D", "A")
	if err != nil {
		fmt.Println("Failed to add edge D->A:", err)
	} else {
		fmt.Println("Edge D->A added successfully")
	}

	// 输出结果，验证环检测
	fmt.Println("DAG construction completed without cycles.")
}