Tema 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:

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

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).
1

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 que (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.
Segn el grafo ejemplo:
(A)
(B)
(C)
(D)
(E)

=> B => D
=> C => D => E
=> E
=> E
=> D

Listas de pares ordenados (incidentes)

Las aristas se representan como un arreglo de pares ordenados
Segn el grafo ejemplo:
A
A
B
B
B
C
D
E

B
D
C
D
E
E
E
D

Matriz de adyacencia
El grafo se representa por una matriz de tamao V * V, donde V son los vrtices que unen a
los nodos, la conjuncin de los dos vrtices representa la arista.
Segn el grafo ejemplo:

A
B
C
D
E

A
0
0
0
0
0

B
1
0
0
0
0

C
0
1
0
0
0

D
1
1
0
0
1

E
0
1
1
1
0

En el cdigo siguiente, se muestra la implementacin de un grafo a partir de listas adyacentes:

Program.cs
using
using
using
using

System;
System.Collections.Generic;
System.Linq;
System.Text;

namespace GRAFO1
{
class Program
{
public static void Menu(out int opcion)
{
Console.WriteLine("
***
MENU
*** ");
Console.WriteLine("1. Crear Grafo");
Console.WriteLine("2. Agregar vertice");
Console.WriteLine("3. Agregar arco");
Console.WriteLine("4. Mostrar vertice");
Console.WriteLine("5. Mostrar grafo");
Console.WriteLine("6. Salir");
Console.WriteLine(" Escoja una opcion:");
opcion = int.Parse(Console.ReadLine());
}
static void Main()
{
int opcion;
char bandera;
CGrafo Grafo = new CGrafo();
CVertice Ver = new CVertice();
CVertice Ver1 = new CVertice();
CVertice Ver2 = new CVertice();
do
{
Menu(out opcion);
switch (opcion)
{
case 1: // Crear grafo
Console.Write("Desea Crear un Nuevo Grafo: S/N ");
bandera = char.Parse(Console.ReadLine());
if (bandera == 'S' || bandera == 's')
{
Grafo = new CGrafo();
Console.WriteLine("Grafo creado ...");
}
break;
case 2: //Agrear vertice
Console.Write("Ingrese el Nombre del vertice: ");
Ver.nombre = Console.ReadLine();
Grafo.AgregarVertice(Ver);
break;
case 3: //Agrear 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 vertices
Console.WriteLine("Los vertices del grafo son: ");
Grafo.MostrarVertices();
break;
case 5: //Mostrar grafo
Console.WriteLine("El grafo es el siguiente: ");
Grafo.MostrarGrafo();
break;
case 6: //Fin del programa
Console.WriteLine("Fin del progrma ... ");
break;
default: Console.WriteLine("Opcion incorrecta ...");
break;
}
}
while (opcion != 6);
}
}
}

Luego agregue las clases CVertice.cs, CLista.cs y CGrafo.cs, desarrollados a continuacin, para
agregar estas otras clases haga clic derecho sobre el proyecto Grafo1 en el Explorador de
Soluciones, luego haga clic derecho en Agregar y finalmente clic en Clase, agregue el nombre de
la clase en la parte inferior de la ventana emergente donde aparece Nombre: y luego clic en
Agregar.
Cuando haya agregado las tres clases haga clic en el botn guardar todo.

CVertice.cs
using
using
using
using

System;
System.Collections.Generic;
System.Linq;
System.Text;

namespace GRAFO1
{
class CVertice
{
public string nombre;
public CVertice()
{
}
public CVertice(string Nombre)
{
nombre = Nombre;

}
public override string ToString()
{
return nombre;
}
public override bool Equals(object obj)
{
if (obj == null)
return false;
else
return nombre.Equals(obj.ToString());
}
}
}

CLista.cs
using
using
using
using

System;
System.Collections.Generic;
System.Linq;
System.Text;

namespace GRAFO1
{
class CLista
{
//Atributos
private CVertice aElemento;
private CLista aSubLista;
private int aPeso;
//Constructores
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;
}
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;
}
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
using
using
using

System;
System.Collections.Generic;
System.Linq;
System.Text;

namespace GRAFO1
{
class CGrafo
{
// ============== Atributos =============
protected CVertice aVertice;
protected CLista aLista;
protected CGrafo aSiguiente;
// ============= 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 Basicas =========
public bool EstaVacio()
{
return (aVertice == null);
}
public int NumerodeVertices()
{
if (aVertice == null)
return 0;
else
return 1 + aSiguiente.NumerodeVertices();
}
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)
{
// Posionarse en el elemento donde se agregara el arco
if (ExisteVertice(pVerticeOrigen) && ExisteVertice(pVerticeDestino))
agregarArco(pVerticeOrigen, pVerticeDestino, pDistancia);
else
Console.WriteLine("Error ... No se agrego arco ");
}
private void agregarArco(CVertice pVerticeOrigen, CVertice pVerticeDestino, int pDistancia)
{
// Posionarse en el elemento donde se agregara 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);
}
}
public void MostrarVertices()
{
if (aVertice != null)
{
Console.WriteLine(aVertice.nombre);
aSiguiente.MostrarVertices();
}
}
public void MostrarGrafo()
{
if (aVertice != null)

10

{
for (int i = 1; i <= aLista.NroElementos(); i++)
Console.WriteLine(aVertice.nombre + "==>" + aLista.IesimoElemento(i) + "Con
peso>>>>(" + aLista.IesimoElementoPeso(i) + ")");
aSiguiente.MostrarGrafo();
}
}
}
}

Aplicaciones

Aplicaciones Gracias a la teora de grafos se pueden resolver diversos problemas como por ejemplo
la sntesis de circuitos secuenciales, contadores o sistemas de apertura. Se utiliza para diferentes
reas por ejemplo:

Dibujo computacional, en todas las reas de Ingeniera.

Los grafos se utilizan tambin para modelar trayectos como el de una lnea de autobs a
travs de las calles de una ciudad, en el que podemos obtener caminos ptimos para el
trayecto aplicando diversos algoritmos como puede ser el algoritmo de Floyd.

Para la administracin de proyectos, utilizamos tcnicas como PERT en las que se modelan
los mismos utilizando grafos y optimizando los tiempos para concretar los mismos.

La teora de grafos tambin ha servido de inspiracin para las ciencias sociales, en especial

para desarrollar un concepto no metafrico de red social que sustituye los nodos por los
actores sociales y verifica la posicin, centralidad e importancia de cada actor dentro de la
red. Esta medida permite cuantificar y abstraer relaciones complejas, de manera que la
estructura social puede representarse grficamente. Por ejemplo, una red social puede
representar la estructura de poder dentro de una sociedad al identificar los vnculos (aristas),
su direccin e intensidad y da idea de la manera en que el poder se transmite y a quines.
Los grafos son importantes en el estudio de la biologa y hbitat. El vrtice representa un
hbitat y las aristas (o "edges" en ingls) representa los senderos de los animales o las
migracines. Con esta informacin, los cientficos pueden entender cmo esto puede cambiar
o afectar a las especies en su hbitat.
Se emplea en problemas de control de produccin, para proyectar redes de ordenadores, para
disear mdulos electrnicos modernos y proyectar sistemas fsicos con parmetros
localizados (mecnicos, acsticos y elctricos).
Se usa para la solucin de problemas de gentica y problemas de automatizacin de la
proyeccin (SAPR). Apoyo matemtico de los sistemas modernos para el procesamiento de la
informacin. Acude en las investigaciones nucleares (tcnica de diagramas de Feynman).

11

Algoritmos importantes utilizados en grafos:

Algoritmo de bsqueda en anchura (BFS)

Algoritmo de bsqueda en profundidad (DFS)

Algoritmo de bsqueda A*

Algoritmo del vecino ms cercano

Ordenacin topolgica de un grafo

Algoritmo de clculo de los componentes fuertemente conexos de un grafo

Algoritmo de Dijkstra

Algoritmo de Bellman-Ford

Algoritmo de Prim

Algoritmo de Ford-Fulkerson

Algoritmo de Kruskal

Algoritmo de Floyd-Warshall

12