TECNOLÓGICO NACIONAL DE MÉXICO

INSTITUTO TECNOLÓGICO DE TAPACHULA

“LIBERTAD DE ESPÍRITU EN CIENCIA Y TECNOLOGÍA”

ASIGNATURA: ESTRUCTURA DE DATOS.

SEMESTRE: 3. GRUPO: B.

TAREA: INVESTIGAR LOS SUBTEMAS: 3.1 PILAS, 3.1.1 REPRESENTACIÓN

EN MEMORIA, 3.1.2 OPERACIONES BÁSICAS, 3.1.3 APLICACIONES, 3.2
COLAS. Y HACER UNA PRACTICA EN JAVA QUE EJEMPLIFIQUE UNA COLA
Y UNA PILA.

FECHA: 03/11/2021.

PRESENTA: MORALES SOLÍS BRANDON OMAR.

TEMA 3: “ESTRUCTURAS LINEALES.”

NO. CONTROL: 20510397.

CATEDRÁTICO: LIC. CARLOS HERNANDEZ SALAS.

pág. 1
Introducción.

La presente investigación se refiere al tema de estructuras lineales, que se

puede definir como aquellas en las que los elementos ocupan lugares sucesivos en
la estructura y cada uno de ellos tiene un único sucesor y predecesor. O como
aquellas secuencias de conjuntos de elementos entre los que se establece una
relación de predecesor y sucesor.
La característica principal de este tema es que en las estructuras lineales
siempre existe un sucesor y predecesor.
Esta investigación se realizó por el interés de saber que son las pilas, que es
la representación en memoria, saber cuáles son las operaciones básicas,
aplicaciones y también aprender acerca de las colas.
Por otra parte, realizar prácticas aplicando el concepto de colas y pilas.

pág. 2
Índice.
Portada ................................................................................................................................................ 1
Introducción. ...................................................................................................................... 2
Desarrollo. ......................................................................................................................... 4
3.1 Pilas. ............................................................................................................................ 4
Pila vacía. .......................................................................................................................... 4
Pila llena. ........................................................................................................................... 6
Pila con elementos. ........................................................................................................... 7
3.1.1 Representación en memoria. .................................................................................... 9
3.1.2 Operaciones básicas................................................................................................. 9
Insertar (push). .................................................................................................................. 9
Borrar (pop). .................................................................................................................... 10
3.1.3 Aplicaciones. ........................................................................................................... 10
3.2 Colas. ........................................................................................................................ 11
Cola vacía........................................................................................................................ 11
Cola llena......................................................................................................................... 12
Cola con elementos. ........................................................................................................ 14
Aplicaciones. ................................................................................................................... 15
Ejemplo de pila. ............................................................................................................... 16
Código de la clase PracticeBatteries. ............................................................................... 16
Código de la calse Main................................................................................................... 17
Resultados....................................................................................................................... 17
Segundo ejemplo de pila. ................................................................................................ 19
Código de la clase PracticeBatteries2. ............................................................................. 19
Código de la clase Main................................................................................................... 21
Resultados....................................................................................................................... 22
Ejemplo de cola. .............................................................................................................. 23
Código del programa. ...................................................................................................... 23
Código de la clase PracticeQueues. ................................................................................ 23
Código de la clase Main................................................................................................... 24
Resultados....................................................................................................................... 25
Conclusión. ...................................................................................................................... 26
Bibliografías. .................................................................................................................... 27

pág. 3
Desarrollo.

3.1 Pilas.

La pila (o stack) es una estructura de datos lineal y dinámica, en la cual el

elemento obtenido a través de la operación ELIMINAR está predefinido, debido a
que implementa la política Last-In, First-Out (LIFO), esto es, el último elemento que
se agregó es el primer que se elimina.
Las operaciones que se pueden realizar sobre una pila son INSERTAR (que
es llamada PUSH) y ELIMINAR (que es llamada POP). Debido a la política LIFO
que implementa esta estructura, el orden en el que los elementos son extraídos de
la pila (POP) es inverso al orden en el que los elementos fueron insertados en la
pila (PUSH). Además, el único elemento accesible de la pila es el que está hasta
arriba y que se conoce como tope de la pila.
Para poder diseñar un algoritmo que defina el comportamiento de una pila se
deben considerar 3 casos para ambas operaciones (push y pop):

• Estructura vacía (caso extremo).

• Estructura llena (caso extremo).
• Estructura con elemento(s) (caso base).

Pila vacía.
Una pila vacía no contiene elemento alguno dentro de la estructura y el tope
de la misma apunta a nulo.

pág. 4
 En una pila vacía no es posible realizar POP, debido a que la estructura no
contiene información.

Cuando la pila está vacía sí se puede realizar PUSH, en tal caso, el nodo que
entra a la estructura sería el único elemento de la pila y el tope apuntaría a él.

pág. 5
Pila llena.
Por definición, una estructura de datos tipo pila tiene un tamaño fijo. Cuando
la pila ha almacenado el número máximo de nodos definido, se dice que la pila está
llena.

En una pila llena no es posible hacer PUSH de un nuevo elemento, ya que

se ha alcanzado el tamaño máximo permitido.

pág. 6
 Cuando la pila está llena se puede hacer POP de la información contenida
en la estructura.
En tal caso, el tope apunta al elemento siguiente de la estructura.

Pila con elementos.

Una pila que contiene elementos (sin llegar a su máxima capacidad)
representa el caso general.

pág. 7
 En una pila con elementos se pueden realizar PUSH. En tal caso, el tope
apuntara al elemento que se insertó y el nuevo elemento apunta al elemento al que
apuntaba tope.

En una pila con elementos es posible realizar POP. En tal caso, el nodo al
que apunta tope se extrae y ahora tope apunta al elemento al que apuntaba éste
(sucesor).

pág. 8
3.1.1 Representación en memoria.

Las pilas no son estructuras fundamentales de datos.

No están definidas como tales en los lenguajes de programación
Para su representación requieren de otras E.D:

• Arreglos.
• Listas.

3.1.2 Operaciones básicas.

Insertar (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 las 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.

pág. 9
Borrar (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:

3.1.3 Aplicaciones.

La estructura pila tienen varias aplicaciones dentro de la ingeniería, de las

más conocidas es la que se utiliza dentro de la memoria RAM de un equipo de
cómputo.
La memoria de las computadoras no es un espacio uniforme, el código que
se ejecuta, utiliza tres diferentes segmentos de memoria: el texto (text), la pila
(stack) y el montículo (heap).
Cuando una aplicación inicia, el método principal es invocado y se reserva
memoria en la pila o stack. En el segmento de memoria de la pila es donde se alojan
las variables requeridas por las funciones del programa. Así mismo, cada vez que
se llama una función dentro del programa una sección de la pila, llamada
marco o frame, se reserva y es ahí donde las variables de la nueva función son
almacenadas.
Cuando una función manda llamar varias funciones, éstas generan un nuevo
marco que se va creando uno encima del otro y, cuando las funciones terminan, los
marcos se liberan de manera automática en orden inverso (LIFO).

pág. 10
3.2 Colas.
La cola (o queue) es una estructura de datos lineal, en la cual el elemento
obtenido a través de la operación ELIMINAR está predefinido y es el que se
encuentra al inicio de la estructura.
La cola implementa la política First-In, First-Out (FIFO), esto es, el primer
elemento que se agregó es el primero que se elimina.
La cola es una estructura de datos de tamaño fijo y cuyas operaciones se
realizan por ambos extremos; permite INSERTAR elementos al final de la estructura
y permite ELIMINAR elementos por el inicio de la misma. La operación de
INSERTAR también se le llama ENCOLAR y la operación de ELIMINAR también se
le llama DESENCOLAR.
Para poder diseñar un algoritmo que defina el comportamiento de una COLA
se deben considerar 3 casos para ambas operaciones (INSERTAR y ELIMINAR):

• Estructura vacía (caso extremo).

• Estructura llena (caso extremo).
• Estructura con elemento(s) (caso base).

Cola vacía.

La cola posee dos referencias, una al inicio (HEAD) y otra al final (TAIL) de
la cola. En una cola vacía ambas referencias (HEAD y TAIL) apuntan a nulo.

En una cola vacía no es posible desencolar debido a que la estructura no

posee elementos.

pág. 11
 En una cola vacía sí se pueden encolar elementos, en este caso las
referencias HEAD y TAIL apuntan al mismo elemento, que es el único en la
estructura.

Cola llena.

Cuando la referencia a tail de una cola llega a su máxima capacidad de

almacenamiento (MAX) se dice que la cola está llena.

pág. 12
 En una cola llena no es posible encolar más elementos.

En una cola llena sí se pueden desencolar elementos, en tal caso se obtiene

el elemento al que hace referencia head y esta referencia se recorre al siguiente
elemento (sucesor).

pág. 13
Cola con elementos.

Una cola que contiene elementos (sin llegar a su máximo tamaño) representa
el caso general de la estructura.

En una cola con elementos es posible desencolar nodos, recorriendo la

referencia al inicio de la cola (HEAD) al siguiente elemento de la estructura.

pág. 14
 Así mismo, se pueden encolar elementos en una cola mientras la referencia
al final (TAIL) de la estructura no sea mayor al tamaño máximo de la misma. Cuando
se encola un elemento, el nodo al que apunta TAIL tiene como sucesor el nuevo
elemento y la referencia a TAIL apunta al nuevo elemento.

Aplicaciones.

La aplicación más conocida de la estructura cola es la que se utiliza en la

impresión de documentos.
Las impresoras tienen una cantidad de memoria limitada, la cual puede ser
inferior al tamaño de un documento que se desea imprimir.
La cola de impresión permite enviar documentos de gran tamaño, o varios
documentos, a una impresora sin tener que esperar que se complete la impresión
para seguir con la siguiente tarea. Cuando se envía un archivo a imprimir, se crea
un archivo de almacenamiento intermedio en formato EMF, donde se almacena lo
que se envía a la impresora y las opciones de impresión. Las impresiones se van
realizando según vayan llegando los archivos (FIFO).

pág. 15
Ejemplo de pila.

Se codifica en java un ejemplo sencillo de pila para así aprender cuales son
los métodos de la calse Stack.
El proyecto tiene como nombre PracticeBatteries que cuenta con dos clases
las cuales son:
• PracticeBatteries.
• Main.

Código de la clase PracticeBatteries.

package practiceBatteries;

//Libreria para poder utilizar los métodos de pilas.

import java.util.Stack;
import javax.swing.JOptionPane;

/**
*
* @author Brandon Omar Morales Solís version 1.0
*/
public class PracticeBatteries {

//Se instancia el objeto pila (batterie) para poder utilizar los métodos.
Stack batterie = new Stack();

public void push() { //Método para poder añadir elementos a la pila.

//[] //La pila empieza como un arreglo vacío.
//["Mundo"]
batterie.push("Mundo"); //Añadimos un elemento a la pila.
//["Mundo", "Hola"]
batterie.push("Hola");//Añadimos un segundo elemento a la pila.
}

//Método que permite vizualizar el ultimo elemento.

public void peek() {
JOptionPane.showMessageDialog(null, "El primer elemento es:
"+batterie.peek());
}

//Método que permite sacar un elemento final

public void pop() {

pág. 16
 JOptionPane.showMessageDialog(null, "Se elimina: " + batterie.pop());
//["Mundo", ""]
//["Mundo"] "Mundo" pasaría a ser el ultimo elemento debido a que se
//ha elimindado "Hola"
JOptionPane.showMessageDialog(null, "Y queda solo: " + batterie.peek());
}

//Método para saber si la pila está vacia retorna true o false según sea el caso
public void empity() {
JOptionPane.showMessageDialog(null, "¿La pila está vacia? :
"+batterie.empty());
}
}

Código de la calse Main.

package practiceBatteries;

/**
*
* @author Brandon Omar Morales Solís version 1.0
*
*/
public class Main {

public static void main(String[] args) {

PracticeBatteries batteries = new PracticeBatteries();
batteries.push();
batteries.peek();
batteries.pop();
batteries.empity();
}
}

Resultados.

pág. 17
Al dejar vacía la pila.

pág. 18
Segundo ejemplo de pila.

Código de la clase PracticeBatteries2.

package practiceBatteries2;

/**
*
* @author Brandon Omar Morales Solís version 1.1
*/
public class PracticeBatteries2 {

//Atributos
String array[];
int maxSize;
int stop;

public PracticeBatteries2() {
maxSize = 0;
stop = 0;
array = new String[maxSize];
}

public PracticeBatteries2(int n) {
maxSize = n;
array = new String[maxSize];
}

public boolean empty() {

pág. 19
 if (stop == 0) {
return true;
} else {
return false;
}
}

public void push(String str) {

if (stop < maxSize) {
array[stop] = str;
stop++;
}
}

public String peek() {

if (stop > 0) {
return array[stop - 1];
} else {
return null; //Retorna un valor nulo porque stop es menor que 0
}
}

public String pop() {

String temp = null;
if (stop > 0) {
temp = array[stop - 1];
array[stop - 1] = null;
stop--;

pág. 20
 }

return temp;
}

Código de la clase Main.

package practiceBatteries2;

import javax.swing.JOptionPane;

/**
*
* @author Brandon Omar Morales Solís version 1.1
*/
public class Main {

public static void main(String[] args) {

PracticeBatteries2 practiceBatteries2 = new PracticeBatteries2(3);
practiceBatteries2.push("1");
practiceBatteries2.push("2");
practiceBatteries2.push("3");
JOptionPane.showMessageDialog(null, practiceBatteries2.peek());
JOptionPane.showMessageDialog(null, practiceBatteries2.pop());
JOptionPane.showMessageDialog(null, practiceBatteries2.empty());
}
}

pág. 21
Resultados.

pág. 22
Ejemplo de cola.

Código del programa.

Código de la clase PracticeQueues.

package practiceQueues;

//Libreria para poder utilizar métodos que nos sirven para poder
//aplicar las colas
import java.util.LinkedList;
import javax.swing.JOptionPane;

/**
*
* @author Brandon Omar Morales Solís versión 1.1 offer, poll
*/
public class PracticeQueues {

//Atributos
LinkedList queues;
String window;

//Método constructor
public PracticeQueues() {
queues = new LinkedList();
window = "";
}

public void offer() {

//Bucle for para poder realizar la serie del 1 al 10

pág. 23
 for (byte i = 1; i <= 10; i++) {
queues.offer(i);
}
}

public void poll() {

//Ciclo while que se estara ejecutando
while (queues.peek() != null) {
window += queues.poll() + "\n";
}

JOptionPane.showMessageDialog(null, window);
}

Código de la clase Main.

package practiceQueues;

/**
*
* @author Brandon Omar Morales Solís versión 1.1
*/
public class Main {

public static void main(String[] args) {

PracticeQueues queues = new PracticeQueues();
queues.offer();

pág. 24
 queues.poll();
}
}

Resultados.

pág. 25
Conclusión.

Al haber hecho esta investigación puedo decir que las estructuras lineales
siempre tienen la principal característica de que existe un sucesor y predecesor.
También puedo decir que las pilas y las colas son lo contrario uno del otro ya
que las pilas solo te retornan el último elemento mientras que las colas solo retornan
el primer elemento.

pág. 26
Bibliografías.

Estructuras de Datos Lineales. (s/f). unizar.es. Recuperado de:

http://webdiis.unizar.es/~elvira/eda/addeda/teruel/Estructuras_Lineales.html
Pilas. (s/f). docs.google.com. Recuperado de:
https://docs.google.com/document/d/1C9kK11sIof6GItlJAynxjP3XtBN9Y7V4PhsDf
DxU1eU/edit
Villanueva, S. (s/f). hci.uniovi.es. Recuperado de:
http://www.hci.uniovi.es/Products/DSTool/pilas/pilas-operaciones.html
Gálvez, J, Cano, E. (s/f). odin.fi-b. Recuperado de:
https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahU
KEwj5soXyrPvzAhVEkmoFHcqwCYoQFnoECAMQAw&url=http%3A%2F%2Fodin.f
i-
b.unam.mx%2Fsalac%2FpracticasEDAA%2Feda1_p5.pdf&usg=AOvVaw3nm6DG
EKMmGzk7iby0VAiP

pág. 27