PILAS

Jostin González

T.S.U Informática

Procesamiento de Datos -2023-2-AA

10 de febrero de 2024
 Índice
Introducción .............................................................................................................................................3
Definición .................................................................................................................................................4
Características..........................................................................................................................................5
Representación ........................................................................................................................................6
Tratamiento de una pila ..........................................................................................................................7
LIFO ......................................................................................................................................................7
FIFO ......................................................................................................................................................8
Ejemplos...............................................................................................................................................9
Operaciones a realizar con estructura de pila. EJEMPLOS ....................................................................10
Diseñar Algoritmos elementales para el tratamiento de pila ...............................................................12
Conclusión..............................................................................................................................................14
Bibliografía .............................................................................................................................................16
Introducción
Dos componentes esenciales en la creación de sistemas y aplicaciones
informáticas son el procesamiento de datos y la programación con pilas. Ambos son
esenciales para la gestión, organización y manipulación eficaces de la información. El
conjunto de procedimientos y actividades necesarios para convertir los datos en
información significativa se denomina procesamiento de datos. El proceso implica
recopilar, organizar, evaluar y mostrar la información para permitir la extracción de
conocimientos y la toma de decisiones bien informadas. Un tratamiento inadecuado
de los datos da lugar a información desorganizada e ininteligible, lo que impide la
toma de decisiones y limita el potencial de los datos. Nuestra vida cotidiana se ve
afectada por el tratamiento de datos de muchas formas distintas. Por ejemplo, el
tratamiento de datos en las empresas permite analizar las ventas, las preferencias de
los consumidores y el comportamiento del mercado para mejorar la toma de
decisiones estratégicas. El procesamiento de datos es crucial para gestionar nuestras
finanzas, programar nuestro tiempo y tomar decisiones acertadas incluso en nuestra
vida privada.

En cambio, las pilas de programación son estructuras de datos que nos

permiten almacenar y recuperar elementos de forma eficaz y lógica. Las pilas son
únicas por su forma de funcionar: según la regla "último en entrar, primero en salir"
(LIFO) o FIFO, lo último que se inserta es lo primero que se recupera. Por eso son
una herramienta importante para crear algoritmos y resolver problemas complejos.
Las pilas de programación resultan especialmente útiles cuando hay que gestionar la
memoria de forma eficaz o controlar el orden en que se introducen las piezas. Las
pilas pueden utilizarse, por ejemplo, en la programación de aplicaciones web para
controlar las peticiones de los usuarios y el flujo secuencial de información. Las pilas
pueden utilizarse en el desarrollo de aplicaciones móviles para almacenar la
navegación del usuario, lo que permite un cambio de pantalla lógico y sin
interrupciones.

En resumen, dos componentes esenciales de la informática son el tratamiento

de datos y la programación con pilas. Por lo tanto, se puede decir que aprender sobre
ambas materias es esencial si se quiere progresar en informática y obtener una
comprensión realmente completa para poder desarrollar proyectos informáticos.
 Definición
Una pila es una estructura de datos lineal utilizada en el procesamiento de
datos que se adhiere al principio LIFO (Last-In, First-Out), que establece que lo último
que se añade a la pila es lo primero que se saca. La pila es similar a una pila física
de objetos del mundo real, en la que sólo se pueden mover o añadir elementos en la
parte superior de la pila. Para decirlo de forma más técnica, una pila es una
disposición de piezas homogéneas o heterogéneas conectadas entre sí mediante
enlaces dentro de la estructura. Un "nodo" es un elemento de la pila que tiene una
referencia al siguiente nodo de la pila, así como a los datos que se van a almacenar.
El término "top" o "cima" se refiere al nodo situado en la parte superior de la pila.

Las pilas se utilizan con frecuencia en el tratamiento de datos para

almacenarlos y manejarlos con eficacia. Las pilas se utilizan, por ejemplo, en los
sistemas operativos para rastrear las direcciones de retorno de las funciones a
medida que se ejecutan. Además, se emplean en la implementación de métodos de
búsqueda y recorrido de datos, incluido el algoritmo de búsqueda en profundidad de
grafos.

Una pila es relativamente fácil de usar. Push y pop son las dos acciones básicas que
se pueden realizar en una pila. Al realizar la acción "push", un nuevo nodo es
empujado a la parte superior de la pila, tomando el relevo como nuevo nodo superior.
Con la acción "pop" se elimina el nodo situado en la parte superior de la pila, y el
elemento siguiente ocupa su lugar.

Aparte de estas acciones fundamentales, también podemos realizar otras

acciones sobre una pila, como "peek", que consulta el elemento en la parte superior
de la pila sin eliminarlo, "isEmpty", que determina si la pila está vacía, y "isFull", que
determina si la pila está llena, en el caso de que la capacidad de memoria sea una
limitación.

Hay varias estructuras de datos que se pueden utilizar para implementar una
pila, incluidas las matrices y las listas enlazadas. Un puntero que indica la ubicación
superior de la pila se ajusta para añadir o eliminar elementos de una matriz, que tiene
un tamaño fijo asignado a la pila. Cada nodo de una lista enlazada contiene un puntero
al nodo que le sigue, lo que permite flexibilizar el tamaño de la pila.
 Características
En el tratamiento de datos, las pilas son un tipo de estructura de datos sujeta
al principio de último en entrar, primero en salir (LIFO). Según esta regla, el último
elemento en añadirse a la pila será el primero en eliminarse.

Los nodos, también conocidos como elementos de la pila, son los bloques de
construcción de las pilas. Cada nodo se compone de dos partes principales: una
referencia al nodo que le sigue en la pila y los datos, o información que se almacena.
La estructura y el orden de la pila pueden conservarse gracias a la referencia al nodo
siguiente.

A continuación, se enumeran algunas propiedades y características cruciales

de las pilas en el tratamiento de datos:

1. Operaciones básicas: Para modificar las pilas se pueden utilizar dos

operaciones fundamentales: la inserción, también conocida como push, que
añade un elemento a la parte superior de la pila, y la eliminación, a menudo
conocida como pop, que saca el elemento de la parte superior de la pila.
2. Parte superior de la pila: Se llama parte superior de la pila por una razón. Es el
lugar donde se realizan las operaciones de inserción y extracción. El último
elemento añadido a la pila siempre está en la parte superior de la pila.
3. Vacía o no vacía: Una pila puede estar vacía o no vacía, lo que indica que
incluye al menos un elemento o que está vacía, lo que indica que no contiene
ningún elemento. Antes de realizar cualquier operación de borrado, es
fundamental considerar el estado de la pila.
4. Capacidad: Las pilas suelen estar especificadas por un tamaño máximo y una
capacidad límite. Esto indica que, una vez alcanzada la capacidad máxima de
la pila, no se pueden añadir más elementos. Se produce un desbordamiento
cuando se intenta introducir un elemento por encima de la capacidad de la pila.
5. Desbordamiento: Cuando se añade un elemento mayor que la capacidad
máxima de la pila, se produce un desbordamiento de la pila. Esto puede ocurrir
si se intenta añadir un elemento a una pila llena o si no hay suficiente espacio
reservado para los elementos que se van a almacenar en la pila.
6. Subdesbordamiento: Un intento de eliminar un elemento de una pila vacía
resulta en un desbordamiento por debajo de la pila. Esto puede ocurrir si
 alguien intenta eliminar un elemento de una pila que no contiene ningún
elemento.
7. Flexibilidad: Debido a que pueden ser implementadas usando una variedad de
estructuras subyacentes, incluyendo listas enlazadas, vectores, arreglos
estáticos o dinámicos, y más, las pilas son un tipo increíblemente flexible de
estructura de datos. Gracias a su adaptabilidad, las pilas pueden modificarse
para satisfacer distintas necesidades.

Debido a su facilidad de uso y eficacia en la gestión de elementos, las pilas se

emplean con frecuencia en el procesamiento de datos. Se emplean en contextos muy
diversos, como el tratamiento de textos, los sistemas operativos, los compiladores y
la programación. Las pilas, cuya estructura se basa en la regla LIFO, proporcionan un
medio práctico para manipular y almacenar elementos en una secuencia determinada,
lo que ayuda a la organización y gestión de datos en muchas aplicaciones de
procesamiento de datos.

Representación
En informática y procesamiento de datos, la representación de pilas es esencial
porque proporcionan una organización y gestión jerárquica eficaz de la información.
La estructura de datos Last In, First Out (LIFO), que establece que el último elemento
añadido es el primero en ser retirado, es la base de una pila. Sólo se puede acceder
al elemento situado en la parte superior de esta representación, de forma muy
parecida a una pila de elementos reales. Como las pilas ofrecen un medio eficaz de
gestionar y organizar datos temporalmente, se utilizan en una amplia gama de
aplicaciones y algoritmos informáticos. La gestión de llamadas al sistema operativo,
la ejecución de funciones de software, la evaluación de expresiones matemáticas y la
puesta en práctica de algoritmos de búsqueda y recorrido de grafos son algunas de
las aplicaciones típicas del uso de pilas.

En el mundo de la informática, se suelen utilizar estructuras de datos para

representar una pila. Una matriz es un tipo de estructura de datos utilizada en la
implementación tradicional de una pila. La posición del elemento superior se indica
mediante la variable "top", mientras que el número de elementos de la pila se registra
mediante la variable "size". En esta representación, la pila se define con un tamaño
fijo.
 Para representar una pila se suele utilizar otra estructura de datos muy popular,
denominada "lista enlazada". Cada nodo de la lista en esta representación tiene una
referencia al nodo que le sigue, así como un elemento de datos. El elemento superior
de la pila está representado por el nodo final de la lista. Esto permite añadir y eliminar
elementos con mayor libertad, ya que no es necesario establecer un tamaño y la lista
puede cambiar de tamaño según sea necesario.

Dado que no es necesario navegar por cada elemento para acceder a los
elementos superiores de la pila, la representación de la pila en el campo informático
facilita un acceso eficaz a esos elementos. Además, las operaciones de inserción y
eliminación son rápidas y se completan en tiempo real, lo que convierte a las pilas en
una gran opción para muchas aplicaciones.

En resumen, la gestión y organización eficaz de los datos depende de la

representación informática de las pilas. Las pilas, tanto si están hechas con matrices
como con listas enlazadas, proporcionan un acceso rápido a los elementos superiores
y el principio LIFO, que es útil para muchos tipos diferentes de algoritmos y
aplicaciones.

Tratamiento de una pila

El tratamiento de una pila puede realizarse de dos formas: modo FIFO (First
In, First Out) y modo LIFO (Last In, First Out).
LIFO
El método con el que se gestionan los elementos contenidos en una pila se
denomina tratamiento de una pila en modo LIFO (Last In, First Out). Una pila es un
tipo de estructura de datos que permite el almacenamiento secuencial de
componentes; el único elemento que puede recuperarse es la última pieza añadida a
la pila, o el elemento situado en la parte superior. Una acción conocida como "push"
se utiliza para añadir un nuevo elemento a la pila, situándolo en la parte superior de
la misma. Por el contrario, una operación conocida como "pop" se utiliza para eliminar
un elemento de la pila, quitando el elemento más reciente añadido a la pila. El
elemento que se añadió más recientemente a la pila siempre será el primero en ser
eliminado cuando se utiliza el modo LIFO. Esto se debe al hecho de que el elemento
en la parte superior de la pila se elimina cuando se realiza una operación pop en una
pila en modo LIFO. Hasta que no se eliminan los elementos más recientes, los
elementos añadidos anteriormente quedan enterrados o no disponibles. Una forma
de conceptualizar el procesamiento de una pila en modo LIFO es como una pila real
de elementos, como platos o libros. El plato de la parte superior de la pila se retira
cuando se elimina uno, y se añaden platos nuevos a la pila apilándolos sobre los
anteriores. Esta conducta es análoga al tratamiento de una pila en modo LIFO.

Hay varias aplicaciones que emplean el modo LIFO. Por ejemplo, en

programación, las llamadas a funciones realizadas dentro de un programa pueden
almacenarse en una pila en modo LIFO. Cada vez que se llama a una función, se
coloca un nuevo elemento en la pila, que se retira mediante una operación pop una
vez que la función ha terminado de ejecutarse, permitiendo que continúe la ejecución
del programa. También se utiliza en la gestión de memoria del sistema operativo,
donde se emplea una pila para mantener los datos relativos a las llamadas a
funciones, variables locales y otros datos necesarios para la ejecución del programa.

En resumen, cuando una pila se procesa en modo LIFO, el último elemento

añadido será el primero en ser eliminado. Para ello se utilizan las operaciones push y
pop, que añaden y eliminan elementos de la parte superior de la pila,
respectivamente. Este estilo de procesamiento, que puede verse como una pila de
objetos físicos con elementos añadidos y eliminados de forma secuencial, es útil en
diversas situaciones, como la programación y la gestión de memoria.

FIFO
Cuando una pila se procesa en modo FIFO (First-In, First-Out), el primer
elemento añadido a la pila será también el primer elemento eliminado. Esto indica que
las piezas se insertan y retiran en un orden preciso.

Los términos "push" y "pop" se refieren a los métodos utilizados para añadir y
eliminar elementos de una pila, respectivamente. Cada vez que se añade un elemento
a la pila mientras se utiliza el modo FIFO. Cuando una pila está en modo FIFO, se
toma el elemento de la parte superior de la pila cuando se eliminan elementos, y
siempre se añaden nuevos elementos al final de la pila.

Por ejemplo, el elemento A se eliminará primero, seguido de los elementos B,

C y D en ese orden, si añadimos los elementos A, B, C y D en ese orden. El miembro
más antiguo de la pila siempre se elimina de esta manera.
 Una estructura de datos que utiliza este método de procesamiento es la
estructura de datos "cola". Según el principio FIFO, los componentes se añaden al
final de una cola y se retiran al principio. En pocas palabras, el procesamiento FIFO
en una pila se refiere a la retirada de elementos en el mismo orden en que fueron
introducidos, teniendo siempre prioridad el miembro más antiguo.

Ejemplos
Estos ejemplos están basados en la implementación de una pila en C++

Ejemplo de uso: Modo FIFO

Ejemplo de uso: Modo LIFO

En los ejemplos anteriores, hemos definido una clase Pila con métodos para
apilar y desapilar elementos. También tiene un mecanismo para determinar si la pila
está vacía. Los elementos son mostrados, según el modo que se esté usando.
Operaciones a realizar con estructura de pila. EJEMPLOS

• Empujar (push): Consiste en empujar un elemento a la parte superior de la pila.

Por ejemplo, si empezamos con una pila vacía y añadimos el número 5,
obtendremos una pila con el número 5. Ejemplo en código:

• Sacar (Pop): Consiste en quitar un elemento de la parte superior de la pila. Por

ejemplo, si tenemos una pila con los números 3, 7 y 2 en esa secuencia,
podemos realizar la operación pop para obtener una pila con los números 3 y
7. Ejemplo en código:

• Comprobar si la pila está vacía (isEmpty): Consiste en determinar si la pila está

vacía, es decir, si no contiene ningún elemento. Por ejemplo, si tenemos una
pila vacía y utilizamos la operación isEmpty, el resultado será true. Ejemplo en
código:
• Obtener el elemento de la parte superior de la pila (top): Consiste en recuperar
el elemento de la parte superior de la pila sin eliminarlo. Por ejemplo, si
tuviéramos una pila con los números 9, 4 y 6 en esa secuencia, la operación
top devolverá el número 9. Ejemplo en código:

• Obtener el tamaño de la pila (tamaño): Consiste en determinar el número de

entradas de la pila. Por ejemplo, si tenemos una pila con los números 1, 2, 3 y
4 en esa secuencia, la operación tamaño devuelve el valor 4. Ejemplo con
código:

• Vaciar la pila (clear): Consiste en eliminar todos los elementos de la pila,

dejándola vacía. Por ejemplo, si tenemos una pila que contiene los enteros 8,
 5 y 2 en ese orden, la operación clear devolverá una pila vacía. Ejemplo en
código:

Estos son sólo algunos ejemplos y operaciones básicas que se pueden realizar
utilizando una estructura de pila. Pueden existir otras operaciones y ejemplos
especializados basados en el contexto y la implementación de la pila.

Diseñar Algoritmos elementales para el tratamiento de pila

En programación, los algoritmos elementales son los más fundamentales y
básicos. Estos algoritmos proporcionan soluciones para una serie de problemas
sencillos y típicos, como sumar una serie de números, encontrar un elemento en una
lista y ordenar elementos de una lista. Estos algoritmos sirven de base tanto para
enseñar ideas fundamentales de programación como para crear algoritmos más
sofisticados.

Aquí se muestran algunos algoritmos elementales para el tratamiento de una

pila, todo utilizando C++, por lo cual los algoritmos pueden cambiar en otros
lenguajes:

Inicializar una pila vacía:

Insertar un elemento en la pila:

Obtener el elemento superior de la pila sin eliminarlo:

Eliminar el elemento superior de la pila:

Verificar si la pila está vacía:

Tamaño de la pila:
Conclusión
En resumen, las pilas son un componente básico de la programación que
permite una gestión y organización eficaces de los datos. Dado que proporcionan un
enfoque organizado y sistemático del manejo de la información, su uso se ha hecho
indispensable en una amplia gama de aplicaciones y algoritmos.

Inicialmente, una pila se describe como una estructura de datos lineal cuyos
elementos se insertan y eliminan de acuerdo con el principio de último en entrar,
primero en salir (LIFO). Esto crea una secuencia razonable para gestionar los
elementos de la pila, ya que el último elemento añadido será el primero en ser
eliminado.

Dependiendo de las necesidades de la aplicación, se puede utilizar una lista

enlazada o un array para representar una pila. Aunque cada enfoque tiene ventajas
e inconvenientes, una lista enlazada proporciona una mayor flexibilidad y eficiencia
para la gestión de la pila en general.

Hay dos formas principales de manejar una pila: LIFO (último en entrar, primero
en salir) y FIFO (primero en entrar, primero en salir). El modo LIFO funciona a la
inversa, mientras que el modo FIFO sugiere que la primera pieza añadida será
también la primera retirada. Es fundamental comprender y aplicar adecuadamente
estos modos, ya que permiten ajustar el comportamiento de la pila para adaptarlo a
diversas necesidades y circunstancias.

Insertar elementos (push), retirar elementos (pop), obtener el elemento

superior de la pila sin retirarlo (Top) y determinar si la pila está vacía (isEmpty) son
algunas operaciones frecuentes a realizar con una estructura de pila. Estos
procedimientos proporcionan una gestión eficaz de la pila y un acceso adecuado a
los datos desde su interior.

A lo largo del estudio se proporcionaron numerosos ejemplos que ilustraban

las ventajas y la adaptabilidad de las pilas en la programación. Estas ilustraciones
mostraban la aplicación de las pilas a la resolución de determinados problemas, como
la reordenación de palabras en frases o la evaluación de fórmulas matemáticas. Las
pilas permitían realizar estas tareas en cualquier situación de forma organizada y
sistemática.
 Por último, es fundamental subrayar lo esencial que resulta crear algoritmos
sencillos de procesamiento de pilas para garantizar un manejo y un funcionamiento
adecuados de los datos. Estos algoritmos deben ser eficaces y tener en cuenta las
propiedades de las pilas, como la forma de añadir y eliminar elementos. También es
importante pensar en las muchas operaciones que se pueden realizar con una pila y
cómo podrían funcionar con el resto del programa.

En conclusión, las pilas son una herramienta crucial en la programación por lo

bien que manejan y organizan los datos. El modo LIFO, que es su característica
principal, ofrece una disposición sensata para gestionar elementos. Además, al poder
utilizar modos como FIFO y LIFO, las pilas permiten llevar a cabo una gran variedad
de actividades y pueden ajustarse a diversos requisitos. Los ejemplos del informe
demuestran la importancia y utilidad de las pilas en el desarrollo de programas. Como
resultado, para maximizar el manejo de datos y resolver problemas con eficacia, la
programación requiere una comprensión y un dominio de las pilas.
Bibliografía
https://informaticaymasparaver.weebly.com/

https://en.wikipedia.org/wiki/Stack_(abstract_data_type)

https://isaaccomputerscience.org/concepts/dsa_datastruct_stack

https://www.thoughtco.com/definition-of-stack-in-programming-958162

https://www.studysmarter.co.uk/explanations/computer-science/data-
structures/stack-in-data-structure/