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

Algoritmos y estructuras de datos en TypeScript: por dónde empezar para un principiante

Comprender los algoritmos y las estructuras de datos es la base que distingue a un desarrollador profesional de un aficionado. Si apenas estás comenzando tu camino en la programación con TypeScript, este artículo te ayudará a comprender los conceptos clave. Analizaremos las estructuras de datos básicas (arrays, pila, cola) y algoritmos simples (búsqueda lineal y binaria), y también mostraremos cómo implementarlos en TypeScript teniendo en cuenta la tipificación estricta.

1. Arrays y trabajo con ellos en TypeScript

El array es la estructura de datos más simple y más utilizada. En TypeScript, los arrays pueden estar estrictamente tipificados, lo que ayuda a evitar errores en la etapa de compilación.

// Declaración de un array tipificado de númerosconst numbers: number[] = [5, 12, 8, 130, 44];

// Array de cadenasconst fruits: Array<string> = ['apple', 'banana', 'cherry'];

// Acceso por índiceconsole.log(numbers[0]); // 5

// Agregar un elemento al finalnumbers.push(100);

// Eliminar el último elementoconst last = numbers.pop();

Importante: TypeScript verifica los tipos en la etapa de compilación. Si intentas agregar una cadena a un array de números, el compilador mostrará un error. Esto hace que el código sea más confiable.

2. Pila y cola: principios LIFO y FIFO

La pila (Stack) funciona bajo el principio LIFO (Last In, First Out — el último en entrar es el primero en salir). La cola (Queue) funciona bajo el principio FIFO (First In, First Out — el primero en entrar es el primero en salir).

Implementación de una pila en TypeScript

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

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

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

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

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

// Usoconst stack = new Stack<number>();stack.push(10);stack.push(20);console.log(stack.pop()); // 20console.log(stack.peek()); // 10

Implementación de una cola en TypeScript

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

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

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

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

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

// Usoconst queue = new Queue<string>();queue.enqueue('tarea 1');queue.enqueue('tarea 2');console.log(queue.dequeue()); // 'tarea 1'

Observa el uso de genéricos <T>. Esto permite crear estructuras de datos que funcionan con cualquier tipo, manteniendo al mismo tiempo una tipificación estricta.

3. Algoritmos de búsqueda: lineal y binaria

La búsqueda es una de las operaciones más comunes. Consideremos dos algoritmos básicos.

Búsqueda lineal

Recorre todos los elementos del array hasta encontrar el deseado. Complejidad: O(n).

function linearSearch<T>(arr: T[], target: T): number {    for (let i = 0; i < arr.length; i++) {        if (arr[i] === target) {            return i; // encontrado, devuelve el índice        }    }    return -1; // no encontrado}

const data = [3, 7, 1, 9, 4];console.log(linearSearch(data, 9)); // 3console.log(linearSearch(data, 10)); // -1

Búsqueda binaria (solo para arrays ordenados)

Divide el array por la mitad en cada paso. Complejidad: O(log n). Esto es significativamente más rápido que la búsqueda lineal para arrays grandes.

function binarySearch(arr: number[], target: number): number {    let left = 0;    let right = arr.length - 1;

    while (left <= right) {        const mid = Math.floor((left + right) / 2);