2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Viereisyyteen linkitetyssä listaesityksessä jokainen kärkipiste vvv On linkitetty luettelo, ja jokainen linkitetyn luettelon solmu edustaa orjaa vvv Aloitusreuna.laskeakseen GTG^TGT, meidän täytyy kulkea GGG Lisää jokaiselle reunalle , ja käännä reunan suunta GTG^TGT vastaavassa linkitetyssä luettelossa.
Siirry kielen käyttöön：
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)
}
}
aika monimutkaisuus：
Viereisyysmatriisiesituksessa käytämme kaksiulotteista taulukkoa tallentamaan reunainformaatiota, missä matrix[u][v] Osoittaa, onko linja alkaen uuu saapua vvv puolella.laskeakseen GTG^TGT, kuljemme matriisin ylemmän kolmion (tai alemman kolmion, riippuen matriisin esitystavoistasi) poikki ja käännämme reunojen suunnan, eli matrix[u][v] Arvo on määritettymatrixT[v][u]。
Siirry kielen käyttöön(Yksinkertaistettu versio, ottaa huomioon vain olemassaolon, ei huomioi reunapainoja):
// 假设使用二维布尔切片表示邻接矩阵
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函数
aika monimutkaisuus：
Suunnatussa graafissa, jota edustaa viereisyysluettelo, voimme lisätä kunkin kärjen viereiset pisteet uuden graafin transponoidun kärjen viereisyysluetteloon kulkemalla kunkin kärjen vierekkäisyysluettelon läpi. Tarkat vaiheet ovat seuraavat:
Aikamonimutkaisuusanalyysi: alkuperäisen graafin jokaisen kärjen läpikäyminen vaatii O ( ∣ V ∣ ) O(|V|)O(∣V∣) Kunkin huippupisteen viereisyysluettelon kulkemiseen tarvittava aika on O ( ∣ E ∣ ) O(|E|)O(∣E∣) aika, joten kokonaisaika monimutkaisuus on O ( ∣ V ∣ + ∣ E ∣ ) O(|V| + |E|)O(∣V∣+∣E∣)。
Viereisyysmatriisin edustamalle suunnatulle graafille voimme saada uuden graafin viereisyysmatriisin transponoimalla alkuperäisen graafin viereisyysmatriisi. Tarkat vaiheet ovat seuraavat:
Aikamonimutkaisuusanalyysi: alkuperäisen kaavion viereisyysmatriisin läpikulku vaatii O ( ∣ V ∣ 2 ) O(|V|^2)O(∣V∣2) aika, joten kokonaisaika monimutkaisuus on O ( ∣ V ∣ 2 ) O(|V|^2)O(∣V∣2)。
Seuraava on Go-kielellä toteutettu koodi:
// 邻接链表表示的有向图转置
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
}
Vierekkäisyyksiin linkitetyssä listaesityksessä voimme kulkea suoraan alkuperäisen kuvan läpi GGGKunkin solmun vierekkäisyysluettelo lisätään sitten uuteen kuvaajaan sen jälkeen, kun kunkin reunan suunta on käännetty. GTG^{T}GTvastaavassa solmussa.
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
}
Siksi kokonaisaika monimutkaisuus on O ( ∣ V ∣ + ∣ E ∣ ) O(|V| + |E|)O(∣V∣+∣E∣)。
Viereisyysmatriisin merkinnöissä voimme luoda uuden viereisyysmatriisin ja kulkea sitten alkuperäisen kuvan läpi GGGviereisyysmatriisi, jokainen matriisin elementti (i, j) (i, j)(i,j)uuteen matriisiin (j , i ) (j, i)(j,i)asemaan, jolloin reunan käännös on valmis.
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
}
Siksi kokonaisaika monimutkaisuus on O ( ∣ V ∣ 2 ) O(|V|^2)O(∣V∣2)。
Viereisyyteen linkitetyn listaesityksen osalta transponointialgoritmin aikamonimutkaisuus on O ( ∣ V ∣ + ∣ E ∣ ) O(|V| + |E|)O(∣V∣+∣E∣), ja viereisyysmatriisiesitystä varten transponointialgoritmin aikamonimutkaisuus on O ( ∣ V ∣ 2 ) O(|V|^2)O(∣V∣2) .Käytännön sovelluksissa, jos graafi on suhteellisen harva (esim. ∣ E ∣ |E|∣E∣paljon pienempi kuin ∣ V ∣ 2 |V|^2∣V∣2 ), olisi tehokkaampaa käyttää viereisyyteen linkitettyä listaesitystä.Jos kuvaaja on tiheä (esim. ∣ E ∣ |E|∣E∣lähellä ∣ V ∣ 2 |V|^2∣V∣2), niin viereisyysmatriisiesitys voi olla sopivampi.
Graafiesityksessä viereisyyteen linkitetyt listat ja viereisyysmatriisit ovat molemmat yleisesti käytettyjä menetelmiä. Vierekkäisyyksiin linkitettyjä listoja käytetään edustamaan suuntaamattomia ja suunnattuja graafisia, kun taas vierekkäisyysmatriiseja käytetään yleensä edustamaan suuntaamattomia graafisia. Suunnatun graafin transponoimiseksi voimme käyttää viereisyyslinkitettyä listaa ja viereisyysmatriisia erikseen.
Suunnatussa graafissa, jota edustaa vierekkäisyyksiin linkitetty lista, graafin transponointi voidaan saavuttaa kulkemalla alkuperäisen graafin kunkin kärjen poikki ja muokkaamalla alkuperäisen graafin lähtevät reunat sisääntuleviksi reunoksi.
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)
}
}
}
Viereisyysmatriisin edustaman suunnatun graafin tapauksessa graafin transponointi voidaan saavuttaa kääntämällä jokainen alkuperäisen graafin rivi uuden graafin vastaavaksi sarakkeeksi.
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)
}
}
Vierekkäisyyksiin linkitetyn listan transponointia varten algoritmin aikamonimutkaisuus on O(E), missä E on graafin reunojen lukumäärä. Tämä johtuu siitä, että jokainen reuna on ajettava kerran.
Viereisyysmatriisin transponoimiseksi algoritmin aikamonimutkaisuus on O(V^2), missä V on graafin kärkien lukumäärä. Tämä johtuu siitä, että jokainen matriisielementti on ajettava kerran ja matriisin koko on V×V.
Nämä algoritmit ovat kaikki tehokkaita ja ajettavia
Toteuttaa algoritmi suunnatun graafin laskemiseksi GGG siirtäminen osaksi kansallista lainsäädäntöä GTG^{T}GT , voimme käsitellä vierekkäisyyksiin linkitetyn listan ja viereisyysmatriisin kaksi esitystä. Alla kuvailen näiden kahden tapauksen algoritmeja ja annan koodiesimerkkejä Go-kielellä.
newAdjList Käytetään transponoidun graafin tallentamiseen.adjList。(u, v), lisää se joukkoon newAdjList[v] keskellä.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
}
Tämän algoritmin ajoaika on O(|V| + |E|), jossa |V| on kärkien lukumäärä ja |E|. Tämä johtuu siitä, että meidän täytyy kulkea kaikki kärjet ja reunat kerran.
newAdjMatrix Käytetään transponoidun graafin tallentamiseen.adjMatrix。adjMatrix[i][j], määritä se 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
}
Tämän algoritmin ajoaika on O(|V|^2), jossa |V| on pisteiden lukumäärä. Tämä johtuu siitä, että meidän täytyy kulkea koko viereisyysmatriisin läpi ja vierekkäisyysmatriisin koko on|V| x |V|.
Yllä oleva koodiesimerkki on vain algoritmin ydinosa Varsinaisissa sovelluksissa saattaa olla tarpeen lisätä muita toimintoja, kuten virheiden käsittelyä, syöttöä ja tulostusta. Lisäksi koodin yksinkertaistamiseksi oletetaan, että graafissa ei ole toistuvia reunoja ja pistenumerot numeroidaan peräkkäin 0:sta alkaen.
Seuraavassa on Go-kielellä kirjoitettu algoritmi G^T:n laskemiseksi graafista G, ja myös vastaavat vierekkäisyydet linkitetty lista ja viereisyysmatriisiesitystavat on annettu:
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)
}
Tämän algoritmin aikamonimutkaisuus on O(V + E), missä V on kärkien lukumäärä ja E on reunojen lukumäärä. Transponoidun graafin konstruointi edellyttää alkuperäisen graafin kaikkien reunojen läpikulkua ja niiden lisäämistä transponoituun graafiin käänteisesti, joten kokonaisaikamonimutkaisuus on verrannollinen kärkien ja reunojen lukumäärään.
Suunnattujen graafien transponoidut graafit voidaan esittää kahdella päätietorakenteella: viereisyyteen linkitetyillä listoilla ja viereisyysmatriiseilla. Alla esittelen algoritmit näissä kahdessa tapauksessa ja toimitan esimerkkikoodin Go-kielellä.
Graafille, jota edustaa vierekkäisyyksiin linkitetty luettelo, voimme transponoida graafin kulkemalla kunkin kärjen vierekkäisyysluettelon läpi ja lisäämällä sitten käänteisreunan jokaiseen viereisyyspisteeseen. Tämän menetelmän aikamonimutkaisuus on O(V + E), jossa V on kärkien lukumäärä ja E on reunojen lukumäärä.
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
}
Viereisyysmatriisin edustaman graafin tapauksessa voimme toteuttaa transponoinnin vaihtamalla matriisin rivejä ja sarakkeita. Tämän menetelmän aikamonimutkaisuus on 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
}
Käytännön sovelluksissa valitaan algoritmi riippuu graafin harvaksesta ja käytettävissä olevasta muistista. Harvassa graafissa vierekkäisyyteen linkitetyt listat voivat olla muistitehokkaampia tiheissä kaavioissa, viereisyysmatriisit voivat olla tehokkaampia.
Suunnatun graafin laskeminen G = ( V , E ) G= (V, E)G=(V,E) siirtäminen osaksi kansallista lainsäädäntöä GT = ( V , ET ) G^T=(V,E^T)GT=(V,ET), voimme antaa vastaavat algoritmit vierekkäisyyksiin linkitetyn listan ja viereisyysmatriisin kahdelle esitysmenetelmälle ja analysoida niiden ajoaikaa.
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()
}
}
Tässä koodissa määrittelemme a Edge rakenne edustamaan reunoja, ja aAdjacencyList Rakenne, joka edustaa vierekkäisyyteen linkitettyä luetteloa.TransposeGraph Funktio hyväksyy aAdjacencyList type-parametrin ja palauttaa transponoidun graafin viereisyyteen linkitetyn luetteloesityksen.olla olemassamain -funktion avulla luomme esimerkkikaavion, laskemme ja tulostamme sen transponoidun kaavion.
Hän on omistautunut teknologian tutkimukselle yli 30 vuoden ajan ja hallitsee useita kieliä, kuten java, linux, javascript, php, css jne. Hän on tehnyt paljon työtä avoimen lähdekoodin tässä Kehittäjän dokumentaatioasema jakaaksesi teknologian kehittämisen ongelman tulevaa käyttöä varten
