Tipos Abstractos de Datos TAD

Introducción a los Tipos Abstractos de Datos (TAD) y Modularización

1. Introducción a los Tipos Abstractos de Datos (TAD)

1. Definición:

   • Los Tipos Abstractos de Datos (TAD) son estructuras que permiten organizar y gestionar datos de manera eficiente. Suelen utilizarse para representar problemas reales y resolverlos de forma estructurada.

2. TAD más comunes:

   • Secuencia: Una colección ordenada de elementos, como una lista de tareas en una fábrica.
   • Pila: Sigue la regla LIFO (Last In, First Out), como una pila de piezas que se apilan y se retiran en una línea de producción.
   • Cola: Sigue la regla FIFO (First In, First Out), como una cola de espera de tareas para ser ejecutadas por un robot.
   • Arreglo: Colección de datos de tamaño fijo, similar a un conjunto de sensores o elementos de una máquina.
   • Conjunto: Almacena elementos únicos sin orden, útil para evitar duplicaciones en listas de inventario.
   • Diccionario: Almacena pares de clave-valor, como un catálogo de productos industriales con nombre y cantidad.

2. Ejemplo práctico: Pila de productos en un almacén industrial

Contexto: Vamos a suponer que una fábrica tiene una pila de cajas que deben almacenarse y retirarse en un orden particular (LIFO). Vamos a crear una simulación de esta pila utilizando Python.

Código en Python (Pila de productos):

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

    def apilar(self, item):
        self.items.append(item)

    def desapilar(self):
        if not self.esta_vacia():
            return self.items.pop()
        else:
            return "La pila está vacía"

    def esta_vacia(self):
        return len(self.items) == 0

    def ver_pila(self):
        return self.items

# Ejemplo de uso
pila_productos = Pila()
pila_productos.apilar("Producto A")
pila_productos.apilar("Producto B")
pila_productos.apilar("Producto C")

print(pila_productos.ver_pila())  # ['Producto A', 'Producto B', 'Producto C']
print(pila_productos.desapilar()) # 'Producto C'
print(pila_productos.ver_pila())  # ['Producto A', 'Producto B']

3. Introducción a la Modularización

Definición:

• La modularización es una técnica que permite dividir un problema en módulos o funciones más pequeños y manejables, mejorando la organización y la claridad del código.

Ejemplo:

• Supongamos que un robot en una fábrica tiene múltiples tareas (como apilar cajas, mover productos, etc.). Cada una de estas tareas se puede definir como una función independiente.

Código en Python (Modularización de tareas en un robot):

def apilar(producto, pila):
    pila.append(producto)
    print(f'{producto} apilado')

def desapilar(pila):
    if len(pila) > 0:
        return pila.pop()
    else:
        print("La pila está vacía")

# Simulación de una pila de productos
pila = []
apilar("Producto A", pila)
apilar("Producto B", pila)
print(f'Se desapila: {desapilar(pila)}')  # Producto B

4. Actividad práctica: Implementación de una Cola de tareas

Contexto: En una línea de producción, las tareas se organizan en una cola, donde las primeras en entrar son las primeras en ejecutarse (FIFO). Los alumnos programarán una cola para gestionar tareas de un robot.

Código en Python (Cola de tareas):

from collections import deque

# Definición de la cola
cola_tareas = deque()

# Agregar tareas
cola_tareas.append('Verificar sensores')
cola_tareas.append('Mover producto A')
cola_tareas.append('Apilar cajas')

# Eliminar la primera tarea de la cola
tarea_actual = cola_tareas.popleft()
print(f'Tarea ejecutada: {tarea_actual}')
# Verificar tareas pendientes
print(f'Cola restante: {cola_tareas}')  # ['Mover producto A', 'Apilar cajas']