Red de conocimiento informático - Problemas con los teléfonos móviles - Programación de colas

Programación de colas

Te doy uno como referencia.

# 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");

}