TEMA 3 MATRICES DE ADYACENCIA, MATRICES DE ADYACENCIA

ETIQUETADA, LISTAS DE ADYACENCIA

Introducción

Una de las maneras más fáciles de implementar un grafo es usar una matriz bidimensional.
En esta implementación de matriz, cada una de las filas y columnas representa un vértice en
el grafo. El valor que se almacena en la celda en la intersección de la fila v y la
columna w indica si hay una arista desde el vértice v al vértice w. Cuando dos vértices están
conectados por una arista, decimos que son adyacentes. (InteractivePython, 2016)

1. Objetivo

Investigar el uso de las matrices de adyacencia y su funcionalidad dentro de la

programación.

Entender cómo es la forma correcta de representar un grafo con la ayuda de las matrices
de adyacencia y las relaciones que esta lleva con las listas de adyacencia.

2. Procedimiento o desarrollo

MATRICES DE ADYACENCIA

Dentro del análisis de algoritmos un punto importante de estudio son las matrices de
adyacencia que es una forma de representar un grafo.

Según el sitio web (MOUSE, 2017). Una matriz cuadrada de n filas x n columnas donde, n es
la máxima cantidad de nodos que tiene el grafo. Es la forma más sencilla de representar un
grafo, pero a la vez, requiere más espacio de memoria que otros métodos, por lo que requiere
al menos n^2 bits de memoria.

¿Cómo construir una Matriz de Adyacencia?

De acuerdo con el sitio web antes citado la forma de construir una matriz de adyacencia,
debemos tomar en cuenta los siguientes aspectos:

 A cada elemento (i, j) se suma 1, cuando exista una arista que una los vértices
(nodos) i y j.
  Si una arista es un bucle, y el grafo es no dirigido, se suma 2 en vez de 1.
 Cada elemento (i, j) valdrá 0, cuando no exista una arista que una los nodos i y j.

Ilustración 1 Ejemplo de Grafo no dirigido

Este grafo consta de 5 vértices (nodos), por tanto nuestra matriz de adyacencia será 5×5

Ilustración 2 matriz de adyacencia 5×5

Completamos para la primera fila de la siguiente manera:

 El nodo 1 no es un bucle, por tanto (1,1), vale 0

 Vemos que del vértice 1 al vértice 2, salen dos aristas, por tanto para (1,2) sumamos
+1 para cada arista, es decir, (1,2) vale 2
  De 1 a 3 existe una arista, (1,3) = 1
 De 1 a 4 existe una arista, (1,4) = 1
 De 1 a 5 no existe ninguna arista, por tanto, (1,5) = 0

Ilustración 3 matriz de adyacencia 5×5

Y para el resto de las filas, tenemos:

Ilustración 4 matriz de adyacencia 5×5

Ahora Algo que podemos notar es que cuando el grafo es no dirigido, la matriz resultante es
simétrica respecto a la diagonal principal.
 Ilustración 5 Ejemplo Grafo dirigido

Para representar un grafo dirigido con una matriz de adyacencia se usan los mismos pasos de
un grafo no dirigido, tomando en cuenta esta vez, la dirección de cada arista.

Ilustración 6 matriz de adyacencia 5×5

Representación en lenguaje java

Siguiendo el ejemplo de este post, la matriz de adyacencia será de tipo entero, sin
pesos, se implementan los métodos mínimos de agregar, remover e imprimir. El código es
sencillo y fácil de entender por lo que no requiere de más comentarios.
𝑝𝑢𝑏𝑙𝑖𝑐 𝑐𝑙𝑎𝑠𝑠 𝑀𝑎𝑡𝑟𝑖𝑧_𝑑𝑒_𝑎𝑑𝑦𝑎𝑐𝑒𝑛𝑐𝑖𝑎 {

𝑝𝑟𝑖𝑣𝑎𝑡𝑒 𝑖𝑛𝑡 𝑛;
𝑝𝑟𝑖𝑣𝑎𝑡𝑒 𝑖𝑛𝑡[][] 𝑚𝑎𝑡𝑟𝑖𝑧;

/∗∗
∗ 𝐶𝑜𝑛𝑠𝑡𝑟𝑢𝑐𝑡𝑜𝑟 𝑑𝑒 𝑐𝑙𝑎𝑠𝑒
∗ @𝑝𝑎𝑟𝑎𝑚 𝑛 𝑛𝑢𝑚𝑒𝑟𝑜 𝑑𝑒 𝑛𝑜𝑑𝑜𝑠
∗/
𝑝𝑢𝑏𝑙𝑖𝑐 𝑀𝑎𝑡𝑟𝑖𝑧_𝑑𝑒_𝑎𝑑𝑦𝑎𝑐𝑒𝑛𝑐𝑖𝑎(𝑖𝑛𝑡 𝑛) {
𝑡ℎ𝑖𝑠. 𝑛 = 𝑛;
𝑚𝑎𝑡𝑟𝑖𝑧 = 𝑛𝑒𝑤 𝑖𝑛𝑡[𝑡ℎ𝑖𝑠. 𝑛][𝑡ℎ𝑖𝑠. 𝑛];
//𝑠𝑒 𝑖𝑛𝑖𝑐𝑖𝑎𝑙𝑖𝑧𝑎 𝑚𝑎𝑡𝑟𝑖𝑧 𝑒𝑛 0
𝑓𝑜𝑟(𝑖𝑛𝑡 𝑖 = 0; 𝑖 < 𝑛; 𝑖 + +){
𝑓𝑜𝑟(𝑖𝑛𝑡 𝑗 = 0; 𝑗 < 𝑛; 𝑗 + +){
𝑚𝑎𝑡𝑟𝑖𝑧[𝑖][𝑗] = 0;
}
}
}

𝑝𝑢𝑏𝑙𝑖𝑐 𝑣𝑜𝑖𝑑 𝑎𝑔𝑟𝑒𝑔𝑎𝑟(𝑖𝑛𝑡 𝑖, 𝑖𝑛𝑡 𝑗){

𝑚𝑎𝑡𝑟𝑖𝑧[𝑖][𝑗] += 1;
}

𝑝𝑢𝑏𝑙𝑖𝑐 𝑣𝑜𝑖𝑑 𝑟𝑒𝑚𝑜𝑣𝑒𝑟(𝑖𝑛𝑡 𝑖, 𝑖𝑛𝑡 𝑗){

𝑖𝑓(𝑚𝑎𝑡𝑟𝑖𝑧[𝑖][𝑗] > 0)
𝑚𝑎𝑡𝑟𝑖𝑧[𝑖][𝑗] −= 1;
}

𝑝𝑢𝑏𝑙𝑖𝑐 𝑣𝑜𝑖𝑑 𝑖𝑚𝑝𝑟𝑖𝑚𝑖𝑟(){

𝑓𝑜𝑟(𝑖𝑛𝑡 𝑖 = 0; 𝑖 < 𝑛; 𝑖 + +){
𝑓𝑜𝑟(𝑖𝑛𝑡 𝑗 = 0; 𝑗 < 𝑛; 𝑗 + +){
𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡( 𝑚𝑎𝑡𝑟𝑖𝑧[𝑖][𝑗] + " " );
 }
𝑆𝑦𝑠𝑡𝑒𝑚. 𝑜𝑢𝑡. 𝑝𝑟𝑖𝑛𝑡𝑙𝑛();
}
}
}

Y ahora implementado la clase anterior con el grafo no dirigido usado como ejemplo en este
post, tenemos lo siguiente:

𝑝𝑢𝑏𝑙𝑖𝑐 𝑠𝑡𝑎𝑡𝑖𝑐 𝑣𝑜𝑖𝑑 𝑚𝑎𝑖𝑛(𝑆𝑡𝑟𝑖𝑛𝑔[] 𝑎𝑟𝑔𝑠) {

𝑀𝑎𝑡𝑟𝑖𝑧_𝑑𝑒_𝑎𝑑𝑦𝑎𝑐𝑒𝑛𝑐𝑖𝑎 𝑚𝑎𝑡𝑟𝑖𝑧 = 𝑛𝑒𝑤 𝑀𝑎𝑡𝑟𝑖𝑧_𝑑𝑒_𝑎𝑑𝑦𝑎𝑐𝑒𝑛𝑐𝑖𝑎 (5);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (0, 1);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (0, 1);
𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (0, 2);
𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (0, 3);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (1, 0);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (1, 0);
𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (1, 4);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (2, 0);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (2, 3);
𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (2, 4);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (3, 0);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (3, 2);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (4, 1);

𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (4, 2);
𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (4, 4);
𝑚𝑎𝑡𝑟𝑖𝑧. 𝑎𝑔𝑟𝑒𝑔𝑎𝑟 (4, 4);
 𝑚𝑎𝑡𝑟𝑖𝑧. 𝑖𝑚𝑝𝑟𝑖𝑚𝑖𝑟 ();
}

Y como salida por consola tendremos: