4.1 KiB

Raw Blame History

title	localeTitle
Depth First Search (DFS)	Primera búsqueda de profundidad (DFS)

Primera búsqueda de profundidad (DFS)

Depth First Search es uno de los algoritmos gráficos más simples. Atraviesa el gráfico, primero verifica el nodo actual y luego se mueve a uno de sus sucesores para repetir el proceso. Si el nodo actual no tiene un sucesor para verificar, volvemos a su predecesor y el proceso continúa (al pasar a otro sucesor). Si se encuentra la solución, la búsqueda se detiene.

Visualización

Implementación (C ++ 14)

`` `c ++

incluir

utilizando namespace std;

clase grafica { En televisión; // número de vértices

// pointer to a vector containing adjacency lists 
 vector < int > *adj;

público: Gráfico (int v); // Constructor

// function to add an edge to graph 
 void add_edge(int v, int w); 
 
 // prints dfs traversal from a given source `s` 
 void dfs(); 
 void dfs_util(int s, vector < bool> &visited);

};

Graph :: Graph (int v) { esto -> v = v; adj = nuevo vector [v]; }

void Graph :: add edge (int u, int v) { adj [u]. empujar hacia atrás (v); // agregar v a la lista de u adj [v] .push atrás (v); // agregar u a la lista de v (elimine esta declaración si se dirige el gráfico) } Gráfica de vacío: dfs () { // vector visitado - para realizar un seguimiento de los nodos visitados durante DFS vector visitado (v, falso); // marcando todos los nodos / vértices como no visitados para (int i = 0; i <v; i ++) si (! visitó [i]) dfs util (i, visitó); } // ¡note el uso de llamada por referencia aquí! void Graph :: dfs_util (int s, vector & visited) { // marca el nodo / vértice actual como visitado visitó [s] = verdadero; // salida a la salida estándar (pantalla) cout << s << "";

// traverse its adjacency list and recursively call dfs_util for all of its neighbours! 
 // (only if the neighbour has not been visited yet!) 
 for(vector < int > :: iterator itr = adj[s].begin(); itr != adj[s].end(); itr++) 
    if(!visited[*itr]) 
        dfs_util(*itr, visited);

}

int main () { // crear un gráfico utilizando la clase de gráfico que definimos anteriormente Gráfica g (4); borde g.add (0, 1); borde g.add (0, 2); g.add borde (1, 2); borde g.add (2, 0); g.add borde (2, 3); g.add borde (3, 3);

cout << "Following is the Depth First Traversal of the provided graph" 
     << "(starting from vertex 0): "; 
 g.dfs(); 
 // output would be: 0 1 2 3 
 return 0;

}

### Evaluation 
 
 Space Complexity: O(n) 
 
 Worse Case Time Complexity: O(n) 
 Depth First Search is complete on a finite set of nodes. I works better on shallow trees. 
 
 ### Implementation of DFS in C++

c ++

incluir

utilizando namespace std;

struct Graph { En televisión; bool * adj; público: Gráfico (int vcount); void addEdge (int u, int v); void deleteEdge (int u, int v); vector DFS (int s); void DFSUtil (int s, vector & dfs, vector &visitó); }; Graph :: Graph (int vcount) { esto-> v = vcount; this-> adj = new bool [vcount]; para (int i = 0; i

void Graph :: addEdge (int u, int w) { this-> adj [u] [w] = true; this-> adj [w] [u] = true; }

void Graph :: deleteEdge (int u, int w) { esto-> adj [u] [w] = falso; esto-> adj [w] [u] = falso; }

Void Graph :: DFSUtil (int s, vector & dfs, vector &visitó){ visitó [s] = verdadero; dfs.push_back (s); para (int i = 0; i v; i ++) { if (this-> adj [s] [i] == true && visitó [i] == false) DFSUtil (i, dfs, visitó); } }

vector Graph :: DFS (int s) { vector visitado (this-> v); vector dfs; DFSUtil (s, dfs, visitó); devuelve dfs; } `` `