Algoritmos e estruturas de dados em TypeScript: guia completo

Algoritmos e Estruturas de Dados em TypeScript: do Iniciante ao Profissional

Algoritmos e estruturas de dados são a base sobre a qual se constrói todo o desenvolvimento de software moderno. Independentemente de você estar escrevendo frontend em React, backend em Node.js ou um aplicativo móvel, uma compreensão profunda desses conceitos permite criar aplicações eficientes, escaláveis e rápidas. Neste artigo, vamos detalhar os principais algoritmos e estruturas de dados em TypeScript — uma linguagem que combina a flexibilidade do JavaScript com o rigor da tipagem estática.

TypeScript é ideal para aprender algoritmos: a tipagem estática ajuda a evitar erros em tempo de compilação, e o suporte a generics permite criar estruturas de dados universais e reutilizáveis. Começaremos com conceitos simples e, gradualmente, passaremos para tópicos mais complexos, acompanhando cada etapa com exemplos de código claros.

1. Estruturas de Dados Básicas: Pilha e Fila

Pilha (Stack) e Fila (Queue) são estruturas de dados lineares básicas, usadas em toda parte: desde o gerenciamento do histórico do navegador até o agendamento de tarefas em sistemas operacionais. Vamos ver suas implementações em TypeScript.

Pilha (LIFO — Last In, First Out)

A pilha funciona pelo princípio "o último a entrar é o primeiro a sair". As operações principais são: push (adicionar elemento) e pop (remover o último elemento).

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;    }

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

// Exemplo de usoconst stack = new Stack<number>();stack.push(1);stack.push(2);stack.push(3);console.log(stack.pop()); // 3console.log(stack.peek()); // 2

Fila (FIFO — First In, First Out)

A fila funciona pelo princípio "o primeiro a entrar é o primeiro a sair". As operações principais são: enqueue (adicionar ao final) e dequeue (remover do início).

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;    }

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

// Exemplo de usoconst queue = new Queue<string>();queue.enqueue("Primeiro");queue.enqueue("Segundo");queue.enqueue("Terceiro");console.log(queue.dequeue()); // "Primeiro"console.log(queue.front()); // "Segundo"

2. Algoritmos de Busca: Busca Linear e Busca Binária

A busca de dados é uma das operações mais comuns na programação. Veremos duas abordagens principais: a busca linear (simples, mas lenta) e a busca binária (rápida, mas que requer dados ordenados).

Busca Linear

O algoritmo verifica sequencialmente cada elemento do array até encontrar o alvo. Complexidade de tempo: O(n).

function linearSearch<T>(arr: T[], target: T): number {    for (let i = 0; i < arr.length; i++) {        if (arr[i] === target) {            return i; // Retorna o índice do elemento encontrado        }    }    return -1; // Elemento não encontrado}

// Exemploconst numbers = [10, 20, 30, 40, 50];console.log(linearSearch(numbers, 30)); // 2console.log(linearSearch(numbers, 60)); // -1

Busca Binária

A busca binária funciona apenas em arrays ordenados. Ela divide o array ao meio a cada etapa, descartando a metade ```