Is241 Labortaorio 12 Grafos

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
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. Alberto Lapa

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. Alberto Lapa
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. Alberto Lapa
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:
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. Alberto Lapa
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. Alberto Lapa
}
// 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. Alberto Lapa
}
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
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. Alberto Lapa
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. Alberto Lapa
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) {
}
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. Alberto Lapa
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);
// Se añade los arcos al grafo a partir de pares de

vértices
gm.nuevoArco(c1, c2);
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. Alberto Lapa
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. Alberto Lapa
}
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
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. Alberto Lapa
}
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. Alberto Lapa
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) {
}
Docentes:
Ing. Alberto Lapa
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) {
}
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) {
}
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. Alberto Lapa
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);
// Se añade los arcos al grafo a partir de pares de

vértices
gl.nuevoArco(c1, c2);
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. Alberto Lapa
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. Alberto Lapa

Idioma

Is241 Labortaorio 12 Grafos

Cargado por

Información del documento

Título original

Derechos de autor

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Is241 Labortaorio 12 Grafos

Título original:

Cargado por

Copyright:

UNIVERSIDAD NACIONAL DE SAN CRISTÓBAL DE HUAMANGA

ESCUELA PROFESIONAL DE INGENIERÍA DE SISTEMAS

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

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

Figura 2.1 Grafo dirigido

2.2. Conceptos básicos de grafos

2.3. Tipos de grafos

2.3.2. Grafo dirigido

Figura 2.2 Grafo dirigido

2.5. Implementación de los grafos

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

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

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

2.5.2. Listas 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

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

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

3.1.1 Clase Ciudad

public class Ciudad {

// Constructor con 4 parámetros

// Métodos get y set

public void setIdCiudad(int idCiudad) {

public String getNombre() {

public void setNombre(String nombre) {

public int getNumHabitantes() {

public void setNumHabitantes(int numHabitantes) {

3.1.2 Clase Vertice

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

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

public class Vertice <Tipo> {

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

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

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

// Devuelve la información del vértice

// True, si dos vértices son iguales

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

// Establece el número de vértices

// Características del vértice

3.1.3 Clase GrafoMatriz

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

• 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

public class GrafoMatriz <Tipo> {

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

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

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

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

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

// Devuelve los vértices

// Añade un nuevo vértice

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

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

// Determina si dos vértices forman un arco

3.1.4 Clase principal PruebaGrafoMatriz

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

// Al constructor de la clase GrafoMatriz se le pasa

// Se crea objetos de tipo Ciudad