Programacin IV.

Gua 7

Facultad:
Ingeniera
Escuela:
Computacin
Asignatura: Programacin IV

Tema: Grafos en C#.

Objetivos Especficos

Definir el concepto de Grafo.

A partir de una clase agregar la sintaxis necesaria para construir una funcin de grafos en C#

Materiales y Equipo

Gua Nmero 7.

Computadora con programa Microsoft Visual C#.

Introduccin Terica
Grafos.
Un grafo G = (V, E) est formado por un conjunto de elementos llamados vrtices V y un
conjunto de aristas E que conectan a los distintos vrtices. En ocasiones los vrtices son
llamados nodos y las aristas arcos.
Las aristas se definen como el par de vrtices que conectan y pueden tener asociado un valor
el cual representa el peso o dificultad para desplazarse de un vrtice a otro.
Ejemplo grfico de un grafo:

Figura 1.

Donde:
Vrtices = {A, B, C, D, E}
Aristas = {(A, B), (A, D), (B, C), (B, D), (B, E), (C, E), (D, E), (E, D)}

Programacin IV. Gua 7

Tipos de grafos.
Existen dos tipos de grafos: los no dirigidos y los dirigidos.
Grafos No Dirigidos.
Son aquellos en los cuales las aristas no estn orientadas (no son flechas). Cada lado se
representa entre parntesis, separando sus vrtices por comas, y teniendo en cuenta que
ambos vrtices son origen y destino a la vez: (Vi, Vj) = (Vj, Vi).
Grafos Dirigidos.
Son aquellos en los cuales las aristas estn orientadas (son flechas). Cada arista se representa
entre parntesis, separando sus vrtices por comas y teniendo en cuenta (Vi, Vj) (Vj, Vi).
Los grafos pueden representarse de varias formas en una computadora:

Listas adyacentes.
Cada vrtice tiene una lista de vrtices los cuales son adyacentes a l.
Representacin del ejemplo (grafo de Figura 1):
(A) => B => D
(B) => C => D => E
(C) => E
(D) => E
(E) => D

Listas de pares ordenados (incidentes).

Las aristas se representan como un arreglo de pares ordenados.

Matriz de adyacencia.
El grafo se representa por una matriz de tamao VxV, donde V son los vrtices que unen a los
nodos, la conjuncin de los dos vrtices representa la arista.
Representacin del ejemplo (grafo de Figura 1):

Programacin IV. Gua 7

Figura 2.

Procedimiento
Ejemplo 1.
En los cdigos siguientes, se muestra la implementacin de un grafo a partir de listas
adyacentes. Tomar como base el grafo del ejemplo de la seccin terica (ver Figura 1) y crearlo
usando la implementacin.
Crear un proyecto llamado grafo y en el principal agregar el siguiente cdigo:
Program.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace grafo
{
class Program
{
public static void Menu( )
{
Console.WriteLine("**MENU**");
Console.WriteLine("1. Crear grafo");
Console.WriteLine("2. Agregar vertice");
Console.WriteLine("3. Agregar arco");
Console.WriteLine("4. Mostrar vertices");
Console.WriteLine("5. Mostrar grafo");
Console.WriteLine("0. Salir");
Console.WriteLine("opcion: ");
}
static void Main( )
{
string Opcion;
string flag;
CGrafo Grafo = new CGrafo( );
CVertice Ver = new CVertice( );
CVertice Ver1 = new CVertice( );
CVertice Ver2 = new CVertice( );
do
{
Menu( );

Programacin IV. Gua 7

Opcion = Console.ReadLine( );
switch (Opcion)
{ case "1"://Crear Grafo
Console.Write(" Desea Crear un Nuevo Grafo :(S)/(N) ");
flag = Console.ReadLine( );
if (flag == "S")
{
Grafo = new CGrafo( );
Console.WriteLine("Grafo Creado...");
}
break;
case "2"://Agregar Vertice
Console.Write("Ingrese el Nombre del vertice:===>> ");
Ver.nombre = Console.ReadLine( );
Grafo.AgregarVertice(Ver);
break;
case "3"://Agregar Arco
Console.Write("Ingrese Vertice Origen :===>> ");
Ver1.nombre = Console.ReadLine( );
Console.Write("Ingrese Vertice Destino : ");
Ver2.nombre = Console.ReadLine( );
Console.Write("Ingrese Distancia : ");
int Dist = int.Parse(Console.ReadLine( ));
Grafo.AgregarArco(Ver1, Ver2, Dist);
break;
case "4"://Mostrar vetices
Console.WriteLine("Los vertices del grafo son :");
Grafo.MostrarVertices( );
break;
case "5"://Mostrar grafo
Console.WriteLine("El grafo es el siguiente");
Grafo.MostrarGrafo( );
break;
} //Fin del switch
}
while (Opcion != "0");
}
}
}

Agregar las clases CVertice.cs, CLista.cs y Cgrafo.cs, desarrollados en los recuadros de la

manera siguiente: clic derecho sobre el proyecto Grafo en el rbol Explorador de Soluciones,
clic en agregar y clic en clase.
Dar el nombre especificado en el recuadro y clic en Agregar.

Programacin IV. Gua 7

CVertice.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace grafo
{
class CVertice
{
public string nombre;
public CVertice( )
{
}
public CVertice(string Nombre)
{
nombre = Nombre;
}
public override string ToString( )
{
return nombre;
}
public override int GetHashCode( )
{
return base.GetHashCode( );
}
public override bool Equals(object obj)
{
if (obj == null)
return false;
else
return nombre.Equals(obj.ToString( ));
}
}
}
CLista.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace grafo
{
class Clista
{
//----------------ATRIBUTOS------------------------private CVertice aElemento;
private CLista aSubLista;
private int aPeso;
//----------------CONSTRUCTORES---------------------

Programacin IV. Gua 7

public CLista( )
{
aElemento = null;
aSubLista = null;
aPeso = 0;
}
public CLista(CLista pLista)
{
if (pLista != null)
{
aElemento = pLista.aElemento;
aSubLista = pLista.aSubLista;
aPeso = pLista.aPeso;
}
}
public CLista(CVertice pElemento, CLista pSubLista, int pPeso)
{
aElemento = pElemento;
aSubLista = pSubLista;
aPeso = pPeso;
}
//---------------PROPIEDADES-----------------------public CVertice Elemento
{
get
{
return aElemento;}
set
{

aElemento = value; }

}
public CLista SubLista
{
get
{
return aSubLista; }
set
{

aSubLista = value; }

}
public int Peso
{
get
{
return aPeso; }
set
{

aPeso = value;}

}
//------------------------METODOS------------------public bool EsVacia( )
{
return aElemento == null;
}

Programacin IV. Gua 7

public void Agregar(CVertice pElemento, int pPeso)

{
if (pElemento != null)
{
if (aElemento == null)
{
aElemento = new CVertice(pElemento.nombre);
aPeso = pPeso;
aSubLista = new CLista( );
}
else
{
if (!ExisteElemento(pElemento))
aSubLista.Agregar(pElemento, pPeso);
}
}
}
public void Eliminar(CVertice pElemento)
{
if (aElemento != null)
{
if (aElemento.Equals(pElemento))
{
aElemento = aSubLista.aElemento;
aSubLista = aSubLista.SubLista;
}
else
aSubLista.Eliminar(pElemento);
}
}
public int NroElementos( )
{
if (aElemento != null)
return 1 + aSubLista.NroElementos( );
else
return 0;
}
public object IesimoElemento(int posicion)
{
if ((posicion > 0) && (posicion <= NroElementos( )))
if (posicion == 1)
return aElemento;
else
return aSubLista.IesimoElemento(posicion - 1);
else
return null;
}
public object IesimoElementoPeso(int posicion)
{
if ((posicion > 0) && (posicion <= NroElementos( )))
if (posicion == 1)
return aPeso;
else
return aSubLista.IesimoElementoPeso(posicion - 1);
else
return 0;
}

Programacin IV. Gua 7

public bool ExisteElemento(CVertice pElemento)
{
if ((aElemento != null) && (pElemento != null))
{
return (aElemento.Equals(pElemento) ||
(aSubLista.ExisteElemento(pElemento)));
}
else
return false;
}
public int PosicionElemento(CVertice pElemento)
{
if ((aElemento != null) || (ExisteElemento(pElemento)))
if (aElemento.Equals(pElemento))
return 1;
else
return 1 + aSubLista.PosicionElemento(pElemento);
else
return 0;
}
public void Mostrar1( )
{
if (aElemento != null)
{
Console.Write(aElemento.nombre + ":");
aSubLista.Mostrar1( );
}
}
public void Mostrar( )
{
if (aElemento != null)
{
Console.WriteLine(aElemento.nombre + " " + aPeso);
aSubLista.Mostrar( );
}
}
}

CGrafo.cs
using System;
using System.Collections.Generic;
using System.Text;
namespace grafo
{
class CGrafo
{
//==============================Atributos=========================
protected CVertice aVertice;
protected CLista aLista;
protected CGrafo aSiguiente;

Programacin IV. Gua 7

//========================Constructores============================
public CGrafo( )
{
aVertice = null;
aLista = null;
aSiguiente = null;
}
public CGrafo(CVertice pVertice, CLista pLista, CGrafo pSiguiente)
{
aVertice = pVertice;
aLista = pLista;
aSiguiente = pSiguiente;
}
//==========================Propiedades============================
public CVertice Vertice
{
get
{
return aVertice; }
set
{

aVertice = value; }

}
public CLista Lista
{
get
{
return aLista; }
set
{

aLista = value;}

}
public CGrafo Siguiente
{
get
{
return aSiguiente; }
set
{

aSiguiente = value; }

}
//=====================Operaciones Bsicas=================================
public bool EstaVacio( )
{
return (aVertice == null);
}
public int NumerodeVertices( )
{
if (aVertice == null)
return 0;
else
return 1 + aSiguiente.NumerodeVertices();
}

10

Programacin IV. Gua 7

public bool ExisteVertice(CVertice vertice)
{
if ((aVertice == null) || (vertice == null))
return false;
else
if (aVertice.nombre.Equals(vertice.nombre))
return true;
else
return aSiguiente.ExisteVertice(vertice);
}
public void AgregarVertice(CVertice vertice)
{
if ((vertice!=null)&&(!ExisteVertice(vertice)))
{ if (aVertice != null)
{ if (vertice.nombre.CompareTo(aVertice.nombre) < 0)
{
CGrafo aux = new CGrafo(aVertice, aLista, aSiguiente);
aVertice = new CVertice(vertice.nombre);
aSiguiente = aux;
}
else
{
//Agregar
aSiguiente.AgregarVertice(vertice);
}
}
else
{ aVertice = new CVertice(vertice.nombre);
aLista = new CLista( );
aSiguiente = new CGrafo( );
}
}
}

public void AgregarArco(CVertice pVerticeOrigen, CVertice pVerticeDestino, int pDistancia)

{ // Posicionarse en el elemento donde se agragara el arco
if (ExisteVertice(pVerticeOrigen) && ExisteVertice(pVerticeDestino))
agregarArco(pVerticeOrigen, pVerticeDestino, pDistancia);
else
Console.WriteLine("Error......No se agreg arco");
}
private void agregarArco(CVertice pVerticeOrigen, CVertice pVerticeDestino, intpDistancia)
{ // Posicionarse en el elemento donde se agragara el arco
if (ExisteVertice(pVerticeOrigen))
{
if (aVertice.Equals(pVerticeOrigen))
{
//Agregar Arco
if ((!aLista.ExisteElemento(pVerticeDestino)))
aLista.Agregar(pVerticeDestino, pDistancia);
}
else
if (aSiguiente != null)
aSiguiente.agregarArco(pVerticeOrigen, pVerticeDestino, pDistancia);

Programacin IV. Gua 7

11

}
}
public void MostrarVertices( )
{
if (aVertice != null)
{
Console.WriteLine(aVertice.nombre);
aSiguiente.MostrarVertices( );
}
}
public void MostrarGrafo( )
{ if (aVertice != null)
{ for (int i = 1; i <= aLista.NroElementos( ); i++)
Console.WriteLine(aVertice.nombre + " ==> " + aLista.IesimoElemento(i) +
" Con peso>>>>(" + aLista.IesimoElementoPeso(i) + " ) ");
aSiguiente.MostrarGrafo( );
}
}
} //Fin de clase CGrafo
} // Fin del namespace Grafo

Anlisis de resultados
Ejercicio 1.
Analizar el cdigo proporcionado y realizar lo siguiente:

Identificar el tipo de estructura utilizada para el manejo del grafo.

Identificar el objetivo de cada atributo de las clases utilizadas y colocarlo como
comentario en el cdigo del programa.

Determinar la utilidad de cada funcin proporcionada en las clases y colocarlo como

comentario en el cdigo del programa.

Identificar para cada opcin del men, el mtodo invocado y los subsecuentes mtodos
para llevar a cabo la tarea.

Ejercicio 2.
Para el ejemplo desarrollado, agregar al men, las siguientes opciones:

Eliminar Vrtice.
Eliminar Arco.

12

Programacin IV. Gua 7

Investigacin Complementaria

Para la siguiente semana:

Basndose en el cdigo de ejemplo proporcionado, implementar la simulacin del Grafo en una
interfaz grfica de formulario (Windows Forms).
Deben considerarse las siguientes operaciones:
A. Crear grafo
B. Agregar vrtice
C. Agregar arco
D. Mostrar vrtices
E. Eliminar vrtice
F. Eliminar arco
G. Mostrar grafo

Programacin IV. Gua 7

Hoja de cotejo:

Gua 7: Grafos en C#.

Alumno:

Mquina No:

Docente:

GL:

13

Fecha:

EVALUACIN
%
CONOCIMIENTO

Del 20
al 30%

APLICACIN
DEL
CONOCIMIENTO

Del 40%
al 60%

ACTITUD

Del 15%
al 30%

TOTAL

100%

1-4

5-7

8-10

Conocimiento
deficiente
de los
fundamentos
tericos

Conocimiento
y explicacin
incompleta de
los
fundamentos
tericos

Conocimiento
completo y
explicacin
clara de los
fundamentos
tericos

No tiene
actitud
proactiva.

Actitud
propositiva y
con
propuestas no
aplicables al
contenido de
la gua.

Tiene actitud
proactiva y
sus propuestas
son concretas.

Nota