INGENIERÍA EN SISTEMAS

COMPUTACIONALES

-Reporte de Practicas-
Semestre y Grupo:

03-ISC

Asignatura:

Estructura de Datos

Unidad:

IV.- Estructuras no lineales

Presenta:

226Z0262 - Andrik Herrera Perez

Docente:

I.S.C. Jesús Daniel Castro Orea.

Tlalixcoyan, Ver. A 09 de octubre del 2023.

pág. 1
Contenido
Introducción. ............................................................................................................ 3

Explicación ............................................................................................................... 4
Arco ................................................................................................... 5

Grafos ................................................................................................ 6

Lista_Adyacencia ............................................................................. 8

Nodo_Grafo ..................................................................................... 10

Paquete_Grafos .............................................................................. 11

Interfaz_Grafo ................................................................................. 12

Conclusión ............................................................................................................. 14

pág. 2
 Introducción.
En mi código, desarrolló una estructura para trabajar con gráficos. Empecé creando
la clase ‘Arco’, que representa una conexión entre dos nodos en el gráfico. Los arcos
pueden tener un peso asociado o simplemente ser conexiones sin peso.
Luego, implementé la clase ‘Lista_Adyacencia’, que representa la lista de
adyacencia de un nodo en el gráfico. Esta lista contiene los arcos que conectan el
nodo actual con otros nodos.
La clase ‘Nodo_Grafo’ representa un nodo en el gráfico, con un dato asociado, una
lista de adyacencia y un puntero al siguiente nodo.
La clase principal es ‘Grafo’, que utiliza nudos y arcos para construir la estructura
completa del gráfico. Tiene métodos para agregar nodos, verificar si un gráfico está
vacío, verificar la existencia de un vértice y agregar aristas entre vértices.
Además, creó una interfaz gráfica (‘Interfaz_Grafo’) utilizando ‘JOptionPane’ para
permitir la interacción del usuario con el gráfico. Puedes insertar nodos, insertar arcos
entre nodos existentes y visualizar la representación del gráfico en texto.
Finalmente, en la clase ‘Paquete_Grafos’, inició la interfaz gráfica para que sea
visible al ejecutar el programa.

pág. 3
 Explicación
En ‘Arco’, parece que estás creando una representación de un arco en un gráfico.
Tienes un objeto de destino, un peso y una referencia al siguiente arco.
En ‘Grafo’, define un gráfico que consiste en nodos ( ‘Nodo_Grafo’) y sus
conexiones ( ‘Arco’). Hay métodos para verificar si el gráfico está vacío, si existe un
vértice, agregar una nueva arista (con o sin peso), y agregar un nuevo nodo.
En ‘Lista_Adyacencia’, define una lista de adyacencia que se utiliza para almacenar
los arcos adyacentes a un nodo en particular. Tienes métodos para verificar si la lista
está vacía, agregar una nueva adyacencia (con o sin peso) y convertir la lista a una
cadena de texto.
En ‘Nodo_Grafo’, define un nodo en el gráfico que tiene un dato, una lista de
adyacencia y una referencia al siguiente nodo.
‘Interfaz_Grafo’ Parece ser una interfaz gráfica de usuario para interactuar con el
gráfico. Se pueden insertar nodos y arcos, y la interfaz muestra la representación
textual del gráfico.
‘Paquete_Grafos’ simplemente inicia la interfaz gráfica.
En general, parece un sistema completo para trabajar con gráficos, desde la
representación de arcos y nodos hasta la interfaz de usuario para interactuar con el
gráfico.

pág. 4
 Arco
En este código, la clase ‘Arco’ parece representar un arco de un gráfico. Un arco
generalmente conecta dos nodos en un gráfico y puede tener un peso asociado. En
este caso, el arco tiene una llamada variable ‘destino’ que representa el nodo de
destino, una variable de tipo flotante llamada ‘peso’ para representar el peso del arco,
y una referencia a otro objeto de la clase ‘Arco’ llamado siguiente.
El constructor ‘Arco(Object d)’ crea un arco con un nodo de destino y establece la
referencia al siguiente arco como nula. El segundo constructor ‘Arco(Object d, float
p)’ añade la posibilidad de especificar un peso al crear el arco.
En resumen, esta clase proporciona una estructura básica para representar arcos en
un gráfico, permitiendo flexibilidad al incluir o no información sobre el peso del arco.

pág. 5
 Grafos
Este código en Java define una clase llamada ‘Grafo’ que representa un gráfico no
dirigido.
En esta clase, creó variables de instancia para representar el primer y último nodo
del gráfico. El constructor inicializa estas variables como nulas.
Luego, implementó métodos para verificar si el grafo está vacío y si un vértice
específico ya existe en el grafo. También hay métodos para agregar nuevos nodos al
gráfico y para crear aristas entre nodos.
El método ‘nueva_arista’ permite crear una nueva arista entre dos vértices. También
proporcionó una versión del método que incluye un peso para la arista.
El método ‘nuevo_Nodo’ agrega un nuevo nodo al gráfico, manteniendo el orden de
los nodos.
Finalmente, el método ‘toString’ genera una representación en texto del gráfico,
mostrando la lista de adyacencia de cada nodo.
En resumen, esta clase proporciona funcionalidades básicas para trabajar con un
gráfico no dirigido, permitiendo la creación de nodos, la adición de artistas y la
representación en texto del gráfico.

pág. 6
pág. 7
 Lista_Adyacencia
Este código en Java define una clase llamada ‘Lista_Adyacencia’ que representa
una lista de adyacencia utilizada en gráficos.
En esta clase, declaró dos variables de tipo ‘Arco’ llamadas ‘primero’ y ‘ultimo’.
Estas variables representan el primer y último arco en la lista de adyacencia.
En el constructor de la clase, inicializó ambas variables como nulas, indicando que la
lista está vacía al principio.
He creado un método llamado ‘listaVacia()’ que devuelve true si la lista está vacía,
es decir, si el primer arco es nulo.
Luego, implementó un par de métodos para agregar nuevas adyacencias a la lista.
Uno de ellos toma solo el destino como parámetro, mientras que el otro también
incluye un peso. Ambos métodos verifican si la adyacencia ya existe antes de
agregarla.
La inserción de nuevos nodos en la lista se realiza a través del método privado
‘inserta’, que coloca los nodos en orden alfabético calculando en el destino del arco.
Además, implementó un método de búsqueda llamado ‘adyacente’ que verifica si un
dato dado está presente en la lista de adyacencia.
Finalmente, hay un método ‘toString()’ que devuelve una representación en cadena
de la lista, mostrando los destinos de los arcos en el orden en que fueron agregados.
En resumen, esta clase proporciona funcionalidades para gestionar una lista de
adyacencia en un gráfico, permitiendo agregar nuevas adyacencias, verificar si
existen y obtener una representación en cadena de la lista.

pág. 8
pág. 9
 Nodo_Grafo
Este código en Java define una clase llamada ‘Nodo_Grafo’ que representa un nodo
en una estructura de gráfico.
En este código, creo una clase llamada ‘Nodo_Grafo’. En esta clase, define tres
variables: ‘dato’ para almacenar un objeto, ‘lista’ para representar una lista de
adyacencia y siguientecomo un puntero al próximo nodo en la secuencia.
Además, implemento un constructor que recibe un parámetro de tipo objeto llamado
x. En este constructor, inicializo las variables ‘dato’ y ‘siguiente’, y creo una nueva
instancia de la clase ‘Lista_Adyacencia’ para la variable ‘lista’. Este nodo se utilizará
para construir estructuras de grafo, conectando nodos entre sí mediante listas de
adyacencia.

pág. 10
 Paquete_Grafos
En este código, se crea una clase llamada ‘Paquete_Grafos’ que contiene un método
‘main’. Dentro de este método, se instancia un objeto de la clase ‘Interfaz_Grafo’ y
se hace visible. En resumen, este código parece ser el punto de entrada para la
aplicación relacionada con gráficos, donde se muestra la interfaz gráfica del gráfico.

pág. 11
 Interfaz_Grafo
En primer lugar, se crea una clase llamada Interfaz_Grafoque se extiende de
javax.swing.JFramey contiene una instancia de la clase Grafo.
La interfaz incluye:
• Un campo de texto (‘txt_entrada’) para ingresar datos.
• Un área de texto (‘txta_salida’) para mostrar información del gráfico.
• Dos botones (‘btn_insert_nodo’ y ‘btn_insert_arco’) para insertar nudos y
arcos en el gráfico.
El constructor de la clase configura la apariencia de la interfaz y establece el título.
Además, hay métodos para:
• ‘insertar_nodo()’: Obtiene el texto ingresado, crea un nuevo nodo en el gráfico
con ese dato y actualiza el área de salida.
• ‘insertar_arco()’: Solicita al usuario los nodos de origen y destino para crear
un arco entre ellos en el grafo, y luego actualice el área de salida.
La interfaz se crea utilizando el framework Swing de Java, y las acciones de los
botones están vinculadas a los métodos correspondientes. En resumen, esta interfaz
proporciona una manera sencilla de interactuar con un gráfico al insertar nodos y
arcos.

pág. 12
pág. 13
 Conclusión
En esta implementación de gráficos, creó varias clases esenciales. La clase ‘Arco’
representa las conexiones entre nodos, permitiendo opciones con y sin peso. La clase
‘Lista_Adyacencia’ gestiona las adyacencias de un nodo en particular, asegurando
la no duplicación de conexiones.
La clase ‘Nodo_Grafo’ representa un nodo en el gráfico, con un dato, una lista de
adyacencias y un enlace al siguiente nodo. La clase ‘Grafo’ utiliza nodos y arcos para
construir la estructura completa, con métodos para verificar si el grafo está vacío, si
existe un vértice, agregue nodos y arcos, y represente el grafo como una cadena de
texto.
La clase ‘Interfaz_Grafo’ proporciona una interfaz gráfica de usuario (GUI) para
interactuar con el gráfico, permitiendo la inserción de nodos y arcos. Es una forma
práctica de visualizar y manipular la estructura del gráfico.
Finalmente, la clase ‘Paquete_Grafos’ contiene el método ‘main’ que inicia la
interfaz gráfica al ejecutar el programa.
En resumen, este conjunto de clases forma una implementación sólida de gráficos en
Java, permitiendo la creación, manipulación y visualización de una estructura de
gráficos de manera intuitiva.

pág. 14