Compilación del código fuente de Zstack
{
Imagen inicial (G);
scanf("%d ", & amp cinco); & lt0) devuelve un error; //El número de vértices no puede ser negativo.
g . vex num = v;
scanf("%d ", & ampa); / El número de aristas no puede ser negativo
g . arc num = a;
for(m = 0; m & ltfive; m++)
Número de vértices [m ]. data = getchar(); //Ingrese el símbolo de cada vértice.
for(m = 1; m & lt= a; m++)
{
t = getchar(); h = getchar(); t es la cola del arco y h es la cabeza del arco.
if((i=LocateVex(G, t))<0) devuelve un error;
if((j=LocateVex(G,h))<0 ) Error de retorno; //Vértice no encontrado
p =(ArcNode *)malloc(sizeof(ArcNode));
if (!Vertex[i].firstarc) G. vertices[ i]. primer arco = p;
Otro
{
for(q=G.vertices[i].firstarcq->; nextarcq = q-& gt; siguiente arco);
q->; siguiente arco = p;
}
p->; NULL
}//Cuando
Regresar OK;
}//Build_AdjList
7.15
// El gráfico G en este problema es un gráfico dirigido no ponderado y el resto es fácil de escribir a partir de él.
Estado insertion_Vex(management graph & ampG, char v)//Inserte el vértice V en el gráfico G representado por la matriz de adyacencia.
{
if(G.vexnum+1)>MAX_VERTEX_NUM devuelve no factible;
g . vexs[++ g num vex]= v;
Regresar OK;
}//INSERT_VEX
STATUS INSERT_ARC(MANAGEMENT Graph & ampG, char v, char w) // En adyacencia Insertar borde (v , w) en el gráfico G representado por la matriz.
{
if((i=LocateVex(G, v))<0) devuelve un error;
if((j=LocateVex(G , w))<0) devuelve un error;
if(i==j) devuelve un error;
if (!G.arcs[i][j]. adj )
{
G.arcs[i][j]. adj = 1;
g . arcnum++;
}
Regresar OK;
}//Insert_arc
Eliminación de estado_Vex (gráfico de gestión y ampG, char v) // Elimina el vértice V en el gráfico G representado por la matriz de adyacencia.
{
n = G.vexnum
if((m=LocateVex(G, v))<0) devuelve error;
g . vexs[m]<->Vexs[n];// Cambia el vértice que se eliminará al último vértice.
for(I = 0;i<n;i++)
{
g . arcos[I][m]= g arcos[I] [n. ];
g . arcs[m][I]= g . arcs[n][I] // Intercambia la relación de los bordes en consecuencia.
}
G.arcs[m][m]. adj = 0;
g . vex num-;
Regresar OK;
}//Delete_Vex
Análisis: si no, cuándo el vértice que se va a eliminar se cambia al último vértice, el algoritmo será más complejo y, a medida que se mueve una gran cantidad de elementos, la complejidad del tiempo aumentará considerablemente.
Estado delete_Arc(management graph & ampG, char v, char w) //Elimina el borde (v, w) en el gráfico G representado por la matriz de adyacencia.
{
if((i=LocateVex(G, v))<0) devuelve un error;
if((j=LocateVex(G , w))<0) Error de retorno;
if(G.arcs[i][j].adj)
{
G. [yo][j]. adj = 0;
g . arcnum-;
}
Regresar OK;
}//Delete_Arc
7.16
// Para ahorrar espacio, esta pregunta solo proporciona el algoritmo Insert_Arc. Escriba otros algoritmos usted mismo.
State Insert_Arc(ALGraph & G, char v, char w)//Inserte el borde (v, w) en el gráfico G representado por la lista de adyacencia.
{
if((i=LocateVex(G, v))<0) devuelve un error;
if((j=LocateVex(G , w))<0) Error de retorno;
p = (ArcNode *)malloc(sizeof(ArcNode));
p->adj vex = j;p -> nextarc = NULL
if (! vértices[i]. firstarc) G.vértices[i]. primer arco = p;
Otro
{
for(q=G.vertices[i].firstarcq->;q->;nextarcq = q ->nextarc)
Error de retorno si (q->adjvex==j); //el borde ya existe
q->next arc = p;
p >}
g . arcnum++;
Regresar OK;
}//Insert_arc
7.17
// Para ahorrar espacio, esta pregunta solo proporciona un algoritmo Delete_Vex más complejo. Escriba el resto del algoritmo usted mismo.
Eliminación de estado_ Vex(ol graph & G, char v)//Elimina el vértice V en el gráfico G representado por la lista entrecruzada.
{
if((m=LocateVex(G, v))<0) devuelve error;
n = G.vexnum
for(I = 0;I<n;I++) //Eliminar todos los bordes que comienzan con V.
{
if(G.xlist[i].first in-& gt; Tailvex==m) //Si el borde a eliminar es el primero en la cabeza nodo de cadena.
{
q=G.xlist[i]. primero en
G.xlist[i].
primero en = q->hlink
free(q);g.arcnum-;
}
else //else
{
para(p=G.xlist[i]). primero en Procter & Gamble. &p->hlink->Tyvix! = m;p = p->hlink);
if (p)
{
q = p->;hlink
p->hlink = q->hlink
free(q);g.arcnum-;
}
}// De lo contrario
}//for
for(I = 0;i<n;I++) //Elimina todos los bordes que terminan en v.
{
if(G.xlist[i].First out-& gt; Headvex==m) //Si el borde a eliminar es el primero en la cola nodo de cadena.
{
q=G.xlist[i]. Primero en salir;
G.xlist[i]. primero en salir = q->tlink
free(q);g.arcnum-;
}
else //else
{
para(p=G.xlist[i]). Primero en salir; & ampp->tlink->Hydwicks! = m;p = p->tlink);
if (p)
{
q = p->;tlink
p->tlink = q->tlink
free(q);g.arcnum-;
}
}// De lo contrario
}//for
for(I = m;I<n;I++) //Reemplace el vértice anterior con el vértice después del nodo M en orden.
{
g . xlist[I]= g . xlist[I+1] //Modificar el vector de encabezado
for(p=G. listax[i]). firstinp;p = p->hlink)
p->head vex-;
for(p=G.xlist[i]). first out;p;p = p->tlink)
p->tail vex- //Modifica el número de vértices en cada cadena.
}
g . vex num-;
Regresar OK;
}//Delete_Vex
7.18
//Para ahorrar espacio, esta pregunta solo proporciona el algoritmo Delete_Arc. Escriba otros algoritmos usted mismo.
Deleción de estado_ Arc(AML graph & G, char v, char w) /// Elimina los bordes (v, w) en el gráfico G representado por múltiples tablas adyacentes.
{
if((i=LocateVex(G, v))<0) devuelve un error;
if((j=LocateVex(G , w))<0) Error de retorno;
if(G.adjmulist[i].first edge->jvex==j)
G.adjmulist[i] . primeredge=G.adjmulist[i]. first edge-& gt;ilink
Otro
{
for(p=G.adjmulist[i].firstedge Procter & Gamble Company.
&p->ilink->jvex! = j;p = p-& gt;ilink);
si (!p) devuelve un error //no encontrado
p->;ilink = p-> ; ilink->;ilink
}//Eliminar el borde en la lista que vinculé.
if(G.adjmulist[j].first edge-& gt;ivex==i)
adjmulist[j]. primeredge=G.adjmulist[j]. primer borde-& gt;jlink
Otro
{
for(p=G.adjmulist[j].firstedge Procter & Gamble Company.&p-> ; jlink->avix! = i;p = p->jlink);
Si (!p) devuelve un error //no encontrado
q = p-; >jlink
p->jlink = q->jlink
free(q);
}//Eliminar I Un borde en una lista vinculada.
g . arcnum-;
Regresar OK;
}//Delete_Arc
7.19
Construcción estatal_ adj mulist (gráfico AML y G) // Ingrese el número de vértices, el número de aristas, la información de los vértices y la información de los bordes del gráfico dirigido para establecer una tabla de adyacencia múltiple.
{
InitAMLGraph(G);
scanf("%d ", & amp cinco
If (v &); lt0) devuelve un error; //El número de vértices no puede ser negativo.
g . vex num = v;
scanf(%d ", & ampa);
Si (a & lt0) devuelve error; // borde El número no puede ser negativo
g . arc num = a;
for(m = 0; m & ltfive; m++)
G.adjmulist[m ]. data = getchar(); //Ingrese el símbolo de cada vértice
for(m = 1; m & lt= a; m++)
{
t = getchar(); h = getchar(); //t es la cola del arco y h es la cabeza del arco
if((i=LocateVex(G, t))< 0 ) devuelve un error;
if((j=LocateVex(G, h))<0) devuelve un error; //Vértice no encontrado
p = (EBox * ) malloc(tamañode(EBox));
p->;ivex = I;p->;jvex = j;
p->;ilink = NULLp->;jlink = NULL //Al nodo de borde se le asigna un valor inicial
If (!G.adjmulist[i].G.adjmulist[i].first edge = p;
Otro
{
q=G.adjmulist[i]. primeredge
mientras(q)
{
r = q ;
if (q->;ivex = = I)q = q-& gt;ilink
si no q = q-& gt;jlink
}
if(r-& gt;ivex = = I)r->ilink = p;//Tenga en cuenta que el valor I puede aparecer en el dominio ivex del nodo de borde,
else r->jlink = p; //Puede aparecer en el dominio jvex de un nodo de borde.
}//else //Insertar al final de la lista enlazada
If (!adjmulist[j].adjmulist[j].first edge = p;
Otro
{
q=G.adjmulist[i]. primeredge
mientras(q)
{<. /p>
r = q;
if (q->; jvex = = j)q = q-& gt; ;ilnk
}
if(r-& gt;jvex = = j)r-& gt;jlink = p;
else r-& gt ; ilink = p;
}//else //Insertar al final de la lista enlazada J
}//para
Regresar OK;
p>}//Build_AdjList
7.20
Int Pass_MGraph(MGraph G)//Determine si se pasa el gráfico dirigido almacenado en la matriz de adyacencia, si es así, devuelve 1; de lo contrario, devuelve 0.
{
for(x = 0; ltg .wicksnum;y++)
if(G.arcs[x][ y])
{
for(z = 0; z<g.wixnum;z++)
if(z!= ]) Devuelve 0 //Condición para que el gráfico no sea transitivo
}//If
Return 1;
}//Pass_MGraph
Análisis: la complejidad del tiempo de este algoritmo es aproximadamente O (n 2 * d)
7.21
int pass _ alg graph(alg graph g)// Juzgue la lista de adyacencia si el gráfico dirigido almacenado es. transitivo, devuelve 1 si es así; en caso contrario, devuelve 0.
{
for(x = 0; x++)
for(p=G.vertices[x ]). vértices[y]). firstarcq;q = q->nextarc)
{
z = q->adjvex
if (z!= x & amp& ! is_adj( G, x, z)) devuelve 0;
}//para
}//para
}//pass_algebra
Intis _ adj (Algraphg, int m, int n) // Determina si hay un borde (m, n) en el gráfico dirigido G. Si es así, devuelve 1; de lo contrario, devuelve 0.
{
for(p=G.vertices[m]). firstarcp;p = p->nextarc)
Si (p->adjvex==n) devuelve 1;
devuelve 0;
} // is_adj
7.22
int visitado [MAXSIZE] // Indica si el vértice está en la ruta actual.
Intexist _ path _ DFS (Algraphg, int I, int J) // La profundidad primero determina si hay una ruta desde el vértice I al vértice J en el gráfico dirigido G. Si es así, devuelve 1, de lo contrario Devuelve 0.
{
if(i==j) devuelve 1; //i es j.
Otro
{
Visitado[I]= 1;
for(p=G.vertices[i].firstarcp ; p = p->nextarc)
{
k = p->adjvex
if (! visitó [k]& amp ;& ampexist_path( k, j)) devuelve 1; //El vértice aguas abajo de i tiene una ruta a j.
}//para
}//de lo contrario
}//la ruta DFS existe
7.23
Intexist _ path _ bfs (Algraphg, int I, int J) // La amplitud primero determina si hay una ruta desde el vértice I al vértice J en el gráfico dirigido G. Si es así, devuelve 1; de lo contrario, devuelve 0.
{
int ha accedido a [MAXSIZE];
init queue(Q);
EnQueue(Q, I);
Y (!QueueEmpty(Q))
{
Quitar de cola (Q, u);
Visitado [u]= 1;
for(p=G.vertices[i].firstarcp;p = p-& gt;nextarc)
{
k = p-& gt ; adjvex
if(k==j) devuelve 1;
if (!visited[k]) enqueue(Q,k);
}/ /for
}//Cuando
devuelve 0;
}//La ruta BFS existe
7.24
Recorrido vacío _No recursivo (gráfico g) //Recorrido no recursivo del gráfico g fuertemente conectado
{
int visitado [MAXSIZE];
InitStack
Push(S, GetVex(S, 1)); //Coloca el primer vértice en la pila.
Visitado (1);
Visitado = 1;
Y (! Parte superior de la pila)
{
while(Gettop(S,I)&&I)
{
j=FirstAdjVex(G,I);
If (j & amp& amp! Visitado[j])
{
Visitado(j);
Visitado[j]= 1;
Push(S, j);//Ir a la izquierda hasta el final
}
}//Cuando
Si (! Parte superior de la pila)
{
Pop(S, j);
Gettop(S, I);
k=NextAdjVex(G, I, j) //Mover un paso a la derecha
Si (k & amp& amp! Visitado [k])
{
Visitado (k);
Visitado[k]= 1;
Push(S, k);
}
}//Si
}/ /Cuando
}//Straverse _ unrecursive
Análisis: La idea básica de este algoritmo es la misma que el algoritmo transversal no recursivo a priori de un árbol binario, por favor consulte 6.37. Debido a que es un gráfico fuertemente conectado, se puede acceder a todos los nodos comenzando desde el primer nodo.
7.25
Vea las respuestas al final del libro.
7.26
Estado TopoNo(ALGraph G)//Reorganiza los vértices en el gráfico dirigido en el orden requerido por la pregunta.
{
int new[MAXSIZE], in gree[MAXSIZE] //Almacena el nuevo número de serie del nodo.
n = G.vexnum
FindInDegree(G, en grados);
InitStack
for(I = 1; i & ltg . vixnum;i++)
if (!ingree[i]) push(s,i); //los nodos de grado cero están apilados
count = 0;
Y (! Parte superior de la pila)
{
Pop(S, I);
new[I]= n-; el número de secuencia topológica inversa del nodo.
count++;
for(p=G.vertices[i].firstarcp;p = p-& gt;nextarc)
{
k = p->adjvex
If (!(- ingrado[k])) Push(S,k);
}//for
}//Cuando
if(count & lt; vexnum) devuelve un error //Hay un ciclo en el gráfico.
for(I = 1; i& lt= n; i++) printf("Número antiguo: %d Número nuevo: %d\n ", I, nuevo[i])
Return OK;
}//Tobono
Análisis: Siempre que los vértices estén numerados en orden topológico inverso, la matriz de adyacencia puede convertirse en una matriz triangular inferior.
7.27
int ha visitado [MAXSIZE];
Intexist _ path _ len (Algraphg, int i, int j, int k)//Juzga la adyacencia Si existe un camino simple de longitud k entre los vértices I a j del gráfico dirigido G almacenado en la tabla.
{
if(I = = j &&k==0) devuelve 1 //Encuentra una ruta cuya longitud cumpla con los requisitos.
si no(k & gt; 0)
{
Visita[I]= 1;
for(p= G .vertices[i].firstarcp;p = p->nextarc)
{
l = p->adjvex
if ( ! Visitado [ l])
if(exist_path_len(G, l, j, k-1)) devuelve 1; //La longitud de la ruta restante se reduce en uno
}// para
visited[I]= 0; //Este tema permite que los nodos visitados aparezcan en otra ruta.
}//De lo contrario
return 0; //no encontrado
}//la longitud de la ruta existe
7.28
int path[MAXSIZE], visitado[MAXSIZE] // Almacena temporalmente la ruta durante el proceso transversal.
Intfind_all_path (Algraphg, int u, int v, int k)// Encuentra todas las rutas simples entre los vértices u a v en el gráfico dirigido G, donde k representa la longitud de la ruta actual.
{
ruta[k]= u; //Agregar la ruta actual
Visitado[u]= 1;
Si (u==v) //Encuentra un camino simple.
{
printf("¡Encontré una ruta! \ n "
for(I = 0; ruta[I]; i++) printf(" %d ", ruta[I]); //Imprimir resultado
}
Otros
for(p=G.vertices[u]).
firstarcp;p = p->nextarc)
{
l = p->adjvex
if (!visited[l]) Find_All_Path(G , l, v, k+1); //Continuar buscando
}
visitado[u]= 0;
ruta[k] = 0 ; //Retroceder
}//Buscar todas las rutas
main()
{
...
Find_All_Path(G, u, v, 0); // La primera llamada en la función principal, el valor de k debe ser 0.
...
}//main
7.29
Intgetpathnum _ len (Algraphg, int I, int J, int len )//Encuentre el número de caminos simples con longitud Len entre los vértices I y J del gráfico dirigido G almacenado en la lista de adyacencia.
{
if(I = = j & amplen==0) return 1; //Encuentre una ruta con una longitud que cumpla con los requisitos.
else if(len & gt; 0)
{
suma = 0; //suma representa el número de rutas a través del nodo.
Visitado[I]= 1;
for(p=G.vertices[i].firstarcp;p = p-& gt;nextarc)
{
l = p->adjvex
if (! visitó [l])
Suma+= getpathnum_len (g, l, j, len-1 )//La longitud restante del camino se reduce en uno.
}//for
visited[I]= 0; //Este tema permite que los nodos visitados aparezcan en otra ruta.
}//En caso contrario
Devuelve la suma;
}//GetPathNum_Len
7.30
int visitado [MAXSIZE];
int path[MAXSIZE]; //Almacena temporalmente la ruta actual
int loop[MAXSIZE][MAXSIZE] //Almacena los nodos contenidos en el bucle descubierto; .
int this Cycle[MAXSIZE]; //Almacena el ciclo encontrado actualmente.
int cycount = 0; //Número de ciclos encontrados
Void GetAllCycle(ALGraph G)//Encuentra todos los ciclos simples en el gráfico dirigido.
{
for(v = 0; v & ltg . vixnum; v++) visitó [v] = 0
for( v = 0; v & ltg . vixnum; v++)
if (!visited[v]) DFS(G, v, 0); // Recorrido en profundidad
}//DFSTraverse
Voidfs (Algraphg, int v, int k)//k representa el número de secuencia del nodo actual en la ruta.
{
Visitado [v] = 1;
Ruta [k] = v; //Registra la ruta actual
para (p=G.vertices[v].firstarcp; p = p-& gt;nextarc)
{
w = p-& gt;adjvex
If (!Visited[w]) DFS(G,w,k+1);
Else //Se encontró un ciclo.
{
for(I = 0; path[i]!= w; i++); //Encontrar el punto inicial del bucle
for( j = 0 ;ruta[I+j];i++)este ciclo[j]= ruta[I+j];//Copiar el ciclo.
if (!exist_cycle())cycles[cycount++]= este ciclo; //Si el ciclo aún no se ha registrado, agréguelo al registro.
for(I = 0;i<g.wicksnum;i++)este ciclo[I]= 0; //Borrar la matriz del ciclo actual.
}//De lo contrario
}//para
ruta[k]= 0;
Visitado[k]= 0 ; //Tenga en cuenta que solo los nodos visitados en la ruta actual son verdaderos. Por lo tanto, una vez que se descubre que el nodo visitado actualmente es verdadero durante el proceso de recorrido, significa que se ha encontrado un ciclo.
}//DFS
in exist _cycle()//Determine si el ciclo registrado en la matriz thiscycle ya existe en el registro del ciclo.
{
int temp[MAXSIZE];
for(I = 0;I<cycountI++) //Determine si el ciclo existente es el mismo que este ciclo.
{//Es decir, todos los nodos y su orden son iguales.
j = 0; c = este ciclo; //Por ejemplo, 142857 y 857142 son el mismo ciclo.
for(k = 0; número de ciclos [i][k]!= c & amp& amp número de ciclos [i][k]!=0;k++); del bucle Encuentre el elemento igual al primer nodo de este ciclo.
If(cycles[i][k]) //Tiene los mismos elementos que este.
{
for(m = 0; periodo[I][k+m]; m++)
temp[m]=número de periodos[I ] [k+m];
for(n = 0; n & ltk; n++, m++)
temp[m]=número de ciclos [I][n]; // Ajusta la fase periódica del registro actual por período y colócalo en la matriz temporal.
If (!StrCompare(temp, thiscycle)) //Comparar con este ciclo.
Return 1; //Exactamente igual
for(m = 0; m & ltg . vixnum; m++)temp[m]= 0 //Borrar la matriz
}
}//for
returns 0; //Todos los circuitos existentes no son exactamente iguales a este período.
}//exit_cycle
Análisis: la idea de este algoritmo es almacenar temporalmente la ruta actual durante el recorrido. Cuando un nodo ya está en la ruta, se almacena temporalmente. indica que hay un ciclo; este ciclo Todos los nodos se pueden obtener escaneando la ruta del vector de ruta, y la secuencia de nodos (por ejemplo, 142857) se almacena en este ciclo. En este algoritmo, se encontrará un bucle varias veces, por lo que es necesario determinar si el bucle ha sido grabado por el bucle. De lo contrario, se puede almacenar en el vector de fila del bucle. Toma cada vector lineal del círculo y compáralo. Porque un ciclo puede tener múltiples secuencias de almacenamiento, como 142857, que equivale a 285714 y 571428. Por lo tanto, es necesario ajustar el orden de los vectores de línea y almacenarlos en la matriz temporal. Por ejemplo, el primer nodo de este ciclo es 142857, el vector actual de ciclos es 857142, luego busque el 1 en este último y coloque la parte después de 1 antes de la parte antes de 1. Finalmente, obtenemos 142857 en temperatura. Comparado con este ciclo encontramos que es lo mismo. Por lo tanto, 142857 y 857142 son el mismo circuito y no se almacenan. Este algoritmo es demasiado complejo para garantizar la precisión de los detalles. Sólo necesitamos entender la idea.
Ojalá alguien pueda darnos un algoritmo más simple.
7.31
int ha accedido a [MAXSIZE];
int ha completado [MAXSIZE]
int count; usado Indica la posición de llenado de la matriz completada en el primer recorrido en profundidad.
void Get _ SG Graph(ol Graph G)//Encuentre los componentes fuertemente conectados del gráfico dirigido G almacenados en la estructura de lista entrecruzada.
{
count = 0;
for(v = 0; v & ltg . vixnum; v++) visitó [v] = 0;
for(v = 0; v & ltg . Vickersnum; V++) //El primer recorrido en profundidad crea la matriz completa.
if(!visited[v]) DFS1(G, v);
for(v = 0; v & ltg . vixnum; v++) visitó [v]= 0; //Borrar la matriz visitada
for(I = g . vex num-1;I>=0;I-)//Segundo recorrido inverso en profundidad primero
{
v = complete(I);
if (! visitó
{
printf (" \ n "); // Diferente fuertemente conectado los componentes se generan en diferentes líneas
DFS2(G, v
}
}//for
}//Get_SGraph);
Voidfs1 (Olgraph g, int v)//El algoritmo del primer recorrido en profundidad
{
Visited[v]= 1;
for(p=G.xlist[v].Primero en salir;p;p = p-& gt;tlink)
{
w = p-> headvex
if (!visited[w]) DFS1(G,w);
}/ /for
Completo[++ count]= v; //Crea una matriz completa en el primer paso
}//DFS1
{
Visitado [v] = 1;
printf("%d ", v); // Genera el nodo en el segundo recorrido Número de serie .
for(p=G.xlist[v].firstinp; p = p-& gt; hlink)
{
w = p-& gt ;tailvex
if (!visited[w]) DFS2(G,w);
}//for
}//DFS2
Análisis: La complejidad temporal del algoritmo para encontrar ramas fuertemente conectadas de un gráfico dirigido es la misma que el recorrido en profundidad primero, que también es O (n+e).
7.32
void Forest_Prim(ALGraph G, int k, CSTree & ampT)//A partir del vértice K, utilice la estructura de lista de adyacencia para construir el bosque generador mínimo T del dirigido gráfico G, almacenado en una lista vinculada entre hermanos.
{
for(j = 0; j & ltg . Vickersnum; J++) // Lo siguiente está ligeramente modificado según el algoritmo de Prim.
Si (j!=k)
{
cerrado[j]={k, Max_int};
para (p =G.vertices[j].firstarcp;p = p->nextarc)
if (p->;adjvex==k)closedge[j].
Bajo costo = p->costo;
}//si
closki[k]. bajo costo = 0;
for(i = 1; i<g. vixnum; i++)
{
k = mínimo( borde cerrado);
if(cerrado[k]. bajo costo & ltMax_int)
{
Addto_Forest(T, cerradodge[k]). adjvex,k); //Agrega este borde al bosque expansivo.
Kloski[k]. Bajo costo = 0;
for(p=G.vertices[k]). firstarcp;p = p->nextarc)
if (p->coste<close dge[p->adjvex].bajo costo)
cerrar dge[ p->adjvex ]={k,p->cost};
}//if
else Forest_Prim(G,k);//para otro Los componentes conectados ejecutan algoritmos.
}//for
}//Forest_Prim
void Addto _ Forest(CSTree & T, int i, int j)//Agregar el borde (I, j) se agrega al árbol T representado por la lista de hermanos secundarios.
{
p=Locate(T, I); // Encuentra el puntero P correspondiente al nodo I, el proceso se omite.
q =(CSTNode *)malloc(sizeof(CSTNode));
q->; datos = j
if (!P) // El vértice inicial no pertenece a ningún árbol existente en el bosque.
{
p =(CSTNode *)malloc(sizeof(CSTNode));
p->; datos = I
r-& gt; siguiente sib =
p-> ;first child = q;
}//Insertar a la derecha como un nuevo árbol.
else if(!p->Firstchild) //Los padres aún no tienen hijos.
p->; first child = q; //Como el primer hijo del padre
Else //El padre ya tiene un hijo.
{
for(r = p-& gt; primer hijo; r-& gt; nextsibr = r-& gt; siguiente hermano); r-& gt; next sib = q; //Como hermano mayor del último hijo de ambos padres.
}
}//Agregar al bosque
main()
{
...
t =(CSTNode *)malloc(sizeof(CSTNode));//Establecer la raíz del árbol
t->; data = 1;
Forest_Prim(G , 1, T);
...
}//main
Análisis: Este algoritmo se basa en el algoritmo de Prim y agrega un gráfico desconectado. Se obtienen los bloques de construcción de la lista enlazada de hermanos descendientes y su complejidad temporal es O (n 2).
7.33
estructura typedef {
int vex//Número de serie del nodo
int ecno//El número del componente de conexión al que pertenece el nodo.
} VexInfo
VexInfo vexs[MAXSIZE]; //Registra la matriz de números de componentes conectados a la que pertenece el nodo.
void Init _ VexInfo(VexInfo & Vexs[], int vexnum)//Inicialización
{
for(I = 0;i<vexnumi++ )
vexs[i]={i, I}; // Estado inicial: cada nodo pertenece a un componente conectado diferente.
}//Init_VexInfo
Intis _ EC (vexinfo vexs [], int i, int j)//Determine si el vértice I y el vértice j pertenecen al mismo componente conectado.
{
si (me molesta [me]. ecno==vexs[j]. ecno) devuelve 1;