Programación de colas
# include ltiostream gt
#Define infinity 32767
#Define MAX_VEX 20 //Número máximo de vértices
# define queue _ size (max _ vex 1)//Longitud de la cola
Usando el espacio de nombres std
bool *Accessed; //Acceso a la matriz de indicadores
//Adyacencia del gráfico Estructura de almacenamiento matricial
estructura typedef {
char * vexs//vertex vector
int arcs[MAX _ VEX][MAX _ VEX]; //adyacencia Matriz
int vexnum, arcnum//El número actual de vértices y arcos del gráfico
}Gráfico;
//Clase de cola
Cola de categorías {
Pública:
void InitQueue(){
base =(int *)malloc(QUEUE _ TAMAÑO * sizeof(int)) ;
Anterior=trasero=0;
}
void EnQueue(int e){
base[trasero]= e;
p>
trasero = (trasero 1) QUEUE _ TAMAÑO
}
eliminación de cola nula (int amperio){
e = base[frente ];
frente = (frente 1) QUEUE _ TAMAÑO
}
Público:
int; * base
int front
int rear
};
//Encuentra la posición del elemento C en la figura g.
int Locate(gráfico G, carácter c){
for(int I = 0; i ltg. vixnum; i)
if (G.vexs [i]==c) return I;
return-1;
}
//Crear una red no dirigida
void CreateUDN(Graphics ampG){
int i, j, w, s1, S2
char a, b, temp
Printf ("Ingrese el número; de vértices y arcos:");
scanf("dd", amp wicksnum.g. arcnum);
temp = getchar(); //Recibir retorno de carro
g . vexs =(char *)malloc(g . vex num * sizeof(char)); //Especifique el número de vértices
Printf("Ingrese d vértices.
\n", g . vexnum);
for(I = 0; i ltg . vexnum; I ){ //Inicializar vértices
Printf("Ingresar vértices d: ", I);
scanf ("c ", ampg . vexs[I]);
temp = getchar() //Recibir retorno de carro
}
for(I = 0; i ltg . vixnum; I ) //Inicializa la matriz de adyacencia
for(j = 0; j ltg .dimension xnum; j )
g . arcos[I][j]=infinito;
Printf("Ingrese d arcos.\n ", g . arcnum) ;
for(I = 0; I ltG.arcnumI ){ //Inicializar arco
Printf("Input arc d:", I);
scanf("c c d", amp one, ampb amp; w); //Ingresa los vértices y pesos adjuntos al borde
temp = getchar(); //Recibir retorno de carro
s1=Locate(G, a);
s2=Ubicar(G, b);
g arcos[s 1][S2]= g arcos[S2] [s 1]= w;
}
}
//El primer vértice adyacente del vértice K en el gráfico G
int FirstVex(graph G, int k){
if(k gt; = 0 amp ampk ltG.vexnum){ //k es razonable
for(int I = 0 ; i ltg . vixnum; i )
if(G.arcs[k][i]!=infinito) return i;
}
return-1
}
//El siguiente vértice adyacente del jésimo vértice adyacente del vértice I en el gráfico g
int NextVex(graphG, int i, int j){
if (. i gt= 0 amp amp ilt vexnum ampj gt= 0 amp ampj ltG.vexnum){ //i, j es razonable
for(int k = j 1; k ltg . vixnum; k )
if(G.arcs[i][k]!= infinito )Return k
}
return-1; }
//Primer recorrido en profundidad
void DFS(Graph G, int k){
int I;
if( k =-1){//La primera vez que se ejecuta DFS, k es -1.
for(I = 0; i ltg . vixnum; i )
if (!visited[i]) dfs(g,i); // en DFS se llama en no visitado. vértices.
}
En caso contrario{
visited[k]= true;
printf("c ",g . vexs[k] ); //Accede al k-ésimo vértice
for(i=FirstVex(G,k);i=0;i=NextVex(G,k,I))
if(!visited[i]) DFS(G,I); //Llame recursivamente a DFS en el vértice I adyacente no visitado de k.
}
}
//Recorrido primero en amplitud
BFS no válido (Figura G){
int k;
Cola Q; //cola auxiliar q
q . init queue(); ; i )
if (! visité [i]) { // Aún no lo he visitado.
visitado[I]= verdadero;
printf("c", g. vexs[I]);
q.Enqueue(I); /Estoy en cola
while(Q.front!=Q.rear){
q. Dequeue(k); //El elemento capitán se retira de la cola y se establece en k.
for(int w=FirstVex(G,k);w gt=0;w=NextVex(G,k,w))
If (! Visitó [ w]) { //w es el vértice adyacente no visitado de k.
visitado[w]= verdadero;
printf("c ", g . vexs[w]);
q .Enqueue(w); /p>
}
}
}
}
//Función principal
void main(){
int I;
Gráfico G;
crear udn(G);
visitado =(bool * ) malloc(g . vex num * sizeof(bool));
Printf("\nRecorrido en anchura: ");
for(I = 0; i ltg . dimensión xnum ;i)
visitado[I]= false;
DFS(G, -1);
printf("\nprimer recorrido: ");
for(I = 0; i ltg . vixnum; i )
visitó[I]= false;
BFS(G);
printf("\nEl programa finaliza.\n");
}