"A escolha da estrutura de dados frequentemente importa mais do que a escolha do algoritmo." — Donald Knuth
A estrutura certa torna operações comuns O(1); a errada transforma tarefas simples em O(n) dolorosos.
const counts = new Map();counts.set('the', (counts.get('the') || 0) + 1); const unique = [...new Set([1, 2, 2, 3])];Neste guia da série 33 Conceitos JS — projeto open source criado por Leonardo Maldonado — você domina as 6 built-ins do JS e implementa Stack, Queue, Linked List, BST e Graph do zero.
Pré-requisitos: Map, Reduce & Filter, Recursion e Modern JS Syntax (Map/Set).
// metadados do artigo
{
"tag": "advanced topics",
"readTime": "24 min",
"author": "Vanderlei José Alamino",
"source": "33jsconcepts.com",
"series": "33 Conceitos JS",
"part": {
"current": 35,
"total": 38
}
}Fonte de referência
Conteúdo adaptado a partir do guia original em inglês.
seção
Stack → pilha de livros (LIFO)Array → prateleira ordenada (índice O(1), insert meio O(n))Map → catálogo indexado (lookup O(1))Set → autores únicos (sem duplicatas)Cada estrutura otimiza operações diferentes — escolha pela operação mais frequente.
seção
| Operação | Método | Big O |
|---|---|---|
| Acesso índice | arr[i] | O(1) |
| Fim add/remove | push, pop | O(1) |
| Início add/remove | unshift, shift | O(n) |
| Busca | indexOf, includes | O(n) |
| Meio insert | splice | O(n) |
Use quando: dados ordenados, acesso por posição, push/pop no fim, iteração sequencial.
seção
Pares chave-valor — chaves string/Symbol, O(1) acesso típico.
const user = { name: 'Alice', age: 30 };user.role = 'admin';'name' in user; // trueIdeal para entidades, config JSON, chaves conhecidas. Limitações: chaves viram string, protótipo, sem .size.
seção
Map — chaves de qualquer tipo, ordem de inserção, .size:
const cache = new Map();cache.set(userObj, { lastLogin: Date.now() });for (const [key, val] of cache) { ... }Set — valores únicos, O(1) has/add/delete:
const unique = [...new Set([1, 2, 2, 3])]; // [1, 2, 3]| Object | Map | |
|---|---|---|
| Chaves | string/Symbol | any |
| Size | manual | .size |
| Iteração | keys helper | direto |
WeakMap/WeakSet — chaves/valores fracos (GC-friendly), não iteráveis — cache privado, dados por instância.
seção
Último a entrar, primeiro a sair — undo/redo, call stack, parênteses válidos.
class Stack { constructor() { this.items = []; } push(item) { this.items.push(item); } pop() { return this.items.pop(); } peek() { return this.items.at(-1); } isEmpty() { return this.items.length === 0; }}Todas as operações O(1) com array backing.
seção
Primeiro a entrar, primeiro a sair — filas, BFS, schedulers.
class Queue { enqueue(item) { this.items.push(item); } dequeue() { return this.items.shift(); } // O(n) com array!}Nota: shift() é O(n). Para performance crítica, use linked list ou ponteiros head/tail.
seção
Nós encadeados por referência — insert/delete no início O(1), acesso por índice O(n).
class Node { constructor(value) { this.value = value; this.next = null; }} class LinkedList { prepend(value) { const node = new Node(value); node.next = this.head; this.head = node; }}| Operação | Array | Linked List |
|---|---|---|
| Índice | O(1) | O(n) |
| Insert início | O(n) | O(1) |
| Insert fim | O(1) | O(1) com tail |
Use para queues O(1), modificações frequentes no início, sem acesso aleatório.
seção
Esquerda < pai < direita — busca/inserção O(log n) média, O(n) pior (desbalanceada).
class BinarySearchTree { insert(value) { /* desce esquerda/direita */ } search(value) { /* compara e desce */ } inOrder(node = this.root, result = []) { if (node) { this.inOrder(node.left, result); result.push(node.value); this.inOrder(node.right, result); } return result; }}Dados ordenados inseridos sequencialmente → lista ligada. Árvores balanceadas (AVL, Red-Black) corrigem isso.
seção
Vértices + arestas — redes sociais, mapas, dependências.
class Graph { constructor() { this.adjacencyList = new Map(); } addVertex(v) { this.adjacencyList.set(v, []); } addEdge(v1, v2) { this.adjacencyList.get(v1).push(v2); this.adjacencyList.get(v2).push(v1); }}BFS usa Queue (nível a nível). DFS usa Stack/recursão (profundidade primeiro). Veja Recursion.
seção
| Caso de uso | Estrutura |
|---|---|
| Ordenado + índice | Array |
| Config JSON | Object |
| Chave any / freq count | Map |
| Valores únicos | Set |
| LIFO | Stack |
| FIFO | Queue |
| Insert início rápido | Linked List |
| Busca ordenada | BST |
| Relações/conexões | Graph |
seção
Two Sum — Map O(n):
function twoSum(nums, target) { const seen = new Map(); for (let i = 0; i < nums.length; i++) { const comp = target - nums[i]; if (seen.has(comp)) return [seen.get(comp), i]; seen.set(nums[i], i); } return [];}Valid Parentheses — Stack:
function isValid(s) { const stack = [], pairs = { ')': '(', ']': '[', '}': '{' }; for (const c of s) { if (c in pairs) { if (stack.pop() !== pairs[c]) return false; } else stack.push(c); } return stack.length === 0;}Reverse Linked List — 3 ponteiros: prev, current, next.
Cycle Detection — Floyd (slow/fast): dois ponteiros, 1 vs 2 passos.
Max Depth Tree — recursão: 1 + max(left, right).
seção
seção
seção
Você avançou na trilha Advanced Topics — sexto de nove conceitos avançados.
Combine estruturas com Higher-Order Functions e Recursion para algoritmos completos.
→ Algorithms & Big O — a ciência da performance
Fonte de referência: 33jsconcepts.com/concepts/data-structures ⬀
.size, freq counting[...new Set(arr)] dedupe