Algoritmos e estruturas de dados em JavaScript para iniciantes

Treinador Online de Python para Iniciantes

Aprenda Python facilmente sem sobrecarga teórica. Resolva tarefas práticas com verificação automática e escreva código diretamente no navegador.

Start Course

Introdução: por que estudar algoritmos e estruturas de dados em JavaScript?

Qualquer programa não é apenas um conjunto de instruções, mas uma forma de gerenciar dados de forma eficiente. Para desenvolvedores iniciantes em JavaScript (especialmente no ambiente Node.js), entender algoritmos e estruturas de dados não é apenas uma tarefa acadêmica, mas uma habilidade prática que impacta diretamente o desempenho e a legibilidade do código.

JavaScript é uma linguagem com tipagem dinâmica, mas isso não elimina a necessidade de saber como funcionam arrays, pilhas ou filas. Sem esse conhecimento, seu código pode se tornar lento e a lógica, confusa. Neste artigo, abordaremos estruturas de dados e algoritmos básicos com exemplos em Node.js que ajudarão você a escrever aplicações mais eficientes.

Principais estruturas de dados em JavaScript (Node.js)

O JavaScript possui várias estruturas de dados embutidas, mas para um entendimento profundo é necessário saber implementá-las manualmente. Isso dá controle sobre a memória e a velocidade de execução.

Arrays (Array)

Arrays em JS são listas dinâmicas. São ideais para armazenar dados ordenados. No entanto, é importante lembrar que inserir ou remover um elemento no início do array (unshift/shift) é uma operação O(n), pois requer o deslocamento de todos os elementos.

// Criando um arrayconst fruits = ['apple', 'banana', 'cherry'];

// Adicionar ao final (O(1))fruits.push('orange');

// Remover do final (O(1))fruits.pop();

// Buscar elemento (O(n))const index = fruits.indexOf('banana');console.log(index); // 1

Pilhas (Stack)

A pilha funciona pelo princípio LIFO (Last In, First Out). É uma estrutura indispensável para processar chamadas de funções, desfazer ações (undo) ou verificar parênteses no código.

class Stack {    constructor() {        this.items = [];    }

    push(element) {        this.items.push(element);    }

    pop() {        if (this.isEmpty()) return null;        return this.items.pop();    }

    peek() {        return this.items[this.items.length - 1];    }

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

// Exemplo de uso: verificação de parêntesesconst stack = new Stack();const str = '({[]})';let isValid = true;

for (let char of str) {    if (char === '(' || char === '{' || char === '[') {        stack.push(char);    } else {        const last = stack.pop();        if (            (char === ')' && last !== '(') ||            (char === '}' && last !== '{') ||            (char === ']' && last !== '[')        ) {            isValid = false;            break;        }    }}

console.log(isValid && stack.isEmpty()); // true

Filas (Queue)

A fila funciona pelo princípio FIFO (First In, First Out). É usada para gerenciar tarefas, processar requisições em servidores web com Node.js ou implementar buffers.

class Queue {    constructor() {        this.items = {};        this.front = 0;        this.rear = 0;    }

    enqueue(element) {        this.items[this.rear] = element;        this.rear++;    }

    dequeue() {        if (this.isEmpty()) return null;        const item = this.items[this.front];        delete this.items[this.front];        this.front++;        return item;    }

    isEmpty() {        return this.front === this.rear;    }

    size() {        return this.rear - this.front;    }}

// Exemplo: processamento de tarefasconst taskQueue = new Queue();taskQueue.enqueue('Tarefa 1');taskQueue.enqueue('Tarefa 2');console.log(taskQueue.dequeue()); // Tarefa 1