1

Plantel: Instituto tecnológico superior de Macuspana.

Nombre y número de control del o de los autores:

Juan Carlos Sánchez López – 19E40038.

Carrera: Ingeniería en sistemas computacionales.

Plan de estudios: 2223-AED1026-1-UB.

Asignatura: AED-1026 - Estructura de Datos.

Semestre: 7mo.

Docente: Jorge Chico Pozo.

Actividad: Reporte de prácticas de la unidad#3.

Fecha de elaboración: 18/10/2022.

Fecha de entrega: 19/10/2022.

 CONTENIDO

INTRODUCCIÓN .................................................................................................................. 3 2
MARCO TEÓRICO ............................................................................................................... 4
PRACTICA ............................................................................................................................ 9
RESULTADOS .................................................................................................................... 21
CONCLUSIÓN .................................................................................................................... 24
 INTRODUCCIÓN

En esta unidad vimos estructuras lineales de datos que se caracterizan porque sus elementos 3
en secuencia, relacionados en forma lineal, uno luego del otro. Cada elemento de la estructura
puede estar conformado por uno o varios subelementos o campos que pueden pertenecer a
cualquier tipo de dato, pero que normalmente son tipos básicos.

Una estructura lineal de datos o lista está conformada por ninguno, uno o varios elementos
que tienen una relación de adyacencia ordenada donde existe un primer elemento,
seguido de un segundo elemento y así sucesivamente hasta llegar al último. El tipo de dato
de los elementos puede ser cualquiera, pero debe ser el mismo tipo para todos. El valor
contenido en los elementos puede ser el mismo o diferente. En estas estructuras se realizan
operaciones de agregar y/o eliminar elementos a la lista según un criterio particular. Sobre la
base de la forma y el lugar de la realización de estas operaciones en la misma,
las listas se clasifican en listas de acceso restringido y listas de acceso no restringido. Las
listas de acceso restringido son las pilas y colas. En las pilas, las operaciones de acceso se
realizan por un único extremo de la lista, al cual normalmente se denomina tope de la pila.
En las colas, estas operaciones se realizan por ambos extremos de la lista llamados
generalmente, inicio y fin de la cola. Las listas de acceso no restringido, denominadas listas,
son el tipo más general, al cual se considera como la superclase de las otras clases de listas,
en específico de las pilas, colas y dipolos. Haciendo la jerarquía de clases adecuada para estas
estructuras, se tiene que la lista es la clase raíz de la jerarquía que tiene como subclases la
pila y cola.
 MARCO TEÓRICO

Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de 4
acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero
en salir) que permite almacenar y recuperar datos. Se aplica en multitud de ocasiones en
informática debido a su simplicidad y ordenación implícita en la propia estructura.

Representación gráfica de una pila:

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca
un objeto en la pila, y su operación inversa, retirar (o des apilar, pop), que retira el último
elemento apilado.
En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto
apilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención
de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con
anterioridad), que pasa a ser el nuevo TOS.
5

Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre
una pila de platos, y una operación retirar a retirarlo.

Las pilas suelen emplearse en los siguientes contextos:

❖ Reconocedores sintácticos de lenguajes independientes del contexto

❖ Implementación de recursividad.

Operaciones básicas de las pilas

Vamos a estudiar las principales operaciones a realizar sobre una pila, insertar y borrar.

1.- Insertar.

En primer lugar, hay que decir que esta operación es muy comúnmente denominada push.

La inserción en una pila se realiza en su cima, considerando la cima como el último elemento
insertado. Esta es una de las particularidades de las pilas, mientras el resto de estructuras de
datos lineales se representan gráficamente en horizontal, las pilas se representan
verticalmente. Por esta razón es por lo que se habla de cima de la pila y no de cola de la cima.
Aunque en el fondo sea lo mismo, el último elemento de la estructura de datos.

Las operaciones a realizar para realizar la inserción en la pila son muy simples, hacer que el
nuevo nodo apunte a la cima anterior, y definir el nuevo nodo como cima de la pila.
Vamos a ver un ejemplo de una inserción:

Al insertar sobre esta pila el elemento 0, la pila resultante sería:

2.- Borrar

Esta operación es normalmente conocida como pop. Cuando se elimina un elemento de la

pila, el elemento que se borra es el elemento situado en la cima de la pila, el que menos
tiempo lleva en la estructura.

Las operaciones a realizar son muy simples, avanzar el puntero que apunta a la cima y extraer
la cima anterior. Si aplicamos la operación pop a la pila de 4 elementos representada arriba
el resultado sería:
¿Qué son las colas?

Las colas están formadas por nodos de la misma forma que las listas. Los nodos de las colas
también están enlazados entre sí como las listas. Las colas no guardan ningún orden, como
tampoco lo guardan las listas no ordenadas. ¿Qué es entonces lo que diferencia a una lista de 7

una cola? Pues lo que diferencia estas dos estructuras de datos es la forma de añadir y de
eliminar elementos de una cola.

Una cola es una estructura de datos FIFO, acrónimo de First In First Out, o lo que es lo
mismo, el primero en entrar es el primero en salir. Esto implica que en las colas siempre se
inserta elementos por el final (cola) y siempre se extraen elementos por el principio(cabeza).

Los ejemplos típicos de colas son las colas de personas para, por ejemplo, compra de
entradas. En esta cola humana el primero en llegar es el primero en marcharse. Pues así se
comportan las colas informáticas.

Operaciones básicas de las colas.

Pues en las colas como en toda estructura de datos las operaciones principales son insertar y
eliminar, aunque en varias implementaciones de colas puedan recibir nombres diferentes.

1.- Insertar.

La inserción en las colas se realiza por la cola de las mismas, es decir, se inserta al final de
la estructura.

Para llevar a cabo esta operación únicamente hay que reestructurar un par de punteros, el
último nodo debe pasar a apuntar al nuevo nodo (que pasará a ser el último) y el nuevo nodo
pasa a ser la nueva cola de la cola.
Vamos a verlo gráficamente sobre la siguiente cola:

8
Si a esta cola le añadimos el elemento 0, la cola resultante sería:

2.- Borrar

El borrado es una operación muy simple en las colas. Esta operación supone extraer la cabeza
de la cola, ya que es el elemento que más tiempo lleva en la estructura. Para llevar a cabo
esta operación únicamente hay que extraer el elemento situado en la cabeza de la cola y
avanzar el puntero cabeza una posición, para que de esta forma la nueva cabeza sea el
segundo elemento que más tiempo lleva en la cola.

Si realizamos la operación eliminar sobre la cola de 4 elementos del último gráfico el

resultado sería el siguiente:

Una diferencia importante entre las colas y las listas, es que en las colas no se puede borrar
un elemento cualquiera, se borra siempre el que está en la cabeza de la cola.
 PRACTICA

Primero lo que hicimos fue crear nuestra clase pilaCola que es donde ira nuestro menú de
selección de una pila o cola:
9

Luego creamos nuestras clases una se llamará pilas1 y la otra colas1:

Lo primero que hicimos en la clase principal fue lo siguiente:
package Unidad3;

import java.util.*; 10

public class pilaCola {

public static void main(String[] args) {

Scanner enteros = new Scanner(System.in);
Scanner cadena = new Scanner(System.in);
En esta parte creamos un arreglo donde se estaran guardando los datos que metamos a la pila
o cola.
String datos[];
Aquí declaramos una variable llamada TOPE que será igual a -1, otra variable llamada MAX,
Otra variable llamada FRENTE que tendrá un valor igual a -1 y por último una variable Final
igual a 0.
int TOPE = -1, MAX, FRENTE = -1, FINAL = 0;
boolean band = false;
int op;
System.out.println("Ingrese la cantidad de datos a ingresar");
MAX = enteros.nextInt();
datos = new String[MAX];
Aquí creamos opciones de si queremos realizar una pila o una cola mediante un do while y
el uso de switch.
Creamos nuestro do while
do {
System.out.println("Seleccione\n"
+ "1. pilas\n"
 + "2. colas\n"
+ "0. salir");
op = enteros.nextInt();
Creamos un switch donde estarán las 3 opciones que declaramos que se podían elegir en este 11
caso tenemos la primera opción que es la de pilas.
switch (op) {
Aquí tenemos la opción 1 donde se ejecutarán todas las opciones que podemos hacer con las
pilas.
case 1:
Aquí creamos un objeto pila de tipo pilas1 la cual es una clase que ya hemos declarado
anteriormente que usaremos durante la ejecución de esta opción.
pilas1 pila = new pilas1();
Para la opción pilas dentro de este menú creamos otro do while donde estará alojado un
switch que contendrá las opciones que tendrá la pila.
do {
Aquí tenemos nuestro menu la cual contara con las siguientes opciones.
System.out.println("\n======= MENU ======\n");
System.out.print("1. Verificar si la pila esta vacia\n");
System.out.print("2. Verificar si la pila está llena\n");
System.out.print("3. Agregar un elemento a la pila\n");
System.out.print("4. Eliminar un elemento de la pila\n");
System.out.print("5. Mostrar elementos guardados\n");
System.out.print("6. Regresar al menú principal\n");
En esta parte se recibe el numero ingresado de la opción elegida para luego ser ejecutada:
op = enteros.nextInt();
Dentro de este do while abrimos un nuevo switch que nos servirá para poder realizar las
acciones que nos dice el menú.
switch (op) {
Como primera opción verificamos si la pila está vacía, donde tenemos el siguiente if else. en
este caso hacemos uso del método pila_vacia que tenemos en la clase pilas1, que va de la
siguiente manera.
case 1:
12
En esta parte hacemos uso de nuestra clase pilas1 para realizar esta acción.
if (pila.pila_vacia(TOPE, band) == true) {
System.out.println("\nLa pila esta vacia\n");
} else {
System.out.println("\nLa pila contiene elementos\n");
}
break;

En esta parte hacemos uso de nuestro método que tenemos en la clase pilas1 la cual veremos
a continuación.
case 2:
if (pila.pila_llena(TOPE, MAX, band) == true) {
Si una de las dos acciones que tenemos declaradas en los métodos son verdaderas entonces
ejecutamos los siguientes mensajes.
System.out.println("\nLa pila está llena\n");
} else {
System.out.println("\nLa pila aún tiene espacio\n");
}
break;

case 3:
En esta parte realizamos la acción de agregar un elemento a la pila, pero primero en esta parte
lo que se hace también es verificar si la pila está llena, mediante el dato alojado en TOPE que
se guardó en el objeto de tipo sccanner cadena la cual guardo la información en un arreglo.
entonces si se verifico que si no está llena podremos llenar la pila dependiendo del TOPE
que le hayamos dado a esta.
13
if (pila.pila_llena(TOPE, MAX, band)) {
System.out.println("\nNo se pueden ingresar más elementos\n");
} else {
TOPE++;
System.out.println("Introdusca un elemento para APILAR");
datos[TOPE] = cadena.nextLine();
}
break;

En esta parte solo verificamos si la pila está vacía mediate el método que tenemos en la clase
pilas1 y también dependiendo de cuantos datos el TOPE.
case 4:
if (pila.pila_vacia(TOPE, band)) {
System.out.println("\nLa pila esta vacia\n");
} else {
TOPE--;
}
break;

En esta parte lo que hacemos es decir que si la pila está vacía, que verifique el TOPE y el
band para mostrar el mensaje "No hay elementos para mostrar". y si no ejecutamos el ciclo
for para mostrar los elementos guardados en el arreglo.
case 5:
if (pila.pila_vacia(TOPE, band)) {
 System.out.println("\nNo hay elementos para mostrar\n");
} else {
for (int i = TOPE; i > -1; i--) {
System.out.println("\nLos elementos son: " + datos[i] + "\n"); 14

}
}
break;

En estas últimas opciones tenemos las opciones para regresar al menú principal y también
por si el usuario mete un numero incorrecto para una opción.
case 6:
System.out.println("\nregresando..\n");
break;

default:
System.out.println("Opcion incorrecta");
break;
}
} while (op != 6);
En este caso termina la primera opción que sería la de pila.
break;

En esta parte iniciamos con la opción dos que sería el de las colas, donde lo primero que
hacemos es crear un objeto colas de tipo colas1 para que después funcionen con los métodos
que hay guardados en la clase colas1.
case 2:
 colas1 cola = new colas1();
do {
En esta primera parte hemos creado nuestro menú de opciones que nos dirá que es lo que
podemos hacer dentro de la cola.
15
System.out.println("\n======= MENU ======\n");
System.out.print("1. Verificar si la cola esta vacia\n");
System.out.print("2. Verificar si la cola esta llena\n");
System.out.print("3. Agregar un elemento a la cola\n");
System.out.print("4. Eliminar un elemento de la cola\n");
System.out.print("5. Mostrar elementos guardados\n");
System.out.print("6. Regresar al menu principal\n");
op = enteros.nextInt();
En esta parte se guarda la opción que queremos realizar dentro de la cola, y como siguiente
paso creamos un switch para cada una de las opciones que tendrá el menú, como primer paso
tenemos la opción para verificar si la cola está vacía haciendo uso de nuestro objeto cola y
del método cola vacía.
switch (op) {
Como parte de la primera opción tenemos la opción de verificar si la pila está vacía en este
caso hacemos uso de nuestro método alojado en la clase colas1 y también de lo que hayamos
guardado dentro de la cola si se confirma que no hay elementos entonces se arroja el mensaje
"La cola no tiene elementos".
case 1:
if (cola.cola_vacia(FRENTE, FINAL, band)) {
System.out.println("\nLa cola esta vacia\n");
FRENTE = -1;
FINAL = 0;
} else {
System.out.println("\nLa cola tiene elementos\n");
}
 break;
En la opción dos hacemos uso de nuestro objeto cola con la ayuda de nuestro método
cola_llena alojado en la clase colas1 es ahí donde se preguntará si la cola está llena. si no está
llena entonces arrojara el mensaje "Aún queda espacio en la cola".
16
case 2:
if (cola.cola_llena(FINAL, MAX, band)) {
System.out.println("\nLa cola está llena\n");
} else {
System.out.println("\nAun queda espacio en la cola\n");
}
break;
Para este caso lo primero que hacemos es verificar si la cola está llena mediante el objeto
cola y el método cola_llena la cola está en la clase colas1. sí aún hay espacio dentro de la
cola, entonces aun nos dejara llenar datos dentro de nuestro arreglo cadena.
case 3:
if (cola.cola_llena(FINAL, MAX, band)) {
System.out.println("\nLa cola está llena, no puede ingresar más
elementos");
} else {
System.out.println("\nIngrese el dato a agregar en la cola");
datos[FINAL] = cadena.nextLine();
FINAL++;
}
break;
Aquí lo único que hacemos es verificar si la cola está vacía mediante el uso del método
cola_vacia.
case 4:
if (cola.cola_vacia(FRENTE, FINAL, band)) {
 System.out.println("\nLa cola esta vacia\n");
} else {
FRENTE++;
} 17

break;
Lo que pasa en esta parte es que, si la cola está vacía nos dirá que no hay elementos, pero si
los hay mostrara elementos guardados en su posición.
case 5:
if (cola.cola_vacia(FRENTE, FINAL, band)) {
System.out.println("\nNo existen elementos para mostrar en la
cola\n");
} else {
for (int i = FRENTE + 1; i < FINAL; i++) {
System.out.println("\nLos elementos en la cola son: " + datos[i]);
}
}
break;
En esta parte tenemos dos opciones una es para regresar al menú principal y otra es por si el
usuario introduce una opción incorrecta.
case 6:
System.out.println("\nRegresando...\n");
break;
default:
System.out.println("\nOpcion Incorrecta\n");

}
} while (op != 6);
Aquí ya se han terminado las opciones para las colas y también por último tenemos la
finalización con dos opciones restantes que esta van dentro del menú colas o pilas que como
vemos una es para regresar y la otra es por i el usuario introduce una opción incorrecta.
break;
18
case 0:
System.out.println("\nSALIENDO...");
break;
default:
System.out.println("\nOpcion incorrecta\n");
break;
}
} while (op != 0);
}
}

En esta segunda parte creamos las los métodos de las clases colas1 y pilas1:
package Unidad3;
class pilas1 {
En este caso creamos nuestro método para saber si la pila está vacía entonces creamos un
método pila_vacia de tipo booleano que tendrá un parámetro Tope de tipo entero y otro
parámetro band que será de tipo booleano, pues bien, entonces como veremos a continuación
decimos que si el TOPE es igual a un valor de -1 entonces el band será verdadero eso
significara que la pila está vacía, y si no, si el valor que esta guardado dentro no es menor a
-1 entonces el band será falso. entonces como último paso retornamos el valor que se tenga
guardado.
public boolean pila_vacia(int TOPE, boolean band) {
if (TOPE == -1) {
band = true;
} else {
 band = false;
}
return band;
} 19

Para este caso creamos un método de tipo booleano que tendrá un parámetro TOPE de tipo
entero, otro parámetro Max que será de tipo entero y por último tendremos un parámetro
band de tipo booleano, entonces decimos que si el TOPE es igual a MAX -1 entonces la
bandera será verdadera, si el TOPE no es igual a MAX - 1 entonces la bandera será false, por
último, retornaremos el valor que arroja del dato o datos que tengamos guardado.
boolean pila_llena(int TOPE, int MAX, boolean band) {
if (TOPE == MAX - 1) {
band = true;
} else {
band = false;
}
return band;
}

}
package Unidad3;
public class colas1 {
En esta clase declaramos un método que se llama cola_vacia, el cual tendrá un parámetro
llamado FRENTE de tipo entero, Uno llamado FINAL de tipo entero y otro llamado band
que será de tipo booleano, pues bien, aquí lo que hacemos es que si el frente es igual a un
FINAL con -1, entonces decimos que la bandera es verdadera y si no se cumple esa condición
entonces decimos que el band es falso, ya sea que se cumpla una de las condiciones
retornamos el resultado obtenido.
public boolean cola_vacia(int FRENTE, int FINAL, boolean band) {
if (FRENTE == FINAL - 1) {
 band = true;
} else {
band = false;
} 20

return band;
}
Para este caso creamos un método llamado cola_llena con los siguientes parámetros: Uno de
llama FINAL que es de tipo entero, uno llamado MAX que también es tipo entero y por
último tenemos uno llamado band que es tipo booleano, pues bien, lo que hacemos aquí es
que si FINAL es igual a MAX -1 entonces el resultado que tendrá será band verdadero si no
el resultado obtenido es mayor a MAX -1 entonces band será falso. ya sea que se dé uno de
los dos casos retornamos el valor obtenido.
boolean cola_llena(int FINAL, int MAX, boolean band) {
if (FINAL == MAX - 1) {
band = true;
} else {
band = false;
}
return band;
}
}
RESULTADOS

21
22
23
 CONCLUSIÓN

Las estructuras lineales ofrecen una amplia gama de variaciones y formas de agrupación que
permiten que el diseñador de diferentes disciplinas experimente con diferentes alternativas y 24

seleccionar a la que mejor se adecua a sus necesidades. Las estructuras lineales son una
técnica constructiva que puede ser empleada en una gran variedad de diciplinas como son la
arquitectura, el diseño estructural, el diseño de exteriores, el diseño de interiores, mobiliarios
y entre muchos otros.