¿Se pueden implementar dfs sin recursividad?

Te estoy dando el código completo en Java. ¡No estoy explicando nada que tengas que decodificar porque ya estoy cansado de escribir este programa!

import java.util.Scanner;

pila de clase {

int [] stack = nuevo int [50];

int frente, final, n;

Pila (int n) {

frente = 0;

final = -1;

esto.n = n;

}

vacío push (int n1) {

si (frente == 50)

System.out.println (“Desbordamiento de pila”);

más si (final == – 1) {

end ++;

pila [frente] = n1;

frente ++;

}

más{

pila [frente] = n1;

frente ++;

}

}

int pop () {

frente-;

pila de retorno [frente];

}

boolean is_empty () {

if (final == – 1 || frontal <= final)

falso retorno;

más

volver verdadero;

}

impresión vacía () {

if (frente> 1) {

para (int i = 0; i <frente; i ++)

System.out.print (stack [i] + “”);

}

System.out.println ();

}

}

clase Dfs {

int [] visitado;

int [] [] ar;

int n;

int [] flag;

Dfs () {

Escáner s = nuevo escáner (Recursos e información del sistema);

System.out.println (“ingrese no de nodos”);

n = s.nextInt ();

visitado = nuevo int [n];

flag = new int [n];

ar = nuevo int [n] [n];

System.out.println (“ingresar gráfico”);

para (int i = 0; i <n; i ++) {

para (int j = 0; j <n; j ++)

ar [i] [j] = s.nextInt ();

}

}

/ * operación nula () {

Pila s = nueva pila (n);

int temp;

System.out.println (0);

s.push (0);

visitado [0] = 1;

while (s.is_empty ()) {

temp = s.pop ();

para (int i = 0; i <n; i ++) {

if (ar [temp] [i] == 1 && visitó [i] == 0) {

visitado [i] = 1;

System.out.println (i);

s.push (i);

}

}

}

} * /

operación nula () {

int temp;

Pila s = nueva pila (n);

System.out.println (0);

visitado [0] = 1;

temp = 0;

//s.push(-1);

s.push (0);

while (s.is_empty ()) {

//System.out.println(“inside while loop “);

//System.out.println(“temp=”+temp);

int i = 0;

para (; i <n; i ++) {

//sprint();

//System.out.println(“i=”+i);

//System.out.println(“inside for loop “);

if (ar [temp] [i] == 1 && visitó [i] == 0) {

// System.out.println (“a”);

visitado [i] = 1;

System.out.println (i);

s.push (i);

temp = i;

//System.out.println(“temp=”+temp);

i = 0;

//System.out.println(“i=”+i);

}

if (i == n-1) {

bandera [temp] = 1;

//System.out.println(“flag[“+ temp + “] =” + flag [temp]);

//System.out.println(“changing flag “);

}

//System.out.println(“temp=”+temp);

}

//System.out.println(“flag[“+(s.front-1)+”font>=”+(flag[s.front-1]));

if (flag [s.stack [s.front-1]] == 0) {

temp = s.stack [s.front-1];

// System.out.println (“tomando valor”);

}

más{

temp = s.pop ();

//System.out.println(“poping out “);

}

//System.out.println(“temp=”+temp);

//System.out.println(“c “);

}

}

public static void main (String [] args) {

Dfs d = nuevo Dfs ();

d.operación ();

}

}

Sí, cada solución recursiva se puede implementar de forma iterativa.

La recursión le permite relajarse fácilmente, debido a la * pila de llamadas * en sí misma.

Por lo tanto, puede implementar DFS usted mismo, simplemente usando una estructura de datos Stack propia. Continúe por un camino presionando () e implemente el retroceso haciendo estallar (), utilizando los valores (y la profundidad) de su pila tal como lo haría con una implementación recursiva de DFS.

Una ventaja es que puede elegir la cantidad de datos que desea almacenar, sin tener que preocuparse por “volar la pila”.

La recursión y la iteración son generalmente reemplazables entre sí.

Puede evitar la recursividad colocando los nodos en la pila a medida que los recorre. La solución es bastante simple, googlear te dará buenas explicaciones con animaciones.

Pseudocódigo de Wikipedia:

  procedimiento DFS-iterativo (G, v):
   // deja que S sea una pila
   S.push (v)
   mientras que S no está vacío
     v = S.pop ()
     si v no está etiquetado como descubierto:
       etiqueta v como descubierta
       para todos los bordes de v a w en G.ad adyacentesEdges (v) do
         S.push (w)

Tenga en cuenta que con el mismo algoritmo exacto , simplemente reemplazando S con una cola, puede obtener un BFS no recursivo.