grafos - ejercicios resueltos

Vista previa del material en texto

EJERCICIOS RESUELTOS
1. Crea un algoritmo que inserte n nodos y a aristas en un grafo y muestra el grafo usando una lista de adyacencias.
Solución:
us ng System;
us ng System.Collect ons.Gener c; us ng System.L nq;
us ng System.Text;
us ng System.Thread ng.Tasks;
namespace Ejerc c o_12._1
{
class Nodo
{
publ c	nt dato; publ c Nodo sgte; publ c Ar sta ady;
}
class Ar sta
{
publ c Nodo dest no; publ c Ar sta sgte;
}
class Grafo
{
pr vate Nodo	n c o;
publ c Grafo()
{
n c o = null;
}
pr vate Nodo obtenerNodo( nt valor)
{
Nodo nodo =	n c o;
wh le (nodo != null && nodo.dato != valor)
{
nodo = nodo.sgte;
}
return nodo;
}
pr vate Ar sta obtenerAr sta(Nodo nodoOr gen, Nodo nodoDest no)
{
Ar sta ar sta = nodoOr gen.ady;
 (
Análisis de algoritmos y estrategias de programación
 
–
 
Sesión
 
1
4
)
 (
10
)
nodoDest no)
}
wh le (ar sta != null && ar sta.dest no !=
{
ar sta = ar sta.sgte;
}
return ar sta;
publ c vo d	nsertarNodo( nt valor)
{
Nodo nuevoNodo, nodoUlt mo;
f (obtenerNodo(valor) == null)
{
nuevoNodo = new Nodo(); nuevoNodo.dato = valor; nuevoNodo.sgte = null; nuevoNodo.ady = null;
f ( n c o == null)
n c o = nuevoNodo;
else
{
nodoUlt mo =	n c o;
wh le (nodoUlt mo.sgte != null) nodoUlt mo = nodoUlt mo.sgte;
nodoUlt mo.sgte = nuevoNodo;
}
}
}
publ c vo d	nsertarAr sta( nt or gen,	nt dest no)
{
Ar sta nuevaAr sta, ult maAr sta; Nodo nodoOr gen, nodoDest no;
nodoOr gen = obtenerNodo(or gen); f (nodoOr gen != null)
{
nodoDest no = obtenerNodo(dest no);
f (nodoDest no != null)
{
nodoDest no) == null)
f (obtenerAr sta(nodoOr gen,
{
nuevaAr sta = new Ar sta(); nuevaAr sta.dest no = nodoDest no; nuevaAr sta.sgte = null;
f (nodoOr gen.ady == null)
{
nodoOr gen.ady =
nuevaAr sta;
nodoOr gen.ady;
}
else
{
ult maAr sta =
null)
ult maAr sta.sgte;
whle (ult maAr sta.sgte != ult maAr sta =
nuevaAr sta;
}
}
}
}
ult maAr sta.sgte =
}
publ c vo d mostrarGrafo()
{
Nodo nodoActual =	n c o; Ar sta ar staActual;
wh le (nodoActual != null)
{
Console.Wr te(nodoActual.dato + " -> "); ar staActual = nodoActual.ady;
wh le (ar staActual != null)
{
Console.Wr te(ar staActual.dest no.dato +
" ");
ar staActual = ar staActual.sgte;
}
Console.Wr teL ne(""); nodoActual = nodoActual.sgte;
}
}
}
nternal class flrogram
{
stat c vo d Ma n(str ng[] args)
{
Grafo grafo = new Grafo();
nt n, a, valor, or gen, dest no;
Console.Wr teL ne("Ingresa la cant dad de nodos:"); n =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= n;	++)
{
Console.Wr teL ne("Nodo " +	+ ":"); valor =	nt.flarse(Console.ReadL ne());
grafo. nsertarNodo(valor);
}
Console.Wr teL ne("Ingresa la cant dad de ar stas:"); a =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= a;	++)
{
Console.Wr teL ne("Ar sta " +	+ ":"); Console.Wr teL ne("Nodo or gen:");
or gen =	nt.flarse(Console.ReadL ne()); Console.Wr teL ne("Nodo dest no:"); dest no =		nt.flarse(Console.ReadL ne());
grafo. nsertarAr sta(or gen, dest no);
}
Console.Wr teL ne("Grafo	ngresado: "); grafo.mostrarGrafo();
}
}
}
2. Crea un algoritmo que inserte n nodos y a aristas en un grafo y muestra el grafo usando una lista de adyacencias. Luego, elimina una arista y muestra el grafo resultante.
Solución:
us ng System;
us ng System.Collect ons.Gener c; us ng System.L nq;
us ng System.Text;
us ng System.Thread ng.Tasks;
namespace Ejerc c o_12._2
{
class Nodo
{
publ c	nt dato; publ c Nodo sgte; publ c Ar sta ady;
}
class Ar sta
{
publ c Nodo dest no; publ c Ar sta sgte;
}
class Grafo
{
pr vate Nodo	n c o;
publ c Grafo()
{
n c o = null;
}
pr vate Nodo obtenerNodo( nt valor)
{
Nodo nodo =	n c o;
wh le (nodo != null && nodo.dato != valor)
{
nodo = nodo.sgte;
}
return nodo;
}
pr vate Ar sta obtenerAr sta(Nodo nodoOr gen, Nodo nodoDest no)
{
Ar sta ar sta = nodoOr gen.ady;
nodoDest no)
}
wh le (ar sta != null && ar sta.dest no !=
{
ar sta = ar sta.sgte;
}
return ar sta;
publ c vo d	nsertarNodo( nt valor)
{
Nodo nuevoNodo, nodoUlt mo;
f (obtenerNodo(valor) == null)
{
nuevoNodo = new Nodo(); nuevoNodo.dato = valor; nuevoNodo.sgte = null; nuevoNodo.ady = null;
f ( n c o == null)
n c o = nuevoNodo;
else
{
nodoUlt mo =	n c o;
wh le (nodoUlt mo.sgte != null) nodoUlt mo = nodoUlt mo.sgte;
nodoUlt mo.sgte = nuevoNodo;
}
}
}
publ c vo d	nsertarAr sta( nt or gen,	nt dest no)
{
Ar sta nuevaAr sta, ult maAr sta; Nodo nodoOr gen, nodoDest no;
nodoOr gen = obtenerNodo(or gen);
f (nodoOr gen != null)
{
nodoDest no = obtenerNodo(dest no);
f (nodoDest no != null)
{
nodoDest no) == null)
f (obtenerAr sta(nodoOr gen,
{
nuevaAr sta = new Ar sta(); nuevaAr sta.dest no = nodoDest no; nuevaAr sta.sgte = null;
f (nodoOr gen.ady == null)
{
nuevaAr sta;
nodoOr gen.ady;
}
else
{
nodoOr gen.ady =
ult maAr sta =
null)
ult maAr sta.sgte;
wh le (ult maAr sta.sgte != ult maAr sta =
nuevaAr sta;
}
}
}
}
ult maAr sta.sgte =
}
publ c vo d el m narAr sta( nt or gen,	nt dest no)
{
Nodo nodoOr gen;
Ar sta ar staAnter or = null, ar staActual; nodoOr gen = obtenerNodo(or gen);
f (nodoOr gen != null && nodoOr gen.ady != null)
{
ar staActual = nodoOr gen.ady;
wh le (ar staActual != null && ar staActual.dest no.dato != dest no)
{
ar staAnter or = ar staActual;
ar staActual = ar staActual.sgte;
}
f (ar staActual != null)
{
f (ar staAnter or == null)
{
nodoOr gen.ady.sgte;
ar staActual.sgte;
}
else
{
}
nodoOr gen.ady =
ar staAnter or.sgte =
ar staActual = null;
}
}
}
publ c vo d mostrarGrafo()
{
Nodo nodoActual =	n c o; Ar sta ar staActual;
wh le (nodoActual != null)
{
Console.Wr te(nodoActual.dato + " -> "); ar staActual = nodoActual.ady;
wh le (ar staActual != null)
{
Console.Wr te(ar staActual.dest no.dato +
" ");
ar staActual = ar staActual.sgte;
}
Console.Wr teL ne(""); nodoActual = nodoActual.sgte;
}
}
}
nternal class flrogram
{
stat c vo d Ma n(str ng[] args)
{
Grafo grafo = new Grafo();
nt n, a, valor, or gen, dest no;
Console.Wr teL ne("Ingresa la cant dad de nodos:"); n =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= n;	++)
{
Console.Wr teL ne("Nodo " +	+ ":"); valor =	nt.flarse(Console.ReadL ne());
grafo. nsertarNodo(valor);
}
Console.Wr teL ne("Ingresa la cant dad de ar stas:"); a =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= a;	++)
{
Console.Wr teL ne("Ar sta " +	+ ":"); Console.Wr teL ne("Nodo or gen:");
or gen =	nt.flarse(Console.ReadL ne()); Console.Wr teL ne("Nodo dest no:"); dest no =		nt.flarse(Console.ReadL ne());
grafo. nsertarAr sta(or gen, dest no);
}
Console.Wr teL ne("Grafo	ngresado: "); grafo.mostrarGrafo();
Console.Wr teL ne("Ingresa ar sta a el m nar:"); Console.Wr teL ne("Nodo or gen:");
or gen =	nt.flarse(Console.ReadL ne()); Console.Wr teL ne("Nodo dest no:");
dest no =	nt.flarse(Console.ReadL ne()); grafo.el m narAr sta(or gen, dest no);
Console.Wr teL ne("Grafo resultante: "); grafo.mostrarGrafo();
}
}
}
3. Crea un algoritmo que inserte n nodos y a aristas en un grafo y muestra el grafo usando una lista de adyacencias. Luego, elimina un nodo y muestra el grafo resultante.
Solución:
us ng System;
us ng System.Collect ons.Gener c; us ng System.L nq;
us ng System.Text;
us ng System.Thread ng.Tasks;
namespace Ejerc c o_12._3
{
class Nodo
{
publ c	nt dato; publ c Nodo sgte; publ c Ar sta ady;
}
class Ar sta
{
publ c Nodo dest no;
publ c Ar sta sgte;
}
class Grafo
{
pr vate Nodo	n c o;
publ c Grafo()
{
n c o = null;
}
pr vate Nodo obtenerNodo( nt valor)
{
Nodo nodo =	n c o;
wh le (nodo != null && nodo.dato != valor)
{
nodo = nodo.sgte;
}
return nodo;
}
pr vate Ar sta obtenerAr sta(Nodo nodoOr gen, Nodo nodoDest no)
{
Ar sta ar sta = nodoOr gen.ady;
nodoDest no)
}
wh le (ar sta != null && ar sta.dest no !=
{
ar sta = ar sta.sgte;
}
return ar sta;
publ c vo dnsertarNodo( nt valor)
{
Nodo nuevoNodo, nodoUlt mo;
f (obtenerNodo(valor) == null)
{
nuevoNodo = new Nodo(); nuevoNodo.dato = valor; nuevoNodo.sgte = null; nuevoNodo.ady = null;
f ( n c o == null)
n c o = nuevoNodo;
else
{
nodoUlt mo =	n c o;
wh le (nodoUlt mo.sgte != null) nodoUlt mo = nodoUlt mo.sgte;
nodoUlt mo.sgte = nuevoNodo;
}
}
}
publ c vo d	nsertarAr sta( nt or gen,	nt dest no)
{
Ar sta nuevaAr sta, ult maAr sta; Nodo nodoOr gen, nodoDest no;
nodoOr gen = obtenerNodo(or gen); f (nodoOr gen != null)
{
nodoDest no = obtenerNodo(dest no);
f (nodoDest no != null)
{
nodoDest no) == null)
f (obtenerAr sta(nodoOr gen,
{
nuevaAr sta = new Ar sta(); nuevaAr sta.dest no = nodoDest no; nuevaAr sta.sgte = null;
f (nodoOr gen.ady == null)
{
nuevaAr sta;
nodoOr gen.ady;
}
else
{
nodoOr gen.ady =
ult maAr sta =
null)
ult maAr sta.sgte;
wh le (ult maAr sta.sgte != ult maAr sta =
nuevaAr sta;
}
}
}
}
ult maAr sta.sgte =
}
publ c vo d el m narAr sta( nt or gen,	nt dest no)
{
Nodo nodoOr gen;
Ar sta ar staAnter or = null, ar staActual; nodoOr gen = obtenerNodo(or gen);
f (nodoOr gen != null && nodoOr gen.ady != null)
{
ar staActual = nodoOr gen.ady;
wh le (ar staActual != null && ar staActual.dest no.dato != dest no)
{
ar staAnter or = ar staActual;
ar staActual = ar staActual.sgte;
}
f (ar staActual != null)
{
f (ar staAnter or == null)
{
nodoOr gen.ady.sgte;
ar staActual.sgte;
}
else
{
}
nodoOr gen.ady =
ar staAnter or.sgte =
ar staActual = null;
}
}
}
publ c vo d el m narNodo( nt valor)
{
n c o;
valor)
Nodo nodoAnter or = null, nodoActual, nodoOr gen = Ar sta adyacenc as, aux;
wh le (nodoOr gen != null && nodoOr gen.dato !=
{
nodoAnter or = nodoOr gen; nodoOr gen = nodoOr gen.sgte;
}
f (nodoOr gen != null)
{
nodoActual =	n c o;
wh le (nodoActual != null)
{
el m narAr sta(nodoActual.dato, valor); nodoActual = nodoActual.sgte;
}
adyacenc as = nodoOr gen.ady;
wh le (adyacenc as != null)
{
aux = adyacenc as;
adyacenc as = adyacenc as.sgte; aux = null;
}
f (nodoAnter or == null)
n c o =	n c o.sgte;
else
nodoAnter or.sgte = nodoOr gen.sgte;
nodoOr gen = null;
}
}
publ c vo d mostrarGrafo()
{
Nodo nodoActual =	n c o; Ar sta ar staActual;
wh le (nodoActual != null)
{
Console.Wr te(nodoActual.dato + " -> "); ar staActual = nodoActual.ady;
wh le (ar staActual != null)
{
Console.Wr te(ar staActual.dest no.dato +
" ");
ar staActual = ar staActual.sgte;
}
Console.Wr teL ne(""); nodoActual = nodoActual.sgte;
}
}
}
class flrogram
{
stat c vo d Ma n(str ng[] args)
{
Grafo grafo = new Grafo();
nt n, a, valor, or gen, dest no;
Console.Wr teL ne("Ingresa la cant dad de nodos:"); n =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= n;	++)
{
Console.Wr teL ne("Nodo " +	+ ":"); valor =	nt.flarse(Console.ReadL ne());
grafo. nsertarNodo(valor);
}
Console.Wr teL ne("Ingresa la cant dad de ar stas:"); a =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= a;	++)
{
Console.Wr teL ne("Ar sta " +	+ ":");
Console.Wr teL ne("Nodo or gen:");
or gen =	nt.flarse(Console.ReadL ne()); Console.Wr teL ne("Nodo dest no:"); dest no =		nt.flarse(Console.ReadL ne());
grafo. nsertarAr sta(or gen, dest no);
}
Console.Wr teL ne("Grafo	ngresado: "); grafo.mostrarGrafo();
Console.Wr teL ne("Ingresa nodo a el m nar:"); valor =	nt.flarse(Console.ReadL ne());
grafo.el m narNodo(valor);
Console.Wr teL ne("Grafo resultante: "); grafo.mostrarGrafo();
}
}
}
4. Inserta n nodos y a aristas en un grafo y muestra el grafo usando una lista de adyacencias. Luego, recorre el grafo por anchura a partir de un nodo específico.
Solución:
us ng System;
us ng System.Collect ons.Gener c; us ng System.L nq;
us ng System.Text;
us ng System.Thread ng.Tasks;
namespace Ejerc c o_12._4_Cola
{
class Nodo
{
publ c	nt dato; publ c Nodo sgte;
}
class Cola
{
pr vate Nodo frente; pr vate Nodo f n;
publ c Nodo getFrente()
{
return frente;
}
publ c vo d enqueue( nt valor)
{
Nodo nuevoNodo;
nuevoNodo = new Nodo(); nuevoNodo.dato = valor;
nuevoNodo.sgte = null;
f (frente == null)
{
frente = nuevoNodo;
}
else
{
}
f n.sgte = nuevoNodo;
f n = nuevoNodo;
}
publ c	nt dequeue()
{
Nodo aux = frente; nt valor;
valor = aux.dato; f (frente == f n)
f n = null; frente = frente.sgte;
aux = null; return valor;
}
}
}
us ng System;
us ng System.Collect ons.Gener c; us ng System.L nq;
us ng System.Text;
us ng System.Thread ng.Tasks; us ng Ejerc c o_12._4_Cola;
namespace Ejerc c o_12._4
{
class Nodo
{
publ c	nt dato; publ c Nodo sgte; publ c Ar sta ady; publ c char estado;
}
class Ar sta
{
publ c Nodo dest no; publ c Ar sta sgte;
}
class Grafo
{
pr vate Nodo	n c o;
publ c Grafo()
{
n c o = null;
}
pr vate Nodo obtenerNodo( nt valor)
{
Nodo nodo =	n c o;
wh le (nodo != null && nodo.dato != valor)
{
nodo = nodo.sgte;
}
return nodo;
}
nodoDest no)
nodoDest no)
pr vate Ar sta obtenerAr sta(Nodo nodoOr gen, Nodo
{
Ar sta ar sta = nodoOr gen.ady;
wh le (ar sta != null && ar sta.dest no !=
{
ar sta = ar sta.sgte;
}
return ar sta;
}
publ c vo d	nsertarNodo( nt valor)
{
Nodo nuevoNodo, nodoUlt mo;
f (obtenerNodo(valor) == null)
{
nuevoNodo = new Nodo(); nuevoNodo.dato = valor; nuevoNodo.sgte = null; nuevoNodo.ady = null;
f ( n c o == null)
n c o = nuevoNodo;
else
{
nodoUlt mo =	n c o;
wh le (nodoUlt mo.sgte != null) nodoUlt mo = nodoUlt mo.sgte;
nodoUlt mo.sgte = nuevoNodo;
}
}
}
publ c vo d	nsertarAr sta( nt or gen,	nt dest no)
{
Ar sta nuevaAr sta, ult maAr sta; Nodo nodoOr gen, nodoDest no;
nodoOr gen = obtenerNodo(or gen); f (nodoOr gen != null)
{
nodoDest no = obtenerNodo(dest no);
f (nodoDest no != null)
{
nodoDest no) == null)
f (obtenerAr sta(nodoOr gen,
{
nuevaAr sta = new Ar sta(); nuevaAr sta.dest no = nodoDest no; nuevaAr sta.sgte = null;
f (nodoOr gen.ady == null)
{
nuevaAr sta;
nodoOr gen.ady;
}
else
{
nodoOr gen.ady =
ult maAr sta =
null)
ult maAr sta.sgte;
wh le (ult maAr sta.sgte != ult maAr sta =
nuevaAr sta;
}
}
}
}
ult maAr sta.sgte =
}
pr vate vo d	n c al zarNodos()
{
Nodo nodoActual =	n c o;
wh le (nodoActual != null)
{
nodoActual.estado = 'N'; nodoActual = nodoActual.sgte;
}
}
publ c vo d recorr doAnchura( nt or gen)
{
Nodo nodoOr gen, nodoDest no; Ar sta adyacenc as;
Cola cola = new Cola();
nt valor;
n c al zarNodos();
nodoOr gen = obtenerNodo(or gen);
f (nodoOr gen != null)
{
nodoOr gen.estado = 'V'; cola.enqueue(nodoOr gen.dato);
wh le (cola.getFrente() != null)
{
valor = cola.dequeue(); Console.Wr te(valor + " ");
nodoOr gen = obtenerNodo(valor); adyacenc as = nodoOr gen.ady;
wh le (adyacenc as != null)
{
nodoDest no = adyacenc as.dest no;
f (nodoDest no.estado == 'N')
{
nodoDest no.estado = 'V';
cola.enqueue(nodoDest no.dato);
}
adyacenc as = adyacenc as.sgte;
}
}
Console.Wr teL ne("");
}
}
publ c vo d mostrarGrafo()
{
Nodo nodoActual =	n c o; Ar sta ar staActual;
wh le (nodoActual != null)
{
Console.Wr te(nodoActual.dato + " -> "); ar staActual = nodoActual.ady;
wh le (ar staActual != null)
{
Console.Wr te(ar staActual.dest no.dato +
" ");
ar staActual = ar staActual.sgte;
}
Console.Wr teL ne(""); nodoActual = nodoActual.sgte;
}
}
}
class flrogram
{
stat c vo d Ma n(str ng[] args)
{
Grafo grafo = new Grafo();
nt n, a, valor, or gen, dest no;
Console.Wr teL ne("Ingresa la cant dad de nodos:"); n =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= n;	++)
{
Console.Wr teL ne("Nodo " +	+ ":"); valor =	nt.flarse(Console.ReadL ne());
grafo. nsertarNodo(valor);
}
Console.Wr teL ne("Ingresa la cant dad de ar stas:"); a =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= a;	++)
{
Console.Wr teL ne("Ar sta " +	+ ":"); Console.Wr teL ne("Nodo or gen:");
or gen =	nt.flarse(Console.ReadL ne()); Console.Wr teL ne("Nodo dest no:");dest no =		nt.flarse(Console.ReadL ne());
grafo. nsertarAr sta(or gen, dest no);
}
Console.Wr teL ne("Grafo	ngresado: "); grafo.mostrarGrafo();
Console.Wr teL ne("Recorr do en anchura: ");
Console.Wr teL ne("Nodo or gen:");
or gen =	nt.flarse(Console.ReadL ne()); Console.Wr teL ne("Resultado: "); grafo.recorr doAnchura(or gen);
}
}
}
5. Inserta n nodos y a aristas en un grafo y muestra el grafo usando una lista de adyacencias. Luego, recorre el grafo por profundidad.
Solución:
us ng System;
us ng System.Collect ons.Gener c; us ng System.L nq;
us ng System.Text;
us ng System.Thread ng.Tasks;
namespace Ejerc c o_12._5
{
class Nodo
{
publ c	nt dato; publ c Nodo sgte; publ c Ar sta ady; publ c char estado;
}
class Ar sta
{
publ c Nodo dest no; publ c Ar sta sgte;
}
class Grafo
{
pr vate Nodo	n c o;
publ c Grafo()
{
n c o = null;
}
pr vate Nodo obtenerNodo( nt valor)
{
Nodo nodo =	n c o;
wh le (nodo != null && nodo.dato != valor)
{
nodo = nodo.sgte;
}
return nodo;
}
pr vate Ar sta obtenerAr sta(Nodo nodoOr gen, Nodo nodoDest no)
{
Ar sta ar sta = nodoOr gen.ady;
nodoDest no)
wh le (ar sta != null && ar sta.dest no !=
{
ar sta = ar sta.sgte;
}
return ar sta;
}
publ c vo d	nsertarNodo( nt valor)
{
Nodo nuevoNodo, nodoUlt mo;
f (obtenerNodo(valor) == null)
{
nuevoNodo = new Nodo(); nuevoNodo.dato = valor; nuevoNodo.sgte = null; nuevoNodo.ady = null;
f ( n c o == null)
n c o = nuevoNodo;
else
{
nodoUlt mo =	n c o;
wh le (nodoUlt mo.sgte != null) nodoUlt mo = nodoUlt mo.sgte;
nodoUlt mo.sgte = nuevoNodo;
}
}
}
publ c vo d	nsertarAr sta( nt or gen,	nt dest no)
{
Ar sta nuevaAr sta, ult maAr sta; Nodo nodoOr gen, nodoDest no;
nodoOr gen = obtenerNodo(or gen); f (nodoOr gen != null)
{
nodoDest no = obtenerNodo(dest no);
f (nodoDest no != null)
{
nodoDest no) == null)
f (obtenerAr sta(nodoOr gen,
{
nuevaAr sta = new Ar sta(); nuevaAr sta.dest no = nodoDest no; nuevaAr sta.sgte = null;
f (nodoOr gen.ady == null)
{
nuevaAr sta;
}
else
{
nodoOr gen.ady =
ult maAr sta =
nodoOr gen.ady;
null)
ult maAr sta.sgte;
wh le (ult maAr sta.sgte != ult maAr sta =
nuevaAr sta;
}
}
}
}
ult maAr sta.sgte =
}
pr vate vo d	n c al zarNodos()
{
Nodo nodoActual =	n c o;
wh le (nodoActual != null)
{
nodoActual.estado = 'N'; nodoActual = nodoActual.sgte;
}
}
pr vate vo d v s tar(Nodo nodoOr gen)
{
Ar sta adyacenc as;
nodoOr gen.estado = 'V';
Console.Wr te(nodoOr gen.dato + " "); adyacenc as = nodoOr gen.ady;
wh le (adyacenc as != null)
{
f (adyacenc as.dest no.estado == 'N')
{
v s tar(adyacenc as.dest no);
}
adyacenc as = adyacenc as.sgte;
}
}
publ c vo d recorr doflrofund dad()
{
Nodo actual =	n c o;
n c al zarNodos();
wh le (actual != null)
{
f (actual.estado == 'N')
{
v s tar(actual);
}
actual = actual.sgte;
}
Console.Wr teL ne("");
}
publ c vo d mostrarGrafo()
{
Nodo nodoActual =	n c o; Ar sta ar staActual;
wh le (nodoActual != null)
{
Console.Wr te(nodoActual.dato + " -> "); ar staActual = nodoActual.ady;
wh le (ar staActual != null)
{
Console.Wr te(ar staActual.dest no.dato +
" ");
ar staActual = ar staActual.sgte;
}
Console.Wr teL ne(""); nodoActual = nodoActual.sgte;
}
}
}
nternal class flrogram
{
stat c vo d Ma n(str ng[] args)
{
Grafo grafo = new Grafo();
nt n, a, valor, or gen, dest no;
Console.Wr teL ne("Ingresa la cant dad de nodos:"); n =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= n;	++)
{
Console.Wr teL ne("Nodo " +	+ ":"); valor =	nt.flarse(Console.ReadL ne());
grafo. nsertarNodo(valor);
}
Console.Wr teL ne("Ingresa la cant dad de ar stas:"); a =	nt.flarse(Console.ReadL ne());
for ( nt	= 1;	<= a;	++)
{
Console.Wr teL ne("Ar sta " +	+ ":"); Console.Wr teL ne("Nodo or gen:");
or gen =	nt.flarse(Console.ReadL ne()); Console.Wr teL ne("Nodo dest no:"); dest no =		nt.flarse(Console.ReadL ne());
grafo. nsertarAr sta(or gen, dest no);
}
Console.Wr teL ne("Grafo	ngresado: "); grafo.mostrarGrafo();
Console.Wr teL ne("Recorr do en profund dad:"); grafo.recorr doflrofund dad();
}
}
}