Algoritmos e Estruturas de Dados em TypeScript: Guia Completo para Iniciantes

Algoritmos e Estruturas de Dados em TypeScript: por onde começar para iniciantes

Compreender algoritmos e estruturas de dados é a base que diferencia um desenvolvedor profissional de um amador. Se você está apenas começando sua jornada na programação com TypeScript, este artigo ajudará você a entender os conceitos-chave. Abordaremos estruturas de dados básicas (arrays, pilha, fila) e algoritmos simples (busca linear e binária), além de mostrar como implementá-los em TypeScript com tipagem estrita.

1. Arrays e como trabalhar com eles em TypeScript

O array é a estrutura de dados mais simples e mais utilizada. Em TypeScript, os arrays podem ser estritamente tipados, o que ajuda a evitar erros em tempo de compilação.

// Declaração de array tipado de númerosconst numbers: number[] = [5, 12, 8, 130, 44];

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

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

// Adicionar elemento ao finalnumbers.push(100);

// Remover o último elementoconst last = numbers.pop();

Importante: O TypeScript verifica os tipos em tempo de compilação. Se você tentar adicionar uma string a um array de números, o compilador emitirá um erro. Isso torna o código mais confiável.

2. Pilha e Fila: princípios LIFO e FIFO

A pilha (Stack) funciona pelo princípio LIFO (Last In, First Out — o último a entrar é o primeiro a sair). A fila (Queue) funciona pelo princípio FIFO (First In, First Out — o primeiro a entrar é o primeiro a sair).

Implementação de pilha em 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

Implementação de fila em 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('tarefa 1');queue.enqueue('tarefa 2');console.log(queue.dequeue()); // 'tarefa 1'

Observe o uso de genéricos <T>. Isso permite criar estruturas de dados que funcionam com qualquer tipo, mantendo a tipagem estrita.

3. Algoritmos de busca: linear e binária

A busca é uma das operações mais comuns. Vamos considerar dois algoritmos básicos.

Busca linear

Percorre todos os elementos do array até encontrar o desejado. Complexidade: 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, retorna o índice        }    }    return -1; // não encontrado}

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

Busca binária (apenas para arrays ordenados)

Divide o array ao meio a cada etapa. Complexidade: O(log n). Isso é significativamente mais rápido que a busca linear 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);