Wilfredo Melendez 27434627 AsignacionPilas

REPÚBLICA BOLIVARIANA DE VENEZUELA
MINISTERIO DEL PODER POPULAR PARA LA

EDUCACIÓN UNIVERSITARIA,
CIENCIA Y TECNOLOGÍA
INSTITUTO UNIVERSITARIO POLITÉCNICO
“SANTIAGO MARIÑO”
EXTENSIÓN MARACAY
Estructura de Datos
Evaluación
Autor:
Wilfredo Melendez
V-27.434.627
Ing. En Sistemas
Maracay, Agosto 2024

Una pila es una estructura de datos que sigue el principio de Last In, First
Out (LIFO). Esto significa que el último elemento añadido a la pila es el primero en
ser eliminado. Imagina una pila de platos en una cafetería: cuando apilas platos, el
último plato que colocas en la pila es el primero que se retira cuando alguien toma
un plato. En programación, las pilas se utilizan para gestionar elementos de manera
eficiente, como en la evaluación de expresiones matemáticas o en el seguimiento
de llamadas a funciones.
Aquí tienes algunas de las características principales de las pilas:

Last In, First Out (LIFO):
En una pila, el último elemento que se añade es el primero en ser
eliminado.
Operaciones Básicas:
Las operaciones fundamentales en una pila son:
Push (Empujar): Agregar un elemento en la parte superior de la pila.
Pop (Sacar): Eliminar el elemento superior de la pila.
Top/Peek (Tope/Vistazo): Observar el elemento superior sin
eliminarlo.
isEmpty (Está vacía): Verificar si la pila no tiene elementos.
Estructura Lineal:
Las pilas son estructuras de datos lineales, lo que significa que los
elementos están organizados en una secuencia unidimensional.
Implementación con Arreglos o Listas Enlazadas:
Las pilas pueden implementarse utilizando arreglos (arrays) o listas
enlazadas. Cada enfoque tiene sus ventajas y desventajas en términos de eficiencia
y flexibilidad.
Limitación de Capacidad:
Las pilas pueden tener una capacidad máxima, y si esta capacidad se
supera, puede ocurrir un desbordamiento de pila (stack overflow).
Eficiencia en la Gestión de Datos:
Las operaciones de una pila, como «Push» y «Pop», generalmente
tienen una complejidad de tiempo constante O(1), lo que las hace eficientes para la
gestión de datos.
Recursión:
La estructura de pila es fundamental para entender la recursión en
programación. Cada llamada recursiva se agrega a la pila y se resuelve en orden
inverso (LIFO).
Balanceo de Paréntesis:
Las pilas son útiles para verificar el equilibrio de paréntesis en
expresiones matemáticas y de programación.
Manejo de Excepciones:
Se utilizan para el manejo eficiente de excepciones y errores, ya que
permiten rastrear y deshacer acciones en un orden específico.
Estas características hacen que las pilas sean una estructura de datos
versátil y ampliamente utilizada en programación para organizar y gestionar datos
de manera eficiente.
Creamos una pila vacía usando pila = [].

Recorremos cada caracter en la cadena usando un bucle for.
Si encontramos un paréntesis de apertura ‘(‘, lo agregamos a la pila
usando pila.append(caracter).
Si encontramos un paréntesis de cierre ‘)’, verificamos si hay un
paréntesis de apertura correspondiente en la pila. Si la pila está vacía, significa que
no hay un paréntesis de apertura correspondiente, y devolvemos False. Si hay un
paréntesis de apertura en la pila, lo eliminamos usando pila.pop().
Al final, la cadena está balanceada si la pila está vacía. Devolvemos True
si la pila está vacía, indicando que todos los paréntesis han sido emparejados
correctamente. En caso contrario, devolvemos False.
En el mundo de las estructuras de datos, nos encontramos con dos
conceptos fundamentales: FIFO (First In, First Out) y LIFO (Last In, First Out). Estos
términos describen el orden en que los elementos son procesados o eliminados de
una estructura de datos.
FIFO es como una fila en un banco: el primer cliente que llega es el

primero en ser atendido.
LIFO es como una pila de platos: el último plato que se coloca es el
primero en ser retirado.
FIFO se usa para implementar colas, similares a las filas en la vida real.
Imagina una cola para comprar entradas de cine: la primera persona que llega es la
primera en comprar su entrada. LIFO, por otro lado, se aplica en estructuras
conocidas como pilas. Piensa en una pila de libros: cuando añades un nuevo libro,
se coloca encima de todos, y cuando tomas uno, coges el que está arriba.
Crear: Inicia una cola vacía.

Encolar: Añade un elemento al final de la cola.
Desencolar: Elimina el elemento que está al frente. Frente: Muestra el
primer elemento, sin eliminarlo.
Apilar (push): Añade un elemento en la cima.
Retirar (pop): Elimina el elemento de la cima.
Crear (constructor): Inicia una pila vacía.
Tamaño (size): Devuelve el número de elementos.
Leer último (top o peek): Muestra el elemento de la cima sin eliminarlo.
Vacía (empty): Verifica si la pila está vacía.
Agregar un elemento (push): Para añadir un elemento a la pila, utiliza la

operación push. Esto coloca el elemento en la parte superior de la pila.
Eliminar un elemento (pop): La operación pop elimina el elemento
superior de la pila y devuelve su valor.
Consultar el elemento superior (top): Puedes usar la operación top para
obtener el valor del elemento en la parte superior de la pila sin eliminarlo.
Verificar si la pila está vacía: Utiliza la función isEmpty() para verificar si
la pila no contiene ningún elemento.
Obtener el tamaño de la pila: La función size() te dará el número de
elementos en la pila.
Inicialización de una pila:

Para crear una pila vacía, simplemente declara una estructura de datos
(como un arreglo o una lista enlazada) que represente la pila.
stack = [] # Creación de una pila vacía
Empujar (Push):
Agregar un elemento a la parte superior de la pila.
Utiliza la operación push para insertar un valor en la pila.
def push(stack, item):

stack.append(item)
push(stack, 10) # Agrega 10 a la pila
Desapilar (Pop):
Eliminar el elemento superior de la pila.
Utiliza la operación pop para extraer el valor del elemento superior.
def pop(stack):
if not isEmpty(stack):
return stack.pop()
popped_item = pop(stack) # Elimina el elemento superior

Consultar la cima (Top o Peek):
Obtener el valor del elemento en la parte superior de la pila sin eliminarlo.
Utiliza la función top o peek.
def top(stack):
if not isEmpty(stack):
return stack[-1]
top_item = top(stack) # Obtiene el elemento superior
Verificar si la pila está vacía:

Utiliza la función isEmpty para determinar si la pila no contiene
elementos.
def isEmpty(stack):
return len(stack) == 0
is_empty = isEmpty(stack) # Verifica si la pila está vacía
Obtener el tamaño de la pila:
La función size devuelve la cantidad de elementos en la pila.

def size(stack):
return len(stack)
stack_size = size(stack) # Tamaño actual de la pila

Mediante programación en C++, realizar un programa que permita Ejercicio
de Pilas, que devuelva la suma de las claves pares de una pila de números enteros
que ocupan pares empezando a contar desde la cima.
En este programa:
Creamos una pila de números enteros usando stack<int>.

Agregamos algunos números a la pila (puedes modificar estos valores
según tus necesidades).
La función sumaClavesPares recorre la pila, verifica si cada clave es par
y las suma.
Finalmente, mostramos el resultado por pantalla.
Este tipo de pila sigue el principio de Last In, First Out (LIFO), ya que el
último elemento agregado es el primero en ser eliminado y siendo de cantidad de
elementos.
A través de la programación en C++, desarrollaremos un programa haciendo uso
de Pilas, donde nos permita apilar pilas. El programa consistirá en crear un menú
con 3 opciones que incluya lo siguiente (apilar, ver pilas y salir).
La clase Pila se define con un puntero privado llamado raiz, que apunta al primer
nodo de la pila.
El constructor Pila() inicializa raiz como NULL.
El método insertar(int x) agrega un nuevo nodo con el valor x al principio de la
pila.
El método imprimir() muestra todos los elementos de la pila.
El método extraer() elimina el último elemento de la pila y devuelve su valor.
El destructor ~Pila() libera la memoria de todos los nodos de la pila.
En la función main(), se crea una instancia de Pila, se insertan valores (10, 40 y
3), se muestra la pila y se extrae un valor.
Este programa utiliza una pila (o lista LIFO) para almacenar los elementos. Los
elementos se insertan y extraen desde el mismo extremo (el principio), siguiendo la
lógica de “último en entrar, primero en salir” (LIFO) y siendo de apilar.
Ejercicio 3
La estructura nodo representa un elemento de la pila y contiene un campo placa

(para almacenar la información del carro) y un puntero sig (para apuntar al siguiente
nodo en la pila).
La función ingresar() agrega un nuevo nodo a la pila.
La función sacar() elimina el último nodo agregado a la pila.
La función mostrar() muestra los carros en la pila en orden inverso.
Recuerda que una pila sigue la regla “Last In, First Out” (LIFO), por lo que solo
puedes eliminar el último elemento agregado.
Ejercicio 4
stack<string> miPila;: Creamos una pila de cadenas de texto llamada miPila.

miPila.push("Hola");: Agregamos la cadena “Hola” a la pila.
miPila.push("Mundo");: Agregamos la cadena “Mundo” a la pila.
string resultado = miPila.top();: Obtenemos el elemento en el tope de la pila (último
agregado) y lo almacenamos en resultado.
miPila.pop();: Eliminamos el elemento del tope de la pila.
resultado += " " + miPila.top();: Concatenamos el siguiente elemento de la pila con
el contenido de resultado.
miPila.pop();: Eliminamos el segundo elemento del tope de la pila.
cout << "Resultado de la concatenación: " << resultado << endl;: Mostramos el
resultado de la concatenación por pantalla.

Wilfredo Melendez 27434627 AsignacionPilas

Cargado por

Copyright:

Formatos disponibles

Wilfredo Melendez 27434627 AsignacionPilas

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Wilfredo Melendez 27434627 AsignacionPilas

Cargado por

Copyright:

Formatos disponibles

REPÚBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA

Maracay, Agosto 2024

Aquí tienes algunas de las características principales de las pilas:

Creamos una pila vacía usando pila = [].

FIFO es como una fila en un banco: el primer cliente que llega es el

Crear: Inicia una cola vacía.

Agregar un elemento (push): Para añadir un elemento a la pila, utiliza la

Inicialización de una pila:

def push(stack, item):

push(stack, 10) # Agrega 10 a la pila

popped_item = pop(stack) # Elimina el elemento superior

top_item = top(stack) # Obtiene el elemento superior

Verificar si la pila está vacía:

is_empty = isEmpty(stack) # Verifica si la pila está vacía

Obtener el tamaño de la pila:

La función size devuelve la cantidad de elementos en la pila.

stack_size = size(stack) # Tamaño actual de la pila

Creamos una pila de números enteros usando stack<int>.

La estructura nodo representa un elemento de la pila y contiene un campo placa

stack<string> miPila;: Creamos una pila de cadenas de texto llamada miPila.

También podría gustarte