私の連絡先情報
郵便メール:
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
隣接リンクリスト表現では、各頂点は vvヴ リンク リストがあり、リンク リスト内の各ノードがスレーブを表します。 vvヴ スタートエッジ。計算するために うわーグT、横断する必要があります GGグ の各エッジに対して、エッジの方向を反転して、に追加します。 うわーグT 対応するリンクリストにあります。
Go言語の実装：
package main
import (
"fmt"
)
// Graph 使用邻接链表表示
type Graph struct {
vertices int
adjList map[int][]int
}
// NewGraph 创建一个新的图
func NewGraph(vertices int) *Graph {
return &Graph{
vertices: vertices,
adjList: make(map[int][]int),
}
}
// AddEdge 添加一条边到图中
func (g *Graph) AddEdge(u, v int) {
g.adjList[u] = append(g.adjList[u], v)
}
// Transpose 计算图的转置
func (g *Graph) Transpose() *Graph {
gT := NewGraph(g.vertices)
for u, adj := range g.adjList {
for _, v := range adj {
gT.AddEdge(v, u) // 反转边的方向
}
}
return gT
}
func main() {
g := NewGraph(4)
g.AddEdge(0, 1)
g.AddEdge(0, 2)
g.AddEdge(1, 2)
g.AddEdge(2, 0)
g.AddEdge(2, 3)
gT := g.Transpose()
fmt.Println("Original Graph:")
for u, adj := range g.adjList {
fmt.Printf("%d -> %vn", u, adj)
}
fmt.Println("nTransposed Graph:")
for u, adj := range gT.adjList {
fmt.Printf("%d -> %vn", u, adj)
}
}
時間の複雑さ：
隣接行列表現では、エッジ情報を格納するために 2 次元配列を使用します。 matrix[u][v] からの行があるかどうかを示します。 うぅあなた 到着 vvヴ 側。計算するために うわーグT、行列の上の三角形 (行列表現の習慣に応じて、下の三角形) をトラバースし、エッジの方向を反転します。 matrix[u][v] 値が割り当てられるのは、matrixT[v][u]。
Go言語の実装(簡易バージョン。存在のみを考慮し、エッジの重みは考慮しません):
// 假设使用二维布尔切片表示邻接矩阵
type GraphMatrix [][]bool
// Transpose 计算图的转置
func (g GraphMatrix) Transpose() GraphMatrix {
n := len(g)
gT := make(GraphMatrix, n)
for i := range gT {
gT[i] = make([]bool, n)
}
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
gT[j][i] = g[i][j] // 反转边的方向
}
}
return gT
}
// 注意：这里没有完整的GraphMatrix类型实现，因为示例仅关注Transpose函数
時間の複雑さ：
隣接リストによって表される有向グラフの場合、各頂点の隣接リストをトラバースすることによって、各頂点の隣接頂点を新しいグラフの転置された頂点の隣接リストに追加できます。具体的な手順は次のとおりです。
時間計算量分析: 元のグラフの各頂点を横断するには、 O ( ∣ V ∣ ) O(|V|)お(∣五∣) 各頂点の隣接リストを走査するのに必要な時間は次のとおりです。 O ( ∣ E ∣ ) O(|E|)お(∣え∣) したがって、合計時間計算量は次のようになります。 O ( ∣ V ∣ + ∣ E ∣ ) O(|V| + |E|)お(∣五∣+∣え∣)。
隣接行列で表される有向グラフの場合、元のグラフの隣接行列を転置することで新しいグラフの隣接行列を取得できます。具体的な手順は次のとおりです。
時間計算量分析: 元のグラフの隣接行列を走査するには、 O ( ∣ V ∣ 2 ) O(|V|^2)お(∣五∣2) したがって、合計時間計算量は次のようになります。 O ( ∣ V ∣ 2 ) O(|V|^2)お(∣五∣2)。
以下は Go 言語で実装されたコードです。
// 邻接链表表示的有向图转置
func transposeAdjList(G map[int][]int) map[int][]int {
GT := make(map[int][]int)
for v, neighbors := range G {
for _, u := range neighbors {
GT[u] = append(GT[u], v)
}
}
return GT
}
// 邻接矩阵表示的有向图转置
func transposeAdjMatrix(G [][]int) [][]int {
n := len(G)
GT := make([][]int, n)
for i := range GT {
GT[i] = make([]int, n)
}
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
GT[j][i] = G[i][j]
}
}
return GT
}
隣接リンクリスト表現では、元の画像を直接走査できます。 GGグ次に、各エッジの方向を反転した後、各ノードの隣接リストが新しいグラフに追加されます。 GTG^{T}グT対応するノード上で。
type Graph struct {
Vertices []*Node // 存储图中所有节点的指针
}
type Node struct {
Value int
Adjacent []*Node // 存储与该节点相邻的所有节点的指针
}
func (g *Graph) Transpose() *Graph {
transposed := &Graph{make([]*Node, len(g.Vertices))}
for i, node := range g.Vertices {
transposed.Vertices[i] = &Node{node.Value, make([]*Node, 0)}
}
for _, node := range g.Vertices {
for _, adj := range node.Adjacent {
// 将边反向添加到转置图中
transposed.Vertices[adj.Value].Adjacent = append(transposed.Vertices[adj.Value].Adjacent, transposed.Vertices[node.Value])
}
}
return transposed
}
したがって、合計時間計算量は次のようになります。 O ( ∣ V ∣ + ∣ E ∣ ) O(|V| + |E|)お(∣五∣+∣え∣)。
隣接行列表記では、新しい隣接行列を作成し、元の画像を走査することができます。 GGグ隣接行列、行列内の各要素 ( 私 、 j ) ( 私 、 j )(私,じゅう)新しいマトリックスに割り当てられる ( j , i ) ( j , i ) の(じゅう,私)位置を調整し、エッジの反転を完了します。
type MatrixGraph struct {
Matrix [][]bool // 存储邻接矩阵
}
func (mg *MatrixGraph) Transpose() *MatrixGraph {
transposed := &MatrixGraph{make([][]bool, len(mg.Matrix))}
for i := range mg.Matrix {
transposed.Matrix[i] = make([]bool, len(mg.Matrix))
for j := range mg.Matrix[i] {
// 将边反向赋值到转置矩阵中
transposed.Matrix[i][j] = mg.Matrix[j][i]
}
}
return transposed
}
したがって、合計時間計算量は次のようになります。 O ( ∣ V ∣ 2 ) O(|V|^2)お(∣五∣2)。
隣接リンク リスト表現の場合、転置アルゴリズムの時間計算量は次のようになります。 O ( ∣ V ∣ + ∣ E ∣ ) O(|V| + |E|)お(∣五∣+∣え∣)、隣接行列表現の場合、転置アルゴリズムの時間計算量は次のようになります。 O ( ∣ V ∣ 2 ) O(|V|^2)お(∣五∣2) 。実際のアプリケーションでは、グラフが比較的まばらな場合 (つまり、 ∣ Ｅ ∣ |Ｅ|∣え∣よりもはるかに小さい ∣ V ∣ 2 |V|^2∣五∣2 )、隣接リンク リスト表現を使用する方が効率的です。グラフが密な場合 (つまり、 ∣ Ｅ ∣ |Ｅ|∣え∣近く ∣ V ∣ 2 |V|^2∣五∣2) の場合、隣接行列表現の方が適切である可能性があります。
グラフ表現では、隣接リンク リストと隣接行列の両方が一般的に使用される方法です。隣接リンク リストは無向グラフと有向グラフを表すために使用されますが、隣接行列は通常、無向グラフを表すために使用されます。有向グラフの転置では、隣接リンク リストと隣接行列を個別に操作できます。
隣接リンクリストによって表される有向グラフの場合、グラフの転置は、元のグラフの各頂点をトラバースし、元のグラフの出力エッジを入力エッジに変更することによって実現できます。
package main
import (
"fmt"
)
// 定义图的顶点结构
type Vertex struct {
Name string
Edges []*Vertex
Visited bool
}
// 计算图的转置
func Transpose(g *Vertex) {
for _, v := range g.Edges {
// 遍历顶点v的所有出边
for _, w := range v.Edges {
// 在原图中查找顶点w指向顶点v的边，并反转
for i, e := range w.Edges {
if e == v {
w.Edges[i] = v
break
}
}
}
}
}
func main() {
// 创建顶点
a := &Vertex{Name: "A"}
b := &Vertex{Name: "B"}
c := &Vertex{Name: "C"}
// 建立有向图关系
a.Edges = []*Vertex{b, c}
b.Edges = []*Vertex{a}
c.Edges = []*Vertex{a}
// 打印原图
fmt.Println("原图：")
PrintGraph(a)
// 计算转置图
Transpose(a)
// 打印转置图
fmt.Println("转置图：")
PrintGraph(a)
}
// PrintGraph 用于打印图的邻接链表表示
func PrintGraph(g *Vertex) {
g.Visited = true
for _, v := range g.Edges {
if !v.Visited {
fmt.Println(g.Name, "->", v.Name)
PrintGraph(v)
}
}
}
隣接行列で表される有向グラフの場合、元のグラフの各行を新しいグラフの対応する列に変換することで、グラフの転置を実現できます。
package main
import (
"fmt"
)
// 计算邻接矩阵的转置
func TransposeMatrix(mat [][]int) [][]int {
transposed := make([][]int, len(mat[0]))
for i := range transposed {
transposed[i] = make([]int, len(mat))
}
for i, row := range mat {
for j, val := range row {
if val == 1 {
transposed[j][i] = 1
}
}
}
return transposed
}
func main() {
// 创建邻接矩阵
originalMatrix := [][]int{
{0, 1, 1},
{0, 0, 1},
{1, 0, 0},
}
// 计算转置矩阵
transposedMatrix := TransposeMatrix(originalMatrix)
// 打印转置矩阵
fmt.Println("转置矩阵：")
for _, row := range transposedMatrix {
fmt.Println(row)
}
}
隣接リンク リストの転置の場合、アルゴリズムの時間計算量は O(E) です。ここで、E はグラフ内のエッジの数です。これは、各エッジを 1 回横断する必要があるためです。
隣接行列の転置の場合、アルゴリズムの時間計算量は O(V^2) です。ここで、V はグラフ内の頂点の数です。これは、各行列要素を 1 回走査する必要があり、行列のサイズが V×V であるためです。
これらのアルゴリズムはすべて効率的で実行されます。
有向グラフを計算するアルゴリズムを実装するには GGグ の転置 GTG^{T}グT 、隣接リンク リストと隣接行列の 2 つの表現をそれぞれ処理できます。以下では、これら 2 つの場合のアルゴリズムをそれぞれ説明し、Go 言語でのコード例を示します。
newAdjList 転置されたグラフを保存するために使用されます。adjList。(u, v)に追加します newAdjList[v] 真ん中。newAdjList。type Graph struct {
vertices []*Vertex
}
type Vertex struct {
key int
adjacent []*Vertex
}
func (g *Graph) Transpose() *Graph {
gt := &Graph{make([]*Vertex, len(g.vertices))}
for i := range g.vertices {
gt.vertices[i] = &Vertex{key: i}
}
for _, u := range g.vertices {
for _, v := range u.adjacent {
// Add edge (v, u) to the transpose graph.
gt.vertices[v.key].adjacent = append(gt.vertices[v.key].adjacent, gt.vertices[u.key])
}
}
return gt
}
このアルゴリズムの実行時間は O(|V| + |E|) です。ここで、|V| は頂点の数、|E| はエッジの数です。これは、すべての頂点とエッジを一度走査する必要があるためです。
newAdjMatrix 転置されたグラフを保存するために使用されます。adjMatrix。adjMatrix[i][j]に割り当てます newAdjMatrix[j][i]。newAdjMatrix。type Graph struct {
matrix [][]bool
}
func (g *Graph) Transpose() *Graph {
gt := &Graph{make([][]bool, len(g.matrix))}
for i := range gt.matrix {
gt.matrix[i] = make([]bool, len(g.matrix))
}
for i := range g.matrix {
for j := range g.matrix[i] {
// Copy the adjacency values with swapped indices.
gt.matrix[j][i] = g.matrix[i][j]
}
}
return gt
}
このアルゴリズムの実行時間は O(|V|^2) です。ここで、|V| は頂点の数です。これは、隣接行列全体を走査する必要があり、隣接行列のサイズが |V| x |V| であるためです。
上記のコード例はアルゴリズムのコア部分にすぎません。実際のアプリケーションでは、エラー処理、入出力などの他の機能を追加する必要がある場合があります。また、コードを簡略化するために、グラフ内に繰り返しエッジはなく、頂点番号は 0 から始まる連続した番号が付けられていると仮定します。
以下は、グラフ G から G^T を計算するために Go 言語で書かれたアルゴリズムであり、対応する隣接リンク リストと隣接行列の表現方法も示されています。
package main
import "fmt"
// 图的节点结构体
type Node struct {
Value int // 节点的值
Next *Node // 下一个节点指针
}
// 邻接链表表示法的图结构体
type Graph struct {
Vertices []*Node // 图中所有节点的数组
}
// 添加有向边到邻接链表
func (g *Graph) AddEdge(u, v int) {
newNode := &Node{Value: v}
if g.Vertices[u] == nil {
g.Vertices[u] = newNode
} else {
curr := g.Vertices[u]
for curr.Next != nil {
curr = curr.Next
}
curr.Next = newNode
}
}
// 输出邻接链表表示的图信息
func (g *Graph) Print() {
for i, node := range g.Vertices {
fmt.Printf("顶点 %d：", i)
for node != nil {
fmt.Printf("%d ", node.Value)
node = node.Next
}
fmt.Println()
}
}
// 获取图 G 的转置图 G^T 的邻接链表表示法
func GetTranspose(g *Graph) *Graph {
transpose := &Graph{
Vertices: make([]*Node, len(g.Vertices)),
}
for i, node := range g.Vertices {
for node != nil {
v := node.Value
// 在转置图中添加反向边
transpose.AddEdge(v, i)
node = node.Next
}
}
return transpose
}
// 输出邻接链表表示的转置图信息
func PrintTranspose(g *Graph) {
fmt.Println("转置图 G^T：")
g.Print()
}
// 邻接矩阵表示法的图结构体
type Matrix struct {
Vertices [][]int // 邻接矩阵，存储边的连接关系（0 表示无边，1 表示有边）
}
// 初始化邻接矩阵表示的图
func InitMatrix(numVertices int) *Matrix {
matrix := &Matrix{
Vertices: make([][]int, numVertices),
}
for i := range matrix.Vertices {
matrix.Vertices[i] = make([]int, numVertices)
}
return matrix
}
// 添加有向边到邻接矩阵
func (m *Matrix) AddEdge(u, v int) {
m.Vertices[u][v] = 1
}
// 获取图 G 的转置图 G^T 的邻接矩阵表示法
func GetTransposeMatrix(m *Matrix) *Matrix {
numRows := len(m.Vertices)
numCols := len(m.Vertices[0])
transpose := InitMatrix(numRows)
for i := 0; i < numRows; i++ {
for j := 0; j < numCols; j++ {
if m.Vertices[i][j] == 1 {
// 在转置矩阵中添加反向边
transpose.AddEdge(j, i)
}
}
}
return transpose
}
// 输出邻接矩阵表示的转置图信息
func PrintTransposeMatrix(m *Matrix) {
numRows := len(m.Vertices)
numCols := len(m.Vertices[0])
fmt.Println("转置图 G^T：")
for i := 0; i < numRows; i++ {
fmt.Printf("顶点 %d：", i)
for j := 0; j < numCols; j++ {
if m.Vertices[i][j] == 1 {
fmt.Printf("%d ", j)
}
}
fmt.Println()
}
}
func main() {
// 邻接链表表示的有向图 G
g := &Graph{
Vertices: make([]*Node, 4),
}
g.AddEdge(0, 1)
g.AddEdge(1, 2)
g.AddEdge(2, 3)
g.AddEdge(3, 1)
// 输出原始图 G 的邻接链表表示法
fmt.Println("原始图 G：")
g.Print()
// 获取转置图 G^T 的邻接链表表示法并输出
transpose := GetTranspose(g)
PrintTranspose(transpose)
// 邻接矩阵表示的有向图 G
m := InitMatrix(4)
m.AddEdge(0, 1)
m.AddEdge(1, 2)
m.AddEdge(2, 3)
m.AddEdge(3, 1)
// 输出原始图 G 的邻接矩阵表示法
fmt.Println("原始图 G：")
for _, row := range m.Vertices {
fmt.Println(row)
}
// 获取转置图 G^T 的邻接矩阵表示法并输出
transposeMatrix := GetTransposeMatrix(m)
PrintTransposeMatrix(transposeMatrix)
}
このアルゴリズムの時間計算量は O(V + E) です。ここで、V は頂点の数、E はエッジの数です。転置グラフの構築プロセスでは、元のグラフのすべてのエッジをたどり、それらを転置グラフに逆に追加する必要があるため、合計の時間の複雑さは頂点とエッジの数に比例します。
有向グラフの転置グラフは、隣接リンク リストと隣接行列という 2 つの主要なデータ構造で表すことができます。以下では、これら 2 つの場合のアルゴリズムをそれぞれ紹介し、Go 言語のサンプルコードを提供します。
隣接リンク リストで表されるグラフの場合、各頂点の隣接リストを走査し、各隣接点に逆エッジを追加することで、グラフを転置できます。この方法の時間計算量は O(V + E) です。ここで、V は頂点の数、E はエッジの数です。
type Vertex struct {
Value int
Adj []Vertex
}
func transposeGraph(graph []Vertex) []Vertex {
transposed := make([]Vertex, len(graph))
for _, v := range graph {
for _, adjV := range v.Adj {
// 为邻接点添加反向边
found := false
for _, tV := range transposed[adjV.Value].Adj {
if tV.Value == v.Value {
found = true
break
}
}
if !found {
transposed[adjV.Value].Adj = append(transposed[adjV.Value].Adj, v)
}
}
}
return transposed
}
隣接行列で表されるグラフの場合、行列の行と列を交換することで転置を実装できます。この方法の時間計算量は O(V^2) です。
func transposeMatrix(matrix [][]int) [][]int {
n := len(matrix)
transposed := make([][]int, n)
for i := 0; i < n; i++ {
transposed[i] = make([]int, n)
for j := 0; j < n; j++ {
transposed[i][j] = matrix[j][i]
}
}
return transposed
}
実際のアプリケーションでは、どのアルゴリズムを選択するかは、グラフのスパース性と利用可能なメモリによって決まります。疎なグラフの場合は、隣接リンク リストの方がメモリ効率が高く、密なグラフの場合は、隣接行列の方が効率的である可能性があります。
有向グラフを計算するには G = ( V , E ) G = ( V , E )グ=(五,え) の転置 GT = ( V 、 ET ) G^T = ( V 、 E^T )グT=(五,えT), 隣接リンク リストと隣接行列の 2 つの表現方法にそれぞれ対応するアルゴリズムを与え、その実行時間を分析できます。
type Edge struct {
dest int
}
type AdjacencyList struct {
edges map[int][]Edge
}
func TransposeGraph(graph AdjacencyList) AdjacencyList {
transposed := AdjacencyList{edges: make(map[int][]Edge)}
for u, neighbors := range graph.edges {
for _, edge := range neighbors {
v := edge.dest
transposed.edges[v] = append(transposed.edges[v], Edge{dest: u})
}
}
return transposed
}
func main() {
// 示例图的邻接链表表示
graph := AdjacencyList{edges: map[int][]Edge{
0: {{dest: 1}},
1: {{dest: 2}},
2: {{dest: 0}},
}}
// 计算转置图
transposedGraph := TransposeGraph(graph)
// 打印转置图的邻接链表
for u, neighbors := range transposedGraph.edges {
fmt.Printf("Node %d -> Nodes: ", u)
for _, edge := range neighbors {
fmt.Printf("%d ", edge.dest)
}
fmt.Println()
}
}
このコードでは、 Edge エッジを表す構造と、AdjacencyList 隣接リンクリストを表す構造。TransposeGraph この関数は、AdjacencyList type パラメータを使用して、転置されたグラフの隣接リンク リスト表現を返します。存在するmain 関数を使用して、グラフの例を作成し、その転置グラフを計算して印刷します。
彼は 30 年以上テクノロジーの研究に専念しており、java、linux、javascript、php、css などのさまざまな言語に堪能であり、オープンソース分野で多くの貢献を行っています。将来の参考のために技術開発におけるいくつかの問題を共有する開発者ドキュメント ステーション。
郵便メール: