Estructura de Datos No

Lineales

Ciencias de la computación e
Inteligencia Artificial Ejercicios matrices

 Sebastián Florido
Cód. Fecha: 16-09-2021
 Carlos Rojas

Enunciado

Aplicación Lista de adyacencia

Implementar una aplicación en Java, para la representación de grafos mediante listas de adyacencia para:

Grafo etiquetado y dirigido (Valor aleatorio del peso entre 1 y 15)

La siguiente grafica presenta el diagrama de clases que modela la aplicación.

Ejemplo.
Entrada
Grafo: V={1,2,3,4,5}
E={(1,2),(1,3),(2,3),(2,4),(2,1),(2,5),(3,1),(3,2),(4,5),(4,2),(5,2),(5,4)}

Salida
Lista de adyacencia Grafo no dirigido

1 2 3
2 3 4 1 5
3 1 2
4 5 2
5 2 4

Ejemplo de una lista de adyacencia

Lista de requerimientos
Requerimientos funcionales
1. El número de vértices es determinado por el usuario.
2. La conexión entre vértices la determina el usuario, y el peso se escoge aleatoriamente entre 1 y 15
Requerimientos No funcionales
 Incorporar el manejo de excepciones a la aplicación
 Elaborado en java
 Utilizar MVC
 Generación de documentación
Productos de entrega:
 El documento técnico de la aplicación en formato Word editable (tener en cuenta ortografía y redacción)
 Aplicación en java
 Socialización del ejercicio

Documentación Requerimientos Funcionales

Nombre 1. El número de vértices es determinado por el usuario

Descripción Se creara un grafo(matriz) con el número de vértices que ingreso el usuario

Entrada Numero de vértices

Salida Grafo creado con el número de vértices ingresado por el usuario

2. Las conexiones entre vértices las determina el usuario, y el peso se

Nombre
escoge aleatoriamente entre el 1 y el 15
Descripción El usuario digita que vértices están conectados

Entrada Grafo sin conexiones

Salida Grafo con vértices conectados entre sí y con un peso aleatorio entre el 1 y 15

Diagrama de casos de uso UML

Nodo
-vertice: int Grafo
-siguiente: Nodo
-arreglo: Nodo[*]
+Nodo()
+getVertice(): int +Grafo()
+setVertice(vertice: int) +agregar(i: int, dato: int)
+getSiguiente(): Nodo +listar()
+setSiguiente(siguiente: Nodo)

ListaAdyacenciaGrafo

+main(args: String)
Diagrama de clases UML

Programa fuente
Control
public class Launcher {

private EntradaSalida lector;

private Modelo m;

public Launcher() {
lector = new EntradaSalida();
}

public void ingresar()

{

lector.imprimirInformacion("Ingrese el numero de vertices que tiene el grafo");

int numerovertices = lector.leernumero();

int[] arreglo = new int[numerovertices];

lector.imprimirInformacion("\nIngresar vertices");

for(int i=0; i<numerovertices;i++)

{
lector.imprimirInformacion("Vertice "+(i+1));
arreglo[i]=lector.leernumero();

for(int j=0; j<i;j++)

{
if(arreglo[j]==arreglo[i])
{
lector.imprimirInformacion("Ese vertice ya fue ingresado\n");
i=i-1;
}
}
}
m = new Modelo(arreglo);

public void conectar(){

lector.imprimirInformacion("\nIngrese 0 cuando ya no hallan mas conexiones");

int masconexiones = 1;
lector.imprimirInformacion("\nPara ingresar los vertices debe ingresarlos asi: salida,llegada. EJ: 1,2");

do
{
try{
lector.imprimirInformacion("\nVertices");
String vertices = lector.leerTexto();

String[] pedir = vertices.split(",");

int v1 = Integer.parseInt(pedir[0]);
int v2 = Integer.parseInt(pedir[1]);

m.agrega(v1, v2);

lector.imprimirInformacion("\ncontinuar?");
masconexiones = lector.leernumero();
}catch(Exception e)
{
System.out.println("\nVertices mal ingresados");
}
 }while(masconexiones!=0);

m.mostrar();

}
}

Modelo
public class Modelo {

private Nodo[] arreglo;

public Modelo(int[] vertice){

this.arreglo = new Nodo[vertice.length];

for(int i=0; i<vertice.length;i++)

{
Nodo n = new Nodo(vertice[i]);
arreglo[i]=n;
}
}

public void agrega(int v, int dato){

boolean encontrado = false;

for(int i=0; i<arreglo.length;i++){

if(arreglo[i].getVertice()==v)
{
for(int j=0; j<arreglo.length;j++)
{

if(arreglo[j].getVertice()==dato)
{
arreglo[i].agregar(dato);
encontrado=true;
}
}
}
}

if(encontrado==false)
{
System.out.println("Alguno de los vertices que ingreso no esta en los vertices ingresasdos");
}
}

public void mostrar(){

System.out.println("\nGrafo dirigido");
System.out.println("Lista de adyacencia\n");

for(int i=0; i<arreglo.length; i++)

 {
arreglo[i].mostrar();
System.out.println(" ");
}
}
}

vista
public class EntradaSalida {

private Scanner leer;

public EntradaSalida() {
leer = new Scanner(System.in);
}

public String leerTexto() {

String dato = "";
while (dato.length() == 0) {
dato = leer.nextLine();
}
return dato;
}
public int leernumero(){
int dato;
dato = leer.nextInt();
return dato;
}

public void imprimirInformacion(String msg) {

System.out.println(msg);
}
}

Pruebas
 Herramientas ingenieriles
 StartUml
 Java
 Netbeans
 Word

Conclusiones
 Gracias a la implementación de este programa se pudo saciar la necesidad de un mejor control y supervisión de
la actualización de datos de los estudiantes del departamento de ingeniería y ciencias exactas, puesto que hemos
proporcionado la respectiva información para que de esta manera sea mas fácil la obtención de su información
básica y la gestión de sus datos.
Hemos entendido de una mejor manera el uso y aplicación de la estructura modelo, vista, controlador, ya que se
proporciona la información deseada por el usuario sin la intervención de la demostración de aquellos procesos
internos y la segmentación de las diferentes estructuras usadas e implementadas para que el sistema funcione
adecuadamente. Lo anterior basándonos en el “Divide y vencerás”.

Bibliografía
https://docs.oracle.com/javase/10/docs/api/overview-summary.html