Está en la página 1de 18

UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS


ESTRUCTURA DE DATOS (IS-241)

LABORATORIO NRO. 12

GRAFOS
1. OBJETIVOS DE LABORATORIO
1.1. Utilizar la estructura de datos no lineal grafos para almacenar y recuperar elementos.
1.2. Implementar el grafo con matriz de adyacencia y listas de adyacencia.
1.3. Implementar las operaciones básicas del grafo.

2. REVISIÓN TEÓRICA
2.1. Grafo

Un grafo G = (V, A) es un par formado por un conjunto de vértices o nodos, V, y un


conjunto de arcos o aristas, A. Cada arco es el par (u, w), siendo u, w dos vértices
relacionados.

La figura 2.1 muestra un grafo formado por vértices V = {1,4,5,7,9} y el conjunto de


arcos A = {(1,4), (4,1), (5,1), (1,5), (7,9), (9,7), (7,5), (5,7), (4,9), (9,4)}.

Figura 2.1 Grafo dirigido

2.2. Conceptos básicos de grafos


A continuación, se presenta algunos conceptos más importantes relacionados con la teoría
de grafos:
Concepto Descripción
Grado de un vértice El grado de un vértice v, escrito como grado(v), es el número
de aristas que contienen a v.
Lazo o bucle Un lazo o bucle es una arista que conecta a un vértice consigo
mismo; es decir, a=(u, u).
Camino Un camino P de longitud n se define como la secuencia de n
vértices que se debe seguir para llegar del vértice v1 (origen) al
Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
vértice vn (destino).
Camino cerrado El camino P es cerrado si el primero y último vértices son
iguales; es decir, si v1 = vn.
Camino simple El camino es simple si todos sus nodos son distintos, con
excepción del primero y del último, que pueden ser iguales; es
decir, P es simple si v1, v2, …, son iguales.
Ciclo Un ciclo es un camino simple cerrado de longitud o mayor. Un
ciclo de longitud k se llama -ciclo.
Grafo conexo Es conexo si existe un camino simple entre cualesquiera dos de
sus nodos.
Grafo árbol Un grafo G es de tipo árbol o árbol libre si G es un grafo conexo
sin ciclos.
Grafo completo Es completo si cada vértice v de G es adyacente a todos los
demás vértices de G. Un grafo completo de n vértices tendrá
n(n+1)/2 aristas.
Tabla 2.1 Conceptos básicos de grafos

2.3. Tipos de grafos


2.3.1. Grafo no dirigido
El grafo es no dirigido si las aristas (arcos) están formados por pares de vértices (nodos)
no ordenados, no apuntados; se representa con un segmento uniendo los nodos, u – v. El
grafo de la Figura 2.1 es no dirigido.

2.3.2. Grafo dirigido


Un grafo es dirigido, también denominado digrafo, si los pares de vértices (nodos) que
forman los arcos son ordenados; se representan con una flecha que indica la dirección de
la relación, u → v. El grafo de la Figura 2.2, que consta de los vértices V = {C, D, E, F,
H} y de los arcos A = {(C, D), (D, F), (E, H), (H, E), (E, C)} forma el grafo dirigido G =
{V, A}.

Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)

Figura 2.2 Grafo dirigido


2.4. Operaciones básicas
Las operaciones básicas para construir la estructura grafo y, en general, modificar sus
elementos. Su realización depende de la representación elegida (matriz de adyacencia, o
lista de adyacencia).
a. arista (u, v). Añade el arco o arista (u, v) al grafo
b. aristaPeso (u, v, w). Para un grafo valorado, añade el arco (u, v) al grafo y el
coste del arco, w.
c. borraArco (u, v). Elimina del grafo el arco (u, v)
d. adyacente (u, v). Operación que devuelve cierto si los vértices u, v forman un
arco.
e. nuevoVértice (u). Añade el vértice u al grafo G.
f. borraVértice (u). Elimina el vértice u del grafo G

2.5. Implementación de los grafos


Para trabajar con los grafos y aplicar algoritmos que permitan encontrar propiedades entre
los nodos hay que pensar cómo representarlo en memoria interna, qué tipos o
estructura de datos se deben utilizar para considerar los nodos y los arcos. Se puede elegir:
a. Una representación secuencial, mediante un array bidimensional, conocida como
matriz de adyacencia.
b. Una representación dinámica, mediante una estructura multienlazada, denominada
listas de adyacencia.

La elección de una representación u otra depende del tipo de grafo y de las operaciones
que se vayan a realizar sobre los vértices y arcos. Para un grafo denso lo mejor es
utilizar una matriz de adyacencia. Para un grafo disperso, se suelen utilizar listas de
adyacencia que se ajustan al número de arcos.

Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
2.5.1. Matriz de adyacencia

Sea G = (V, A) un grafo de n nodos, siendo V = {v0, v1, …, vn-1} el conjunto de nodos,
y A = {(vi, vj)} el conjunto de arcos. Los nodos están numerados consecutivamente de 0
a n-1. La representación de los arcos se hace con una matriz A de nxn elementos,
denominada matriz de adyacencia, tal que todo elemento aij puede tomar los valores:

1 𝑠𝑖 ℎ𝑎𝑦 𝑢𝑛 𝑎𝑟𝑐𝑜 (𝑣𝑖 , 𝑣𝑗 )


𝑎𝑖𝑗 = {
0 𝑠𝑖 𝑛𝑜 ℎ𝑎𝑦 𝑎𝑟𝑐𝑜 (𝑣𝑖 , 𝑣𝑗 )

A continuación, se presenta la presenta la matriz de adyacencia, dado el grafo dirigido de


la Figura 2.3. Suponiendo que el orden de los vértices es {D, F, K, L, R}.

Figura 2.3 Grafo dirigido con los vértices {D, F, K, L, R}

Importante: Una matriz de adyacencia se usa para un grafo denso (tiene la mayoría de
los arcos posibles).

2.5.2. Listas de adyacencia

Para grafos dispersos, la matriz de adyacencia ocupa el mismo espacio que si el grafo
tuviera muchos arcos (grafo denso). Cuando ocurre esto, se elige la representación del
grafo con listas enlazadas, denominadas listas de adyacencia.

Las listas de adyacencia son una estructura multienlazada formada por una tabla
directorio en la que cada elemento representa un vértice del grafo, del cual emerge una
lista enlazada con todos sus vértices adyacentes. Es decir, cada lista representa los arcos

Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
con el vértice origen del nodo de la lista directorio, por eso se llama lista de adyacencia.

A continuación, se presenta un grafo dirigido:

Figura 2.4 Grafo dirigido

La representación mediante listas de adyacencia de la Figura 2.4 es la siguiente:

Figura 2.5 Listas de adyacencia de la Figura 2.4

Importante: Listas de adyacencia se usa para un grafo disperso (tiene, relativamente


pocos arcos).

3. DESARROLLO DE LABORATORIO

En este apartado vamos a implementar el grafo con matriz de adyacencia y con listas de
adyacencia, para ello creamos un nuevo proyecto llamado Laboratorio12.

3.1. (Consola) Implementación del grafo con matriz de adyacencia

En el proyecto Laboratorio12, creamos un paquete llamado matriz. A continuación, se


crea las siguientes clases:

3.1.1 Clase Ciudad


La clase Ciudad representa al elemento a ser insertado en el grafo, por lo que es una clase

Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
que se va a utilizar en la matriz de adyacencia y listas de adyacencia. Por lo tanto, debe
ser creada en un paquete llamado Commons.

public class Ciudad {

// Atributos de la clase
private int idCiudad;
private String nombre;
private int numHabitantes;

// Constructor vacio
public Ciudad() {
}

// Constructor con 4 parámetros


public Ciudad(int idCiudad, String nombre, int
numHabitantes) {
this.idCiudad = idCiudad;
this.nombre = nombre;
this.numHabitantes = numHabitantes;
}

// Métodos get y set


public int getIdCiudad() {
return idCiudad;
}

public void setIdCiudad(int idCiudad) {


this.idCiudad = idCiudad;
}

public String getNombre() {


return nombre;
}

public void setNombre(String nombre) {


this.nombre = nombre;
}

public int getNumHabitantes() {


return numHabitantes;
}

public void setNumHabitantes(int numHabitantes) {


this.numHabitantes = numHabitantes;
Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
}

// Método toString
@Override
public String toString() {
return "Ciudad{" + "idCiudad=" + idCiudad + ",
nombre=" + nombre + ", numHabitantes=" + numHabitantes + '}';
}

3.1.2 Clase Vertice

La clase Vertice representa un nodo del grafo, y tiene las siguientes propiedades:

• valor (Ciudad). Representa la información del vértice.

• numVertice. Representa el número de vértice.

El constructor inicializa el valor y pone como número de vértice -1; el método que
añade el vértice al grafo establece el número que le corresponda.

public class Vertice <Tipo> {

Tipo valor; // Información del vértice


int numVertice; // Número de vértice

// Inicializa el valor y pone como número de vértice -1


public Vertice(Tipo valor) {
this.valor = valor;
this.numVertice = -1;
}

// Operaciones
}

En la clase Vertice, cree el método nomVertice(), este método devuelve la información


del vértice:

// Devuelve la información del vértice


public Tipo nomVertice(){
return valor;
Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
}

En la clase Vertice, cree el método equals(), este método comprueba si dos vértices son
iguales:

// True, si dos vértices son iguales


public boolean equals(Vertice n){
return valor.equals(n.valor);
}

En la clase Vertice, cree el método asigVertice(), este método establece el número de


vértices:

// Establece el número de vértices


public void asigVertice(int n){
numVertice = n;
}

En la clase Vertice, cree el método toString(), este método devuelve las características
del vértice:

// Características del vértice


@Override
public String toString() {
return valor + " (" + numVertice + ")";
}

3.1.3 Clase GrafoMatriz

La clase GrafoMatriz define la matriz de adyacencia, el array de vértices y los métodos


como añadir nodos y arcos al grafo, y tiene las siguientes propiedades:

• numVerts. Representa número de vértices.

• maxVerts. Representa el número máximo de vértices.

• verts. Representa al Array de vértices.

• matAd. Representa a la matriz de adyacencia.

El constructor sin parámetros crea la matriz de adyacencia para un máximo de vértices


preestablecido; el otro constructor tiene un parámetro con el máximo número de
vértices.

Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)

public class GrafoMatriz <Tipo> {

int numVerts; // Número de vértices


static final int maxVerts = 20; // Máximo de vértices
Vertice[] verts; // Array de vértices
int[][] matAd; // Matriz de adyacencia

// Crea la matriz de adyacencia para un máximo de vértices


public GrafoMatriz() {
this(maxVerts);
}

// Tiene un parámetro con el número máximo de vértices


public GrafoMatriz(int mx) {
matAd = new int[mx][mx];
verts = new Vertice[mx];
for (int i = 0; i < mx; i++) {
for (int j = 0; i < mx; i++) {
matAd[i][j] = 0;
}
}
numVerts = 0;
}

// Operaciones

En la clase GrafoMatriz, cree el método numeroDeVertices(), este método devuelve el


número de vértices:

// Devuelve el número de vértices del grafo


public int numeroDeVertices() {
return numVerts;
}

En la clase GrafoMatriz, cree el método vertices(), este método devuelve los vértices
del grafo:

// Devuelve los vértices


public Vertice[] vertices() {
return verts;
}

Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
En la clase GrafoMatriz, cree el método nuevoVertice(), este método añade un nuevo
vértice al grafo:

// Añade un nuevo vértice


public void nuevoVertice(Tipo nom) {
boolean esta = numVertice(nom) >= 0;
if (!esta) {
Vertice v = new Vertice(nom);
v.asigVertice(numVerts);
verts[numVerts++] = v;
}
}

En la clase GrafoMatriz, cree el método nuevoArco, este método añade un nuevo arco
a partir de los nombres de vértice:

// Añade un nuevo arco a partir de los nombres de vértice


public void nuevoArco(Tipo a, Tipo b) throws Exception {
int va, vb;
va = numVertice(a);
vb = numVertice(b);
if (va < 0 || vb < 0) {
throw new Exception("Vértice no existe");
}
matAd[va][vb] = 1;
}

En la clase GrafoMatriz, cree el método adyacente, este método determina si dos


vértices forman un arco:

// Determina si dos vértices forman un arco


boolean adyacente(Tipo a, Tipo b) throws Exception {
int va, vb;
va = numVertice(a);
vb = numVertice(b);
if (va < 0 || vb < 0) {
throw new Exception("Vértice no existe");
}
return matAd[va][vb] == 1;
}

3.1.4 Clase principal PruebaGrafoMatriz

Creamos la clase principal en el paquete Matriz con nombre PruebaGrafoMatriz, con


la finalidad de probar las operaciones del grafo implementadas con la matriz de
Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
adyacencia.

/**
*
* @author fbarrientos
*/
public class PruebaGrafoMatriz {

/**
* @param args the command line arguments
*/
public static void main(String[] args) throws Exception {
// Número de nodos (vértices)
int n = 4;

// Al constructor de la clase GrafoMatriz se le pasa


// el número de nodos del grafo
GrafoMatriz gm = new GrafoMatriz(n);

// Se crea objetos de tipo Ciudad


Ciudad c1 = new Ciudad(1, "Ayacucho", 600000);
Ciudad c2 = new Ciudad(2, "Lima", 10000000);
Ciudad c3 = new Ciudad(3, "Huancayo", 900000);
Ciudad c4 = new Ciudad(4, "Arequipa", 3000000);

// Se añade los vértices al grafo


gm.nuevoVertice(c1);
gm.nuevoVertice(c2);
gm.nuevoVertice(c3);
gm.nuevoVertice(c4);

// Se añade los arcos al grafo a partir de pares de


vértices
gm.nuevoArco(c1, c2);
gm.nuevoArco(c1, c3);
gm.nuevoArco(c2, c3);
gm.nuevoArco(c3, c4);

System.out.println("Vértices del grafo: ");


Vertice [] vs = new Vertice[n];
vs = gm.vertices();
for (int i = 0; i < n; i++) {
System.out.println(vs[i] + " ");
}

// Número de vértices del grafo


Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
System.out.println("\nNro de vértices del grafo: " +
gm.numeroDeVertices());

// Determina si dos vértices forman un arco


System.out.println("\nForman un arco? " +
gm.adyacente(c1, c4));

}
Explique la salida:

3.2. (Consola) Implementación del grafo con listas de adyacencia

En el proyecto Laboratorio12, creamos un nuevo paquete llamado Listas. Y a


continuación, se crea las siguientes clases:

3.2.1. Clase VerticeLista

La clase VerticeLista representa un nodo del grafo, y tiene las siguientes propiedades:

• valor (Ciudad). Representa la información del vértice.

• numVertice. Representa el número de vértice.

• lad. Representa la lista de adyacencia. La lista de adyacencia de un vértice u,


consta de tantos nodos como arcos tiene por origen u.

Además, la clase VerticeLista tiene métodos: equals(), asigVert(), etc.

public class VerticeLista <Tipo> {

Tipo valor;
int numVertice;
Lista lad;

public VerticeLista(Tipo v) {
valor = v;
numVertice = -1;
lad = new Lista();
Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
}

public boolean equals(Object d) {


VerticeLista dos = (VerticeLista) d;
return valor.equals(dos.valor);
}

public void asigVert(int n) {


numVertice = n;
}

public Tipo nomVertice() {


return valor;
}

@Override
public String toString() {
return valor + " (" + numVertice + ")";
}

3.2.2. Clase Arco

Un nodo de la lista contiene un objeto de la clase Arco, en la cual se guarda el vértice


destino v del arco que tiene su origen en u. La clase Arco tiene las siguientes propiedades:

• destino. Representa el vértice destino.

• peso. Representa el peso asociado al arco (para grafos valorados).

public class Arco {

int destino;
double peso;

public Arco(int d) {
destino = d;
}

public Arco(int d, double p) {


this(d);
peso = p;
Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
}

public int getDestino() {


return destino;
}

public boolean equals(Object n) {


Arco a = (Arco) n;
return destino == a.destino;
}

3.2.3. Clase GrafoLista

La clase GrafoLista define la tabla de vértices con sus respectivas listas de adyacencia.
Además, implementa las operaciones básicas para crear un grafo: añadir un vértice,
insertar un arco, dar de baja un vértice y sus arcos, etc.

La clase GrafoLista tiene las siguientes propiedades:

• numVerts. Representa el número de vértices.

• maxVerts. Representa el máximo de vértices.

• tablAdc. Representa la tabla de vértices con sus respectivas listas de adyacencia.

public class GrafoLista <Tipo> {

int numVerts;
static int maxVerts = 20;
VerticeLista[] tablAdc;

public GrafoLista(int mx) {


tablAdc = new VerticeLista[mx];
numVerts = 0;
maxVerts = mx;
}

public GrafoLista() {
this(maxVerts);
}

public int numeroDeVertices() {


Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
return numVerts;
}

public VerticeLista[] vertices() {


return tablAdc;
}

//La operación listaAdyc() devuelve la lista de adyacencia


del vértice v.
public Lista listaAdyc(int v) throws Exception {
if (v < 0 || v >= numVerts) {
throw new Exception(" Vértice fuera de rango ");
}
return tablAdc[v].lad;
}

public void nuevoVertice(Tipo nom) {


boolean esta = numVertice(nom) >= 0;
if (!esta) {
VerticeLista v = new VerticeLista(nom);
v.asigVert(numVerts);
tablAdc[numVerts++] = v;
}
}

// numVertice()busca el vértice en la tabla. Devuelve -1


si no lo encuentra:
public int numVertice(Tipo nm) {
VerticeLista v = new VerticeLista(nm);
boolean encontrado = false;
int i = 0;
for (; (i < numVerts) && !encontrado;) {
encontrado = tablAdc[i].equals(v);
if (!encontrado) {
i++;
}
}
return (i < numVerts) ? i : -1;
}

public void nuevoArco(Tipo a, Tipo b) throws Exception {


if (!adyacente(a, b)) {
int va = numVertice(a);
int vb = numVertice(b);
if (va < 0 || vb < 0) {
throw new Exception("Vértice no existe");
}
Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
Arco ab = new Arco(vb);
tablAdc[va].lad.insertarCabezaLista(ab);
}
}

public void borrarArco(Tipo a, Tipo b) throws Exception {


int va, vb;
va = numVertice(a);
vb = numVertice(b);
if (va < 0 || vb < 0) {
throw new Exception("Vértice no existe");
}
Arco ab = new Arco(vb);
tablAdc[va].lad.eliminar(ab);
}

//
boolean adyacente(Tipo a, Tipo b) throws Exception {
int va, vb;
va = numVertice(a);
vb = numVertice(b);
if (va < 0 || vb < 0) {
throw new Exception("Vértice no existe");
}
if (tablAdc[va].lad.buscarLista(new Arco(vb)) != null)
{
return true;
} else {
return false;
}
}

3.2.4. Clase PruebaGrafoLista

Creamos la clase principal en el paquete Listas con nombre PruebaGrafoLista, con la


finalidad de probar las operaciones del grafo implementadas con las listas de adyacencia.

public class PruebaGrafoLista {

/**
* @param args the command line arguments
*/
public static void main(String[] args) throws Exception {
Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
int n = 4;

// Al constructor de la clase GrafoLista se le pasa


// el número de nodos del grafo
GrafoLista gl = new GrafoLista(4);

// Se crea objetos de tipo Ciudad


Ciudad c1 = new Ciudad(1, "Ayacucho", 600000);
Ciudad c2 = new Ciudad(2, "Lima", 10000000);
Ciudad c3 = new Ciudad(3, "Huancayo", 900000);
Ciudad c4 = new Ciudad(4, "Arequipa", 3000000);

// Se añade los vértices al grafo


gl.nuevoVertice(c1);
gl.nuevoVertice(c2);
gl.nuevoVertice(c3);
gl.nuevoVertice(c4);

// Se añade los arcos al grafo a partir de pares de


vértices
gl.nuevoArco(c1, c2);
gl.nuevoArco(c1, c3);
gl.nuevoArco(c2, c3);
gl.nuevoArco(c2, c4);

System.out.println("Vértices del grafo: ");


VerticeLista [] vs = new VerticeLista[n];
vs = gl.vertices();
for (int i = 0; i < n; i++) {
System.out.println(vs[i] + " ");
}

System.out.println("\nLista de adyacencia del


vértice:");
Lista l = new Lista();
l = gl.listaAdyc(1);
l.visualizar();

Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa
UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA
ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS
ESTRUCTURA DE DATOS (IS-241)
3.3. Reto
Diseñe las GUI’s para probar las operaciones básicas de grafos implementadas con
Matriz de adyacencia y Listas de adyacencia (listas enlazadas).

3.4. Repositorio del código fuente

GitHub: https://github.com/fredybarrientos/LAB.-IS241-ESTRUCTURA-DE-DATOS-
2020-I.git

3.5. Ejercicios propuestos

3.5.1. Se dispone de un grafo no dirigido poco denso. Se elige la representación en memoria


mediante listas de adyacencia. Escribir un programa en el que se de entrada a los vértices
del grafo y sus arcos y se determine si el grafo tiene ciclos. En caso positivo, listar los
vértices que forman un ciclo.

3.5.2. Supóngase un grafo no dirigido y conexo, escribir un programa que encuentre un


camino que vaya a través de todas las aristas exactamente una vez en cada dirección.

3.5.3. Una región está formada por 12 comunidades. Se establece la relación de


desplazamiento de personas en las primeras horas del día. Así, la comunidad A está
relacionada con la comunidad B si desde A se desplazan n personas a B, de igual forma
puede haber relación entre B y A si se desplazan m personas de B hasta A.
• Escribir un programa que represente el grafo descrito mediante listas de
adyacencia.
• Determinar si el grafo formado tiene fuentes o sumideros.

Docentes:
Ing. Jennifer Rocío Pillaca De La Cruz
Ing. Fredy Barrientos
Ing. Alberto Lapa

También podría gustarte