Estructura de DatosDEFINICIÓN

Una estructura de datos es una manera de organizar y almacenar datos para que puedan ser utilizados de manera eficiente. Incluye las operaciones que se pueden realizar sobre esos datos, así como las relaciones entre los diferentes tipos de datos

PilaStack

Es una estructura de datos que sigue el principio de LIFO (Last In, First Out). Esto significa que el último elemento añadido es el primero en ser eliminado.

Operaciones Principales:

Push: Añadir un elemento a la parte superior de la pila.
Pop: Eliminar y devolver el elemento de la parte superior de la pila.
Peek: Ver el elemento en la parte superior sin eliminarlo.
IsEmpty: Comprobar si la pila está vacía.

Uso Común: Las pilas son útiles en diversas aplicaciones, como:

Manejo de la recursión.
Implementación de deshacer/rehacer en aplicaciones.
Evaluación de expresiones y conversión de notación (por ejemplo, de infija a postfija).

Código en Python:


    class Pila:
        def __init__(self):
        self.elementos = []

        def push(self, valor):
        self.elementos.append(valor)

        def pop(self):
        if not self.is_empty():
        return self.elementos.pop()
        else:
        raise IndexError("La pila está vacía.")

        def peek(self):
        if not self.is_empty():
        return self.elementos[-1]
        else:
        raise IndexError("La pila está vacía.")

        def is_empty(self):
        return len(self.elementos) == 0

    # Uso de la pila
    pila = Pila()
    pila.push(1)
    pila.push(2)
    pila.push(3)

    print(pila.pop())  # Salida: 3
    print(pila.peek()) # Salida: 2
    print(pila.is_empty()) # Salida: False

ColaQueue

Es una estructura de datos que sigue el principio de FIFO (First In, First Out). Esto significa que el primer elemento añadido es el primero en ser eliminado.

Operaciones Principales:

Enqueue: Añadir un elemento al final de la cola.
Dequeue: Eliminar y devolver el elemento del frente de la cola.
Peek: Ver el elemento en el frente de la cola sin eliminarlo.
IsEmpty: Comprobar si la cola está vacía.

Uso Común: Las colas son útiles en diversas aplicaciones, como:

Manejo de tareas en sistemas operativos (por ejemplo, en la planificación de procesos).
Implementación de algoritmos de búsqueda en grafos.
Gestión de eventos en sistemas de tiempo real.

Código en Python:


class Cola:
    def __init__(self):
        self.elementos = []

    def enqueue(self, valor):
        self.elementos.append(valor)

    def dequeue(self):
        if not self.is_empty():
            return self.elementos.pop(0)
        else:
            raise IndexError("La cola está vacía.")

    def peek(self):
        if not self.is_empty():
            return self.elementos[0]
        else:
            raise IndexError("La cola está vacía.")

    def is_empty(self):
        return len(self.elementos) == 0

# Uso de la cola
cola = Cola()
cola.enqueue(1)
cola.enqueue(2)
cola.enqueue(3)

print(cola.dequeue())  # Salida: 1
print(cola.peek())     # Salida: 2
print(cola.is_empty()) # Salida: False

DequeDouble-ended Queue

Es una estructura de datos que permite la inserción y eliminación de elementos desde ambos extremos, es decir, tanto desde el frente como desde la parte trasera.

Operaciones Principales:

Append: Añadir un elemento al final del deque.
Appendleft: Añadir un elemento al comienzo del deque.cola.
Pop: Eliminar y devolver el elemento del final del deque.
Popleft: Eliminar y devolver el elemento del frente del deque.
IsEmpty: Comprobar si el deque está vacío.

Uso Común: Los deques son útiles en situaciones donde se necesita acceder y modificar elementos desde ambos extremos, como:

Implementación de algoritmos que requieren acceso eficiente a ambos lados de la colección (por ejemplo, en algoritmos de búsqueda).
Manejo de tareas que pueden ser procesadas de manera flexible.

Código en Python:


from collections import deque

class Deque:
    def __init__(self):
        self.elementos = deque()

    def append(self, valor):
        self.elementos.append(valor)

    def appendleft(self, valor):
        self.elementos.appendleft(valor)

    def pop(self):
        if not self.is_empty():
            return self.elementos.pop()
        else:
            raise IndexError("El deque está vacío.")

    def popleft(self):
        if not self.is_empty():
            return self.elementos.popleft()
        else:
            raise IndexError("El deque está vacío.")

    def is_empty(self):
        return len(self.elementos) == 0

# Uso del deque
deque = Deque()
deque.append(1)
deque.append(2)
deque.appendleft(0)

print(deque.pop())       # Salida: 2
print(deque.popleft())   # Salida: 0
print(deque.is_empty())  # Salida: False

Parte 2