República Bolivariana De Venezuela.

Ministerio Del Poder Popular Para La Educación Universitaria.

Instituto Universitario Tecnológico Coronel Agustín Codazzi.
Barinas Estado Barinas.

Pilas.

Profesor:
Naudy Albornoz. Estudiante:
Ariana Kochmann.

Materia:
Procesamiento De Datos.

Carrera:
Informática.
 Pilas:

Son estructuras de datos lineales que permiten el almacenamiento y recuperación de

información siguiendo una estructura conocida como LIFO (Last In, First Out), lo que
significa que el último elemento ingresado es el primero en ser recuperado.

Estas pilas se componen de nodos o elementos que contienen los datos a almacenar, y
se utilizan en numerosos algoritmos y programas para llevar a cabo un seguimiento
ordenado de las operaciones realizadas en un determinado proceso, permitiendo tanto el
apilamiento de nuevos elementos como la eliminación de los últimos ingresados.

Características De Las Pilas:

Las características de las pilas en procesamiento de datos son las siguientes:

Estructura de datos: Las pilas son una estructura de datos en la que los elementos se
agregan y eliminan siguiendo una regla conocida como "last-in, first-out" (LIFO), lo
que significa que el último elemento agregado es el primero en ser eliminado.

Operaciones básicas: Las operaciones básicas en una pila son la inserción de un

elemento en la parte superior de la pila (push) y la eliminación de un elemento de la
parte superior de la pila (pop). También se pueden ofrecer otras operaciones
adicionales, como la obtención del elemento en la parte superior de la pila sin
eliminarlo (top) y la comprobación si la pila está vacía (isEmpty).

Capacidad limitada: Una pila puede tener una capacidad limitada, es decir, solo puede
contener un número máximo de elementos determinado. Si se intenta agregar un
elemento adicional cuando la pila está llena, se produce un error conocido como
desbordamiento de pila.

Implementación mediante arrays o listas enlazadas: Una pila puede ser implementada
utilizando un array o una lista enlazada. En un array, los elementos se almacenan en
posiciones consecutivas de memoria y se utiliza un puntero para mantener seguimiento
de la posición de la parte superior de la pila. En una lista enlazada, cada elemento de la
pila contiene un valor y un enlace al siguiente elemento de la pila.

Uso en la gestión de llamadas a funciones: Las pilas son frecuentemente utilizadas en el

procesamiento de datos para gestionar llamadas a funciones. Cuando se llama a una
función, se agrega una nueva entrada en la pila, y cuando la función termina, su entrada
correspondiente se elimina de la pila. Esto permite llevar un seguimiento de la
secuencia de llamadas a funciones y garantiza que las funciones se ejecuten y se
devuelvan en orden correcto.
Representación De Las Pilas:

Una pila es una estructura de datos que sigue el principio de LIFO (Last In, First
Out), es decir, el último elemento que se añade es el primero en ser eliminado.
En la representación de las pilas, los elementos se añaden y se eliminan solo por un
extremo llamado "tope". Cuando se añade un elemento a la pila, se coloca en el tope, y
cuando se elimina un elemento, se retira también del tope.

Las pilas se pueden implementar utilizando estructuras de datos como arreglos o

listas enlazadas. En un arreglo, el tope de la pila se representa mediante un índice que
indica la posición del último elemento añadido. En una lista enlazada, cada elemento
tiene un puntero que apunta al elemento siguiente en la pila.

Las pilas son ampliamente utilizadas en el procesamiento de datos y en algoritmos. Se

utilizan en la implementación de estructuras de datos más complejas, como colas,
árboles y grafos, y también se utilizan para resolver problemas como el balanceo de
paréntesis en expresiones matemáticas, el recorrido de árboles binarios y la evaluación
de expresiones posfijas.

Tratamiento De Una Pila:

El tratamiento de una pila, ya sea en modo FIFO (First-In-First-Out) o en modo LIFO

(Last-In-First-Out), se refiere a cómo se gestionan los elementos almacenados en la
pila.

En una pila en modo FIFO, el primer elemento que se añade a la pila es también el
primero en ser eliminado. Esto significa que los elementos se agregan al final de la pila
y se eliminan del principio. Es similar a una cola en la que el primer elemento en llegar
es el primero en ser atendido. Este tipo de pila se utiliza en situaciones donde se
requiere que los elementos se procesen en el orden en que llegaron.

Por otro lado, una pila en modo LIFO funciona de manera opuesta. El último
elemento que se añade a la pila es el primero en ser eliminado. Esto significa que los
elementos se agregan y eliminan del mismo extremo de la pila. Es similar a una pila de
platos, donde el último plato que se colocó es el primero en ser retirado. Este tipo de
pila se utiliza en situaciones donde el orden de procesamiento no importa y se prioriza
el acceso al último elemento añadido.

Operaciones A Realizar Con Estructura De Pilas:

Algunas operaciones típicas que se pueden realizar con estructuras de pilas son:
Push: Agregar un elemento a la parte superior de la pila. Ejemplo: class
Pila:
 def init
(self):
self.items =
[]

def esta_vacia(self):
return self.items ==
[]

def push(self, item):

self.items.append(item
)

# Crear una pila

pila = Pila()

# Verificar si la pila está vacía

print(pila.esta_vacia()) # Debería imprimir: True

# Agregar elementos a la
pila pila.push("manzana")
pila.push("banana")
pila.push("cereza")

# Verificar si la pila está vacía después de agregar elementos

print(pila.esta_vacia()) # Debería imprimir: False

En este código, hemos definido una clase Pila que tiene un método push. Este método
toma un elemento como argumento y lo agrega al final de la lista self.items, que
representa nuestra pila. Así es como se implementa la operación push en una pila.

Pop: Eliminar y retornar el elemento que está en la parte superior de la pila.

Ejemplo: class Pila:

def init
(self):
self.items =
[]

def esta_vacia(self):
return self.items ==
[]

def push(self, item):

self.items.append(item
)
 def pop(self):
if not
self.esta_vacia():
return
self.items.pop()

# Crear una pila

pila = Pila()
# Agregar elementos a la
pila pila.push("manzana")
pila.push("banana")
pila.push("cereza")

# Quitar un elemento de la pila

elemento = pila.pop()
print(elemento) # Debería imprimir: cereza

En este código, hemos definido una clase Pila que tiene un método pop. Este método
verifica si la pila está vacía y, si no lo está, quita el último elemento de la lista
self.items, que representa nuestra pila. Así es como se implementa la operación pop en
una pila.

Peek: Retornar el elemento que está en la parte superior de la pila sin eliminarlo. Ejemplo:
class Pila:
def init
(self):
self.items =
[]

def esta_vacia(self):
return self.items ==
[]

def push(self, item):

self.items.append(item
)

def pop(self):
if not
self.esta_vacia():
return
self.items.pop()

def peek(self):
if not
self.esta_vacia():
 return self.items[-
1]

# Crear una pila

pila = Pila()

# Agregar elementos a la
pila pila.push("manzana")
pila.push("banana")
pila.push("cereza")

# Ver el último elemento de la pila sin quitarlo

elemento = pila.peek()
print(elemento) # Debería imprimir: cereza

En este código, hemos definido una clase Pila que tiene un método peek. Este método
verifica si la pila está vacía y, si no lo está, devuelve el último elemento de la lista
self.items, que representa nuestra pila, sin quitarlo. Así es como se implementa la
operación peek en una pila.

isEmpty: Verificar si la pila está vacía. Ejemplo:

class Pila:
def init
(self):
self.items =
[]

def esta_vacia(self):
return self.items ==
[]

def push(self, item):

self.items.append(item
)

def pop(self):
if not
self.esta_vacia():
return
self.items.pop()

def peek(self):
if not
self.esta_vacia():
return self.items[-
1]
# Crear una pila
pila = Pila()

# Verificar si la pila está vacía

print(pila.esta_vacia()) # Debería imprimir: True

# Agregar elementos a la
pila pila.push("manzana")
pila.push("banana")
pila.push("cereza")
# Verificar si la pila está vacía después de agregar elementos
print(pila.esta_vacia()) # Debería imprimir: False

En e s t e c ó d i g o , h e m o s d e f i n i d o una clase Pila que tiene

un método esta_vacia (que es equivalente a isEmpty en otros lenguajes). Este método
verifica si la pila está vacía devolviendo True si la lista self.items (que representa
nuestra pila) está vacía, y False en caso contrario. Así es como se implementa la
operación isEmpty en una pila.

isFull: Verificar si la pila está llena (en el caso de implementar una pila con tamaño
fijo). Ejemplo:
#include <stdio.h>
#define
MAX_SIZE 10
typedef struct {
int
items[MAX_SIZE]
; int top;
} Stack;

void initialize(Stack
*s) { s->top = -1;
}

int isFull(Stack *s) {

return s->top == MAX_SIZE - 1;
}

int main() {
Stack myStack;
initialize(&myStack);

if(isFull(&myStack)) {
printf("La pila está llena.\n");
} else {
 printf("La pila no está llena.\n");
}

return 0;
}

En este código, la pila tiene un tamaño máximo de 10. La función isFull verifica si el
índice del elemento superior de la pila (top) es igual a MAX_SIZE - 1, lo que indicaría
que la pila está llena. Si es así, la función devuelve 1 (verdadero); si no, devuelve 0
(falso).

Size: Obtener la cantidad de elementos que están en la pila. Ejemplo:

class Pila:
def init
(self):
self.items =
[]

def esta_vacia(self):
return self.items ==
[]

def push(self, item):

self.items.append(item
)

def pop(self):
if not
self.esta_vacia():
return
self.items.pop()
def peek(self):
if not
self.esta_vacia():
return self.items[-
1]

def size(self):
return len(self.items)

# Crear una pila

pila = Pila()

# Agregar elementos a la
pila pila.push("manzana")
pila.push("banana")
pila.push("cereza")

# Obtener el tamaño de la pila

tamanio = pila.size()
print(tamanio) # Debería imprimir: 3

En este código, hemos definido una clase Pila que tiene un método size. Este método
devuelve el número de elementos en la pila, que es igual a la longitud de la lista
self.items que representa nuestra pila. Así es como se implementa la operación size en
una pila.

Clear: Eliminar todos los elementos de la pila. Ejemplo:

class Pila:
def init
(self):
self.items =
[]

def esta_vacia(self):
return self.items ==
[]

def push(self, item):

self.items.append(item
)

def pop(self):
if not
self.esta_vacia():
return
self.items.pop()

def peek(self):
if not
self.esta_vacia():
return self.items[-
1]

def size(self):
return len(self.items)

def clear(self):

self.items = []

# Crear una pila

pila = Pila()

# Agregar elementos a la
pila pila.push("manzana")
pila.push("banana")
pila.push("cereza")

# Limpiar la pila
pila.clear()
# Verificar si la pila está vacía después de limpiarla
print(pila.esta_vacia()) # Debería imprimir: True

En este código, hemos definido una clase Pila que tiene un método clear. Este
método vacía la pila al reasignar self.items a una lista vacía. Así es como se
implementa la operación clear en una pila.

Imprimir: Mostrar todos los elementos de la pila en el orden en que se encuentran,

generalmente desde la parte superior hasta la inferior. Ejemplo:
class Pila:
def init
(self):
self.items =
[]

def esta_vacia(self):
return self.items ==
[]

def push(self, item):

self.items.append(item
)

def pop(self):
if not
self.esta_vacia():
return
self.items.pop()

def peek(self):
if not
self.esta_vacia():
return self.items[-
1]

def size(self):
return len(self.items)
 def clear(self):
self.items =
[]

def imprimir(self):
for item in reversed(self.items):

print(item)

# Crear una pila

pila = Pila()

# Agregar elementos a la
pila pila.push("manzana")
pila.push("banana")
pila.push("cereza")
# Imprimir la pila
pila.imprimir() # Debería imprimir: cereza, banana, manzana

En este código, hemos definido una clase Pila que tiene un método imprimir. Este
método recorre la lista self.items (que representa nuestra pila) en orden inverso (desde
el último elemento hasta el primero) e imprime cada elemento. Así es como se
implementa la operación imprimir en una pila.

Diseñar Algoritmos Elementales Para El Tratamiento De Pilas:

Algunos algoritmos básicos para el manejo de pilas en Python son los siguientes:

Crear una pila vacía:

def
crear_pila
(): pila =
[] return
pila

Verificar si la pila está vacía:

def esta_vacia(pila):
return len(pila) ==
0

Agregar un elemento a la pila:

def agregar(pila, item):
pila.append(item)
Eliminar un elemento de la
pila: def eliminar(pila):
if (esta_vacia(pila)):
return "La pila está vacía"
return pila.pop()

Ver el elemento en la cima de la pila:

def ver_cima(pila):
if (esta_vacia(pila)):
return "La pila está vacía"
return pila[-1]

Ejemplo de una operación con estructura de pilas en Python:

class Pila:
def init
(self):
self.items =
[]

def esta_vacia(self):
return self.items ==
[]

def agregar(self, item):

self.items.append(item
)

def eliminar(self):
return self.items.pop()

def ver_cima(self):
return self.items[len(self.items)-1]

def tamano(self):
return
len(self.items)

# Crear una pila

pila = Pila()

# Agregar elementos
pila.agregar("a")
pila.agregar("b")
pila.agregar("c")

# Ver el elemento en la cima de la pila

print(pila.ver_cima()) # "c"

# Eliminar elementos
print(pila.eliminar()) # "c"
print(pila.eliminar()) # "b"

En este código, los elementos se agregan y se eliminan desde el final de la lista, lo

que simula el comportamiento LIFO (Last In, First Out) de una pila. Cuando ejecutas
este código, los elementos se eliminan en el orden inverso al que se agregaron, es decir,
“c”, “b”, “a”. Esto es característico de una pila. Además, puedes ver el elemento en la
cima de la pila sin eliminarlo con la función ver_cima().