Implementación de los recorridos DFS y BFS y otros algoritmos

1. Implementación de los recorridos DFS y BFSy otros algoritmos

2. Grafo Ejemplo: 0 1 2 3 4 5

3. Matriz de Adyacencia:

4. DFS #include <iostream.h> //Ejemplo con el grafo anterior: #define N 6 int mat[N][N]= {{0,1,1,0,0,0},{1,0,0,1,0,0},{1,0,0,0,0,0}, {0,1,0,0,1,1},{0,0,0,1,0,1},{0,0,0,1,1,0}}; int Visitados[N]= {0,0,0,0,0,0};

5. void DFS(int V) { Visitados[V] = 1; //El vértice V enviado como parámetro es//visitado cout << V; //Se imprime for(int W=0;W<N;W++) //Se buscan los adyacentes de V if (mat[V][W] == 1) //Se encontró con un adyacente(W) if (Visitados[W] == 0) //Si no ha sido visitado DFS(W); //Llamado recursivo } void main(void) { DFS(0); } Imprimió: 013452

6. BFS #include <iostream.h> //Ejemplo con el grafo anterior: #define N 6 int mat[N][N]= {{0,1,1,0,0,0},{1,0,0,1,0,0},{1,0,0,0,0,0}, {0,1,0,0,1,1},{0,0,0,1,0,1},{0,0,0,1,1,0}}; int Visitados[N]= {0,0,0,0,0,0};

7. //La cola se va a manejar como un vector desde la posición 1 int Cola[100]; //Variables para el manejo de la cola: int total=0; //Indica el total de elementos de la cola int primero=0; /*Indica la posición del próximo elemento que debe ser retirado de la cola...*/ int ultimo=0; /*Indica la posición del último elemento que ingresó en la cola*/ Nota: Mejorar el manejo de la cola, creando una clase Cola con sus respectivos métodos...

8. void BFS(int V) { int Z; //Se visita e imprime el elemento enviado Visitados[V]=1; cout<<V; //Se lleva el elemento a la cola total++; primero++; ultimo++; Cola[ultimo] = V;

9. //Mientras la cola no esté vacía: while (total > 0){ //Extraer próximo elemento de la cola Z=Cola[primero]; primero++; /*Se avanza al próximo elemento que debe ser retirado de la cola*/ total--; /*Se decrementa el total de elementos de la cola*/

10. //Buscar los W adyacentes a Z: for(int W=0;W<N;W++) if (mat[Z][W] == 1) //Encontró un adyacente if (Visitados[W] == 0){ //Si no ha sido visitado Visitados[W] = 1; //W es visitado cout << W; //Se imprime //Llevar W a la cola total++; /*Aumenta el # de elementos en la cola */ ultimo++; /*Incrementa ultimo para entrar un elemento a la cola*/ Cola[ultimo]=W; //Se ingresa W a la cola } } }

11. void main(void) { BFS(0); //Se inicializa Visitados para un nuevo recorrido for(int k=0;k<N;k++) Visitados[k]=0; //Se inicializan las vbles para el manejo de la cola total=ultimo=primero=0; cout<< endl; BFS(1); } Imprimió: 012345 Imprimió: 103245

12. Árbol de expansión de Costo Mínimo de un grafo (AECM) • Sea un grafo NO dirigido conectado con un peso definido en c/u de sus lados • Hallar el AECM consiste en hallar el conjunto de lados que conectan a todos los vértices del grafo con un costo mínimo • El costo se calcula como la sumatoria de los pesos de todos los lados involucrados en el AECM • Los algoritmos de Kruskal y Prim resuelven este problema

13. Algoritmo de Kruskal Sea E= Conjunto de lados ordenados por peso ascendentemente Algoritmo ST={ } i=0 V={ {1},{2},…, {N} } While i < N-1 //N= Nro de nodos del grafo Escoger de E lado (u,w) de costo mínimo Borrar de E lado (u,w) escogido SI lado(u,w) no forma ciclo en ST Incluir lado (u,w) en ST Unir en V los subconjuntos que contengan a u y a w i=i+1 END(SI) END While END Kruskal

14. Algoritmo de Prim Sea V= Conjunto de vértices del grafo Algoritmo ST={ } U= {1} //Se inicializa el conjunto U con un vértice dado While U  V Sea (u,w) el lado de costo mínimo tal que u  U y w  V-U ST = ST unión (u,w) U = U unión {w} END While END Prim