Algoritmos y estructuras de datos en TypeScript: guía completa

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Introducción: ¿Por qué son importantes los algoritmos y las estructuras de datos en TypeScript?

En el desarrollo web moderno, TypeScript ocupa una posición líder, ofreciendo tipado estricto y herramientas potentes para crear aplicaciones escalables. Sin embargo, incluso el código más elegante no será eficiente sin comprender los algoritmos y estructuras de datos fundamentales. Este artículo es tu guía hacia el mundo del código optimizado en TypeScript. Analizaremos las estructuras de datos clave, mostraremos cómo implementarlas teniendo en cuenta los tipos y revisaremos algoritmos clásicos. Después de leerlo, podrás escribir código que no solo funcione, sino que sea rápido y predecible.

1. Estructuras de datos básicas con tipado

TypeScript permite definir estrictamente qué tipos de datos pueden almacenarse en una estructura. Esto previene errores en la etapa de compilación. Consideremos tres estructuras fundamentales.

1.1. Pila (Stack) — principio LIFO

La pila funciona bajo el principio "último en entrar, primero en salir" (Last In, First Out). Es ideal para tareas donde se necesita deshacer acciones (por ejemplo, el historial del navegador).

// Implementación de una pila con genérico Tclass Stack<T> {    private items: T[] = [];

    push(item: T): void {        this.items.push(item);    }

    pop(): T | undefined {        return this.items.pop();    }

    peek(): T | undefined {        return this.items[this.items.length - 1];    }

    isEmpty(): boolean {        return this.items.length === 0;    }}

// Ejemplo de usoconst numberStack = new Stack<number>();numberStack.push(10);numberStack.push(20);console.log(numberStack.pop()); // 20

1.2. Cola (Queue) — principio FIFO

La cola funciona bajo el principio "primero en entrar, primero en salir" (First In, First Out). Se utiliza para procesar tareas en el orden en que llegan, por ejemplo, en sistemas de colas de mensajes.

class Queue<T> {    private items: T[] = [];

    enqueue(item: T): void {        this.items.push(item);    }

    dequeue(): T | undefined {        return this.items.shift();    }

    front(): T | undefined {        return this.items[0];    }

    size(): number {        return this.items.length;    }}

// Ejemplo con un tipo personalizadointerface Task {    id: number;    name: string;}const taskQueue = new Queue<Task>();taskQueue.enqueue({ id: 1, name: 'Procesar pedido' });taskQueue.enqueue({ id: 2, name: 'Enviar email' });

1.3. Lista enlazada (Linked List)

La lista enlazada consiste en nodos, cada uno de los cuales referencia al siguiente. A diferencia de un array, insertar y eliminar elementos en medio de la lista no requiere desplazar todos los elementos.

class ListNode<T> {    value: T;    next: ListNode<T> | null = null;

    constructor(value: T) {        this.value = value;    }}

class LinkedList<T> {    private head: ListNode<T> | null = null;

    add(value: T): void {        const newNode = new ListNode(value);        if (!this.head) {            this.head = newNode;            return;        }        let current = this.head;        while (current.next) {            current = current.next;        }        current.next = newNode;    }

    print(): void {        let current = this.head;        while (current) {            console.log(current.value);            current = current.next;        }    }}

// Usoconst list = new LinkedList<string>();list.add('TypeScript');list.add('Python');list.print(); // TypeScript, Python