Algoritmos e Estruturas de Dados em JavaScript: guia completo

Algoritmos e Estruturas de Dados em JavaScript (Node.js): do iniciante ao profissional

Todo desenvolvedor JavaScript, mais cedo ou mais tarde, enfrenta a necessidade de um entendimento profundo de algoritmos e estruturas de dados. Independentemente de você escrever frontend em React ou backend em Node.js, saber como organizar e processar dados de forma eficiente é uma habilidade fundamental. Neste artigo, vamos abordar as estruturas de dados básicas e algoritmos populares com exemplos práticos em JavaScript para o ambiente Node.js.

Por que estudar algoritmos e estruturas de dados?

Algoritmos e estruturas de dados são a base sobre a qual qualquer aplicação é construída. A escolha correta da estrutura de dados pode acelerar a execução do programa dezenas de vezes. Por exemplo, buscar um elemento em um array de 10.000 elementos pode levar até 10.000 operações, enquanto em uma hash table leva apenas uma operação. Entender esses princípios ajuda a:

• Escrever código mais performático
• Utilizar memória de forma eficiente
• Passar em entrevistas técnicas
• Entender o funcionamento interno de bibliotecas e frameworks populares

Principais estruturas de dados em JavaScript

Arrays

Arrays são a estrutura de dados mais comum em JavaScript. Eles armazenam elementos em ordem sequencial e fornecem acesso por índice em O(1). No Node.js, arrays são especialmente úteis para trabalhar com streams de dados.

// Exemplo de trabalho com arrays em Node.jsconst numbers = [5, 2, 9, 1, 5, 6];

// Adicionar elemento ao finalnumbers.push(10);  // [5, 2, 9, 1, 5, 6, 10]

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

// Buscar elementoconst index = numbers.findIndex(num => num === 9);  // 2

// Filtrarconst filtered = numbers.filter(num => num > 5);  // [9, 6]

console.log(`Resultado da filtragem: ${filtered}`);

Stack

O Stack funciona pelo princípio LIFO (Last In, First Out). É a estrutura ideal para tarefas que precisam de acesso ao último elemento adicionado: histórico de ações (undo/redo), verificação de parênteses, travessia de grafos.

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

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

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

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

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

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

// Exemplo: verificar parênteses válidosfunction isValidParentheses(str) {  const stack = new Stack();  const pairs = { '(': ')', '{': '}', '[': ']' };

  for (let char of str) {    if (pairs[char]) {      stack.push(char);    } else {      const last = stack.pop();      if (pairs[last] !== char) return false;    }  }

  return stack.isEmpty();}

console.log(isValidParentheses("({[]})"));  // trueconsole.log(isValidParentheses("({[})"));   // false

Queue

A Queue funciona pelo princípio FIFO (First In, First Out). É indispensável para processar tarefas na ordem de chegada: agendadores de tarefas, filas de mensagens, BFS (busca em largura).

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: simulação de fila de impressãoconst printQueue = new Queue();printQueue.enqueue("document1.pdf");printQueue.enqueue("document2.pdf");printQueue.enqueue("photo.jpg");

while (!printQueue.isEmpty()) {