trekhleb · isaacvrb · Jun 24, 2024
diff --git a/README.pt-BR.md b/README.pt-BR.md
@@ -1,5 +1,7 @@
 # Estrutura de Dados e Algoritmos em JavaScript
 
+## Teste
+
 [![CI](https://github.com/trekhleb/javascript-algorithms/workflows/CI/badge.svg)](https://github.com/trekhleb/javascript-algorithms/actions?query=workflow%3ACI+branch%3Amaster)
 [![codecov](https://codecov.io/gh/trekhleb/javascript-algorithms/branch/master/graph/badge.svg)](https://codecov.io/gh/trekhleb/javascript-algorithms)
 
@@ -35,23 +37,23 @@ ser acessado e modificado de forma eficiente. Mais precisamente, uma estrutura d
 
 `B` - Iniciante, `A` - Avançado
 
-* `B` [Lista Encadeada (Linked List)](src/data-structures/linked-list/README.pt-BR.md)
-* `B` [Lista Duplamente Ligada (Doubly Linked List)](src/data-structures/doubly-linked-list/README.pt-BR.md)
-* `B` [Fila (Queue)](src/data-structures/queue/README.pt-BR.md)
-* `B` [Pilha (Stack)](src/data-structures/stack/README.pt-BR.md)
-* `B` [Tabela de Hash (Hash Table)](src/data-structures/hash-table/README.pt-BR.md)
-* `B` [Heap](src/data-structures/heap/README.pt-BR.md) - versões de heap máximo e mínimo
-* `B` [Fila de Prioridade (Priority Queue)](src/data-structures/priority-queue/README.pt-BR.md)
-* `A` [Árvore de Prefixos (Trie)](src/data-structures/trie/README.pt-BR.md)
-* `A` [Árvore (Tree)](src/data-structures/tree/README.pt-BR.md)
-  * `A` [Árvore de Pesquisa Binária (Binary Search Tree)](src/data-structures/tree/binary-search-tree/README.pt-BR.md)
-  * `A` [Árvore AVL (AVL Tree)](src/data-structures/tree/avl-tree/README.pt-BR.md)
-  * `A` [Árvore Rubro-Negra (Red-Black Tree)](src/data-structures/tree/red-black-tree/README.pt-BR.md)
-  * `A` [Árvore de Segmento (Segment Tree)](src/data-structures/tree/segment-tree/README.pt-BR.md) - com exemplos de consultas min / max / sum range
-  * `A` [Árvore Fenwick (Fenwick Tree)](src/data-structures/tree/fenwick-tree/README.pt-BR.md) (Árvore indexada binária)
-* `A` [Grafo (Graph)](src/data-structures/graph/README.pt-BR.md) (ambos dirigidos e não direcionados)
-* `A` [Conjunto Disjunto (Disjoint Set)](src/data-structures/disjoint-set/README.pt-BR.md)
-* `A` [Filtro Bloom (Bloom Filter)](src/data-structures/bloom-filter/README.pt-BR.md)
+- `B` [Lista Encadeada (Linked List)](src/data-structures/linked-list/README.pt-BR.md)
+- `B` [Lista Duplamente Ligada (Doubly Linked List)](src/data-structures/doubly-linked-list/README.pt-BR.md)
+- `B` [Fila (Queue)](src/data-structures/queue/README.pt-BR.md)
+- `B` [Pilha (Stack)](src/data-structures/stack/README.pt-BR.md)
+- `B` [Tabela de Hash (Hash Table)](src/data-structures/hash-table/README.pt-BR.md)
+- `B` [Heap](src/data-structures/heap/README.pt-BR.md) - versões de heap máximo e mínimo
+- `B` [Fila de Prioridade (Priority Queue)](src/data-structures/priority-queue/README.pt-BR.md)
+- `A` [Árvore de Prefixos (Trie)](src/data-structures/trie/README.pt-BR.md)
+- `A` [Árvore (Tree)](src/data-structures/tree/README.pt-BR.md)
+  - `A` [Árvore de Pesquisa Binária (Binary Search Tree)](src/data-structures/tree/binary-search-tree/README.pt-BR.md)
+  - `A` [Árvore AVL (AVL Tree)](src/data-structures/tree/avl-tree/README.pt-BR.md)
+  - `A` [Árvore Rubro-Negra (Red-Black Tree)](src/data-structures/tree/red-black-tree/README.pt-BR.md)
+  - `A` [Árvore de Segmento (Segment Tree)](src/data-structures/tree/segment-tree/README.pt-BR.md) - com exemplos de consultas min / max / sum range
+  - `A` [Árvore Fenwick (Fenwick Tree)](src/data-structures/tree/fenwick-tree/README.pt-BR.md) (Árvore indexada binária)
+- `A` [Grafo (Graph)](src/data-structures/graph/README.pt-BR.md) (ambos dirigidos e não direcionados)
+- `A` [Conjunto Disjunto (Disjoint Set)](src/data-structures/disjoint-set/README.pt-BR.md)
+- `A` [Filtro Bloom (Bloom Filter)](src/data-structures/bloom-filter/README.pt-BR.md)
 
 ## Algoritmos
 
@@ -62,145 +64,146 @@ um conjunto de regras que define precisamente uma sequência de operações.
 
 ### Algoritmos por Tópico
 
-* **Matemática**
-  * `B` [Manipulação Bit](src/algorithms/math/bits) - set/get/update/clear bits, multiplicação / divisão por dois, tornar negativo etc.
-  * `B` [Fatorial](src/algorithms/math/factorial)
-  * `B` [Número de Fibonacci](src/algorithms/math/fibonacci)
-  * `B` [Teste de Primalidade](src/algorithms/math/primality-test) (método de divisão experimental)
-  * `B` [Algoritmo Euclidiano](src/algorithms/math/euclidean-algorithm) - Calcular o Máximo Divisor Comum (MDC)
-  * `B` [Mínimo Múltiplo Comum](src/algorithms/math/least-common-multiple) Calcular o Mínimo Múltiplo Comum (MMC)
-  * `B` [Peneira de Eratóstenes](src/algorithms/math/sieve-of-eratosthenes) - Encontrar todos os números primos até um determinado limite
-  * `B` [Potência de Dois](src/algorithms/math/is-power-of-two) - Verifique se o número é a potência de dois (algoritmos ingênuos e bit a bit)
-  * `B` [Triângulo de Pascal](src/algorithms/math/pascal-triangle)
-  * `B` [Número Complexo](src/algorithms/math/complex-number) - Números complexos e operações básicas com eles
-  * `A` [Partição Inteira](src/algorithms/math/integer-partition)
-  * `A` [Algoritmo Liu Hui π](src/algorithms/math/liu-hui) - Cálculos aproximados de π baseados em N-gons
-* **Conjuntos**
-  * `B` [Produto Cartesiano](src/algorithms/sets/cartesian-product) - Produto de vários conjuntos
-  * `B` [Permutações de Fisher–Yates](src/algorithms/sets/fisher-yates) - Permutação aleatória de uma sequência finita
-  * `A` [Potência e Conjunto](src/algorithms/sets/power-set) - Todos os subconjuntos de um conjunto
-  * `A` [Permutações](src/algorithms/sets/permutations) (com e sem repetições)
-  * `A` [Combinações](src/algorithms/sets/combinations) (com e sem repetições)
-  * `A` [Mais Longa Subsequência Comum](src/algorithms/sets/longest-common-subsequence) (LCS)
-  * `A` [Maior Subsequência Crescente](src/algorithms/sets/longest-increasing-subsequence)
-  * `A` [Supersequência Comum Mais Curta](src/algorithms/sets/shortest-common-supersequence) (SCS)
-  * `A` [Problema da Mochila](src/algorithms/sets/knapsack-problem) - "0/1" e "Não consolidado"
-  * `A` [Subarray Máximo](src/algorithms/sets/maximum-subarray) - "Força bruta" e "Programação Dinâmica", versões de Kadane
-  * `A` [Soma de Combinação](src/algorithms/sets/combination-sum) - Encontre todas as combinações que formam uma soma específica
-* **Cadeia de Caracteres**
-  * `B` [Distância de Hamming](src/algorithms/string/hamming-distance) - Número de posições em que os símbolos são diferentes
-  * `B` [Palíndromos](src/algorithms/string/palindrome) - Verifique se a cadeia de caracteres (string) é a mesma ao contrário
-  * `A` [Distância Levenshtein](src/algorithms/string/levenshtein-distance) - Distância mínima de edição entre duas sequências
-  * `A` [Algoritmo Knuth–Morris–Pratt](src/algorithms/string/knuth-morris-pratt) (Algoritmo KMP) - Pesquisa de substring (correspondência de padrão)
-  * `A` [Z Algorithm](src/algorithms/string/z-algorithm) - Pesquisa de substring (correspondência de padrão)
-  * `A` [Algoritmo de Rabin Karp](src/algorithms/string/rabin-karp) - Pesquisa de substring
-  * `A` [Substring Comum Mais Longa](src/algorithms/string/longest-common-substring)
-  * `A` [Expressões Regulares Correspondentes](src/algorithms/string/regular-expression-matching)
-* **Buscas**
-  * `B` [Busca Linear (Linear Search)](src/algorithms/search/linear-search)
-  * `B` [Busca por Saltos (Jump Search)](src/algorithms/search/jump-search) - Pesquisa em matriz ordenada
-  * `B` [Busca Binária (Binary Search)](src/algorithms/search/binary-search) - Pesquisa em matriz ordenada
-  * `B` [Busca por Interpolação (Interpolation Search)](src/algorithms/search/interpolation-search) - Pesquisa em matriz classificada uniformemente distribuída
-* **Classificação**
-  * `B` [Bubble Sort](src/algorithms/sorting/bubble-sort)
-  * `B` [Selection Sort](src/algorithms/sorting/selection-sort)
-  * `B` [Insertion Sort](src/algorithms/sorting/insertion-sort)
-  * `B` [Heap Sort](src/algorithms/sorting/heap-sort)
-  * `B` [Merge Sort](src/algorithms/sorting/merge-sort)
-  * `B` [Quicksort](src/algorithms/sorting/quick-sort) - Implementações local e não local
-  * `B` [Shellsort](src/algorithms/sorting/shell-sort)
-  * `B` [Counting Sort](src/algorithms/sorting/counting-sort)
-  * `B` [Radix Sort](src/algorithms/sorting/radix-sort)
-* **Árvores**
-  * `B` [Busca em Profundidade (Depth-First Search)](src/algorithms/tree/depth-first-search) (DFS)
-  * `B` [Busca em Largura (Breadth-First Search)](src/algorithms/tree/breadth-first-search) (BFS)
-* **Grafos**
-  * `B` [Busca em Profundidade (Depth-First Search)](src/algorithms/graph/depth-first-search) (DFS)
-  * `B` [Busca em Largura (Breadth-First Search)](src/algorithms/graph/breadth-first-search) (BFS)
-  * `B` [Algoritmo de Kruskal](src/algorithms/graph/kruskal) - Encontrando Árvore Mínima de Abrangência (MST) para grafo conexo com pesos
-  * `A` [Algoritmo de Dijkstra](src/algorithms/graph/dijkstra) - Encontrar caminhos mais curtos para todos os vértices do grafo a partir de um único vértice
-  * `A` [Algoritmo de Bellman-Ford](src/algorithms/graph/bellman-ford) - Encontrar caminhos mais curtos para todos os vértices do grafo a partir de um único vértice
-  * `A` [Algoritmo de Floyd-Warshall](src/algorithms/graph/floyd-warshall) - Encontrar caminhos mais curtos entre todos os pares de vértices
-  * `A` [Detectar Ciclo](src/algorithms/graph/detect-cycle) - Para grafos direcionados e não direcionados (versões baseadas em DFS e Conjunto Disjuntivo)
-  * `A` [Algoritmo de Prim](src/algorithms/graph/prim) - Encontrando Árvore Mínima de Abrangência (MST) para grafo não direcionado ponderado
-  * `A` [Ordenação Topológica](src/algorithms/graph/topological-sorting) - Métodos DFS
-  * `A` [Pontos de Articulação](src/algorithms/graph/articulation-points) - O algoritmo de Tarjan (baseado em DFS)
-  * `A` [Pontes](src/algorithms/graph/bridges) - Algoritmo baseado em DFS
-  * `A` [Caminho e Circuito Euleriano](src/algorithms/graph/eulerian-path) - Algoritmo de Fleury - Visite todas as bordas exatamente uma vez
-  * `A` [Ciclo Hamiltoniano](src/algorithms/graph/hamiltonian-cycle) - Visite todas as bordas exatamente uma vez
-  * `A` [Componentes Fortemente Conectados](src/algorithms/graph/strongly-connected-components) - Algoritmo de Kosaraju
-  * `A` [Problema do Caixeiro Viajante](src/algorithms/graph/travelling-salesman) - Rota mais curta possível que visita cada cidade e retorna à cidade de origem
-* **Criptografia**
-  * `B` [Hash Polinomial](src/algorithms/cryptography/polynomial-hash) - Função de hash de rolagem baseada em polinômio
-* **Sem categoria**
-  * `B` [Torre de Hanoi](src/algorithms/uncategorized/hanoi-tower)
-  * `B` [Rotação de Matriz Quadrada](src/algorithms/uncategorized/square-matrix-rotation) - Algoritmo no local
-  * `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game) - Backtracking, programação dinâmica (top-down + bottom-up) e exemplos gananciosos
-  * `B` [Caminhos Únicos](src/algorithms/uncategorized/unique-paths) - Backtracking, programação dinâmica e exemplos baseados no triângulo de Pascal
-  * `B` [Terraços de Chuva](src/algorithms/uncategorized/rain-terraces) - Problema de retenção da água da chuva (programação dinâmica e versões de força bruta)
-  * `A` [Problema das N-Rainhas](src/algorithms/uncategorized/n-queens)
-  * `A` [Passeio do Cavaleiro](src/algorithms/uncategorized/knight-tour)
+- **Matemática**
+  - `B` [Manipulação Bit](src/algorithms/math/bits) - set/get/update/clear bits, multiplicação / divisão por dois, tornar negativo etc.
+  - `B` [Fatorial](src/algorithms/math/factorial)
+  - `B` [Número de Fibonacci](src/algorithms/math/fibonacci)
+  - `B` [Teste de Primalidade](src/algorithms/math/primality-test) (método de divisão experimental)
+  - `B` [Algoritmo Euclidiano](src/algorithms/math/euclidean-algorithm) - Calcular o Máximo Divisor Comum (MDC)
+  - `B` [Mínimo Múltiplo Comum](src/algorithms/math/least-common-multiple) Calcular o Mínimo Múltiplo Comum (MMC)
+  - `B` [Peneira de Eratóstenes](src/algorithms/math/sieve-of-eratosthenes) - Encontrar todos os números primos até um determinado limite
+  - `B` [Potência de Dois](src/algorithms/math/is-power-of-two) - Verifique se o número é a potência de dois (algoritmos ingênuos e bit a bit)
+  - `B` [Triângulo de Pascal](src/algorithms/math/pascal-triangle)
+  - `B` [Número Complexo](src/algorithms/math/complex-number) - Números complexos e operações básicas com eles
+  - `A` [Partição Inteira](src/algorithms/math/integer-partition)
+  - `A` [Algoritmo Liu Hui π](src/algorithms/math/liu-hui) - Cálculos aproximados de π baseados em N-gons
+- **Conjuntos**
+  - `B` [Produto Cartesiano](src/algorithms/sets/cartesian-product) - Produto de vários conjuntos
+  - `B` [Permutações de Fisher–Yates](src/algorithms/sets/fisher-yates) - Permutação aleatória de uma sequência finita
+  - `A` [Potência e Conjunto](src/algorithms/sets/power-set) - Todos os subconjuntos de um conjunto
+  - `A` [Permutações](src/algorithms/sets/permutations) (com e sem repetições)
+  - `A` [Combinações](src/algorithms/sets/combinations) (com e sem repetições)
+  - `A` [Mais Longa Subsequência Comum](src/algorithms/sets/longest-common-subsequence) (LCS)
+  - `A` [Maior Subsequência Crescente](src/algorithms/sets/longest-increasing-subsequence)
+  - `A` [Supersequência Comum Mais Curta](src/algorithms/sets/shortest-common-supersequence) (SCS)
+  - `A` [Problema da Mochila](src/algorithms/sets/knapsack-problem) - "0/1" e "Não consolidado"
+  - `A` [Subarray Máximo](src/algorithms/sets/maximum-subarray) - "Força bruta" e "Programação Dinâmica", versões de Kadane
+  - `A` [Soma de Combinação](src/algorithms/sets/combination-sum) - Encontre todas as combinações que formam uma soma específica
+- **Cadeia de Caracteres**
+  - `B` [Distância de Hamming](src/algorithms/string/hamming-distance) - Número de posições em que os símbolos são diferentes
+  - `B` [Palíndromos](src/algorithms/string/palindrome) - Verifique se a cadeia de caracteres (string) é a mesma ao contrário
+  - `A` [Distância Levenshtein](src/algorithms/string/levenshtein-distance) - Distância mínima de edição entre duas sequências
+  - `A` [Algoritmo Knuth–Morris–Pratt](src/algorithms/string/knuth-morris-pratt) (Algoritmo KMP) - Pesquisa de substring (correspondência de padrão)
+  - `A` [Z Algorithm](src/algorithms/string/z-algorithm) - Pesquisa de substring (correspondência de padrão)
+  - `A` [Algoritmo de Rabin Karp](src/algorithms/string/rabin-karp) - Pesquisa de substring
+  - `A` [Substring Comum Mais Longa](src/algorithms/string/longest-common-substring)
+  - `A` [Expressões Regulares Correspondentes](src/algorithms/string/regular-expression-matching)
+- **Buscas**
+  - `B` [Busca Linear (Linear Search)](src/algorithms/search/linear-search)
+  - `B` [Busca por Saltos (Jump Search)](src/algorithms/search/jump-search) - Pesquisa em matriz ordenada
+  - `B` [Busca Binária (Binary Search)](src/algorithms/search/binary-search) - Pesquisa em matriz ordenada
+  - `B` [Busca por Interpolação (Interpolation Search)](src/algorithms/search/interpolation-search) - Pesquisa em matriz classificada uniformemente distribuída
+- **Classificação**
+  - `B` [Bubble Sort](src/algorithms/sorting/bubble-sort)
+  - `B` [Selection Sort](src/algorithms/sorting/selection-sort)
+  - `B` [Insertion Sort](src/algorithms/sorting/insertion-sort)
+  - `B` [Heap Sort](src/algorithms/sorting/heap-sort)
+  - `B` [Merge Sort](src/algorithms/sorting/merge-sort)
+  - `B` [Quicksort](src/algorithms/sorting/quick-sort) - Implementações local e não local
+  - `B` [Shellsort](src/algorithms/sorting/shell-sort)
+  - `B` [Counting Sort](src/algorithms/sorting/counting-sort)
+  - `B` [Radix Sort](src/algorithms/sorting/radix-sort)
+- **Árvores**
+  - `B` [Busca em Profundidade (Depth-First Search)](src/algorithms/tree/depth-first-search) (DFS)
+  - `B` [Busca em Largura (Breadth-First Search)](src/algorithms/tree/breadth-first-search) (BFS)
+- **Grafos**
+  - `B` [Busca em Profundidade (Depth-First Search)](src/algorithms/graph/depth-first-search) (DFS)
+  - `B` [Busca em Largura (Breadth-First Search)](src/algorithms/graph/breadth-first-search) (BFS)
+  - `B` [Algoritmo de Kruskal](src/algorithms/graph/kruskal) - Encontrando Árvore Mínima de Abrangência (MST) para grafo conexo com pesos
+  - `A` [Algoritmo de Dijkstra](src/algorithms/graph/dijkstra) - Encontrar caminhos mais curtos para todos os vértices do grafo a partir de um único vértice
+  - `A` [Algoritmo de Bellman-Ford](src/algorithms/graph/bellman-ford) - Encontrar caminhos mais curtos para todos os vértices do grafo a partir de um único vértice
+  - `A` [Algoritmo de Floyd-Warshall](src/algorithms/graph/floyd-warshall) - Encontrar caminhos mais curtos entre todos os pares de vértices
+  - `A` [Detectar Ciclo](src/algorithms/graph/detect-cycle) - Para grafos direcionados e não direcionados (versões baseadas em DFS e Conjunto Disjuntivo)
+  - `A` [Algoritmo de Prim](src/algorithms/graph/prim) - Encontrando Árvore Mínima de Abrangência (MST) para grafo não direcionado ponderado
+  - `A` [Ordenação Topológica](src/algorithms/graph/topological-sorting) - Métodos DFS
+  - `A` [Pontos de Articulação](src/algorithms/graph/articulation-points) - O algoritmo de Tarjan (baseado em DFS)
+  - `A` [Pontes](src/algorithms/graph/bridges) - Algoritmo baseado em DFS
+  - `A` [Caminho e Circuito Euleriano](src/algorithms/graph/eulerian-path) - Algoritmo de Fleury - Visite todas as bordas exatamente uma vez
+  - `A` [Ciclo Hamiltoniano](src/algorithms/graph/hamiltonian-cycle) - Visite todas as bordas exatamente uma vez
+  - `A` [Componentes Fortemente Conectados](src/algorithms/graph/strongly-connected-components) - Algoritmo de Kosaraju
+  - `A` [Problema do Caixeiro Viajante](src/algorithms/graph/travelling-salesman) - Rota mais curta possível que visita cada cidade e retorna à cidade de origem
+- **Criptografia**
+  - `B` [Hash Polinomial](src/algorithms/cryptography/polynomial-hash) - Função de hash de rolagem baseada em polinômio
+- **Sem categoria**
+  - `B` [Torre de Hanoi](src/algorithms/uncategorized/hanoi-tower)
+  - `B` [Rotação de Matriz Quadrada](src/algorithms/uncategorized/square-matrix-rotation) - Algoritmo no local
+  - `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game) - Backtracking, programação dinâmica (top-down + bottom-up) e exemplos gananciosos
+  - `B` [Caminhos Únicos](src/algorithms/uncategorized/unique-paths) - Backtracking, programação dinâmica e exemplos baseados no triângulo de Pascal
+  - `B` [Terraços de Chuva](src/algorithms/uncategorized/rain-terraces) - Problema de retenção da água da chuva (programação dinâmica e versões de força bruta)
+  - `A` [Problema das N-Rainhas](src/algorithms/uncategorized/n-queens)
+  - `A` [Passeio do Cavaleiro](src/algorithms/uncategorized/knight-tour)
 
 ### Algoritmos por Paradigma
 
 Um paradigma algorítmico é um método ou abordagem genérica subjacente ao design de uma classe
 de algoritmos. É uma abstração maior do que a noção de um algoritmo, assim como
 algoritmo é uma abstração maior que um programa de computador.
 
-* **Força bruta** - Pense em todas as possibilidades e escolha a melhor solução
-  * `B` [Busca Linear (Linear Search)](src/algorithms/search/linear-search)
-  * `B` [Terraços de Chuva](src/algorithms/uncategorized/rain-terraces) - Problema de retenção de água da chuva (programação dinâmica e versões de força bruta)
-  * `A` [Subarray Máximo](src/algorithms/sets/maximum-subarray)
-  * `A` [Problema do Caixeiro Viajante](src/algorithms/graph/travelling-salesman) - Rota mais curta possível que visita cada cidade e retorna à cidade de origem
-* **Ganância** - Escolha a melhor opção no momento, sem qualquer consideração pelo futuro
-  * `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game)
-  * `A` [Problema da Mochila](src/algorithms/sets/knapsack-problem)
-  * `A` [Algoritmo de Dijkstra](src/algorithms/graph/dijkstra) - Encontrar caminhos mais curtos para todos os vértices do grafo a partir de um único vértice
-  * `A` [Algoritmo de Prim](src/algorithms/graph/prim) - Encontrando Árvore Mínima de Abrangência (MST) para grafo não direcionado ponderado
-  * `A` [Algoritmo de Kruskal](src/algorithms/graph/kruskal) - Encontrando Árvore Mínima de Abrangência (MST) para grafo conexo com pesos
-* **Dividir e Conquistar** - Dividir o problema em partes menores e então resolver essas partes
-  * `B` [Busca Binária (Binary Search)](src/algorithms/search/binary-search)
-  * `B` [Torre de Hanoi](src/algorithms/uncategorized/hanoi-tower)
-  * `B` [Triângulo de Pascal](src/algorithms/math/pascal-triangle)
-  * `B` [Algoritmo Euclidiano](src/algorithms/math/euclidean-algorithm) - Calcular o Máximo Divisor Comum (MDC)
-  * `B` [Merge Sort](src/algorithms/sorting/merge-sort)
-  * `B` [Quicksort](src/algorithms/sorting/quick-sort)
-  * `B` [Busca em Profundidade (Depth-First Search)](src/algorithms/tree/depth-first-search) (DFS)
-  * `B` [Busca em Largura (Breadth-First Search)](src/algorithms/graph/breadth-first-search) (BFS)
-  * `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game)
-  * `A` [Permutações](src/algorithms/sets/permutations) (com e sem repetições)
-  * `A` [Combinações](src/algorithms/sets/combinations) (com e sem repetições)
-* **Programação Dinâmica** - Criar uma solução usando sub-soluções encontradas anteriormente
-  * `B` [Número de Fibonacci](src/algorithms/math/fibonacci)
-  * `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game)
-  * `B` [Caminhos Únicos](src/algorithms/uncategorized/unique-paths)
-  * `B` [Terraços de Chuva](src/algorithms/uncategorized/rain-terraces) - Trapping problema da água da chuva
-  * `A` [Distância Levenshtein](src/algorithms/string/levenshtein-distance) - Distância mínima de edição entre duas sequências
-  * `A` [Mais Longa Subsequência Comum](src/algorithms/sets/longest-common-subsequence) (LCS)
-  * `A` [Substring Comum Mais Longa](src/algorithms/string/longest-common-substring)
-  * `A` [Maior Subsequência Crescente](src/algorithms/sets/longest-increasing-subsequence)
-  * `A` [Supersequência Comum Mais Curta](src/algorithms/sets/shortest-common-supersequence)
-  * `A` [Problema da Mochila](src/algorithms/sets/knapsack-problem)
-  * `A` [Partição Inteira](src/algorithms/math/integer-partition)
-  * `A` [Subarray Máximo](src/algorithms/sets/maximum-subarray)
-  * `A` [Algoritmo de Bellman-Ford](src/algorithms/graph/bellman-ford) - Encontrar caminhos mais curtos para todos os vértices do grafo a partir de um único vértice
-  * `A` [Algoritmo de Floyd-Warshall](src/algorithms/graph/floyd-warshall) - Encontrar caminhos mais curtos entre todos os pares de vértices
-  * `A` [Expressões Regulares Correspondentes](src/algorithms/string/regular-expression-matching)
-* **Backtracking** - Da mesma forma que a força bruta, tente gerar todas as soluções possíveis, mas, cada vez que você gerar a próxima solução será necessário testar se a mesma satisfaz todas as condições, e só então continuará a gerar as soluções subsequentes. Caso contrário, volte atrás e siga um caminho diferente para encontrar uma solução. Normalmente, a passagem DFS do espaço de estados está sendo usada.
-  * `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game)
-  * `B` [Caminhos Únicos](src/algorithms/uncategorized/unique-paths)
-  * `A` [Ciclo Hamiltoniano](src/algorithms/graph/hamiltonian-cycle) - Visite todos os vértices exatamente uma vez
-  * `A` [Problema das N-Rainhas](src/algorithms/uncategorized/n-queens)
-  * `A` [Passeio do Cavaleiro](src/algorithms/uncategorized/knight-tour)
-  * `A` [Soma de Combinação](src/algorithms/sets/combination-sum) - Encontre todas as combinações que formam uma soma específica
-* **Branch & Bound** - Lembre-se da solução de menor custo encontrada em cada etapa do retrocesso, pesquisar e usar o custo da solução de menor custo encontrada até o limite inferior do custo de
-solução de menor custo para o problema, a fim de descartar soluções parciais com custos maiores que o
-solução de menor custo encontrada até o momento. Normalmente, a travessia BFS em combinação com a passagem DFS do espaço de estados
-árvore está sendo usada
+- **Força bruta** - Pense em todas as possibilidades e escolha a melhor solução
+  - `B` [Busca Linear (Linear Search)](src/algorithms/search/linear-search)
+  - `B` [Terraços de Chuva](src/algorithms/uncategorized/rain-terraces) - Problema de retenção de água da chuva (programação dinâmica e versões de força bruta)
+  - `A` [Subarray Máximo](src/algorithms/sets/maximum-subarray)
+  - `A` [Problema do Caixeiro Viajante](src/algorithms/graph/travelling-salesman) - Rota mais curta possível que visita cada cidade e retorna à cidade de origem
+- **Ganância** - Escolha a melhor opção no momento, sem qualquer consideração pelo futuro
+  - `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game)
+  - `A` [Problema da Mochila](src/algorithms/sets/knapsack-problem)
+  - `A` [Algoritmo de Dijkstra](src/algorithms/graph/dijkstra) - Encontrar caminhos mais curtos para todos os vértices do grafo a partir de um único vértice
+  - `A` [Algoritmo de Prim](src/algorithms/graph/prim) - Encontrando Árvore Mínima de Abrangência (MST) para grafo não direcionado ponderado
+  - `A` [Algoritmo de Kruskal](src/algorithms/graph/kruskal) - Encontrando Árvore Mínima de Abrangência (MST) para grafo conexo com pesos
+- **Dividir e Conquistar** - Dividir o problema em partes menores e então resolver essas partes
+  - `B` [Busca Binária (Binary Search)](src/algorithms/search/binary-search)
+  - `B` [Torre de Hanoi](src/algorithms/uncategorized/hanoi-tower)
+  - `B` [Triângulo de Pascal](src/algorithms/math/pascal-triangle)
+  - `B` [Algoritmo Euclidiano](src/algorithms/math/euclidean-algorithm) - Calcular o Máximo Divisor Comum (MDC)
+  - `B` [Merge Sort](src/algorithms/sorting/merge-sort)
+  - `B` [Quicksort](src/algorithms/sorting/quick-sort)
+  - `B` [Busca em Profundidade (Depth-First Search)](src/algorithms/tree/depth-first-search) (DFS)
+  - `B` [Busca em Largura (Breadth-First Search)](src/algorithms/graph/breadth-first-search) (BFS)
+  - `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game)
+  - `A` [Permutações](src/algorithms/sets/permutations) (com e sem repetições)
+  - `A` [Combinações](src/algorithms/sets/combinations) (com e sem repetições)
+- **Programação Dinâmica** - Criar uma solução usando sub-soluções encontradas anteriormente
+  - `B` [Número de Fibonacci](src/algorithms/math/fibonacci)
+  - `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game)
+  - `B` [Caminhos Únicos](src/algorithms/uncategorized/unique-paths)
+  - `B` [Terraços de Chuva](src/algorithms/uncategorized/rain-terraces) - Trapping problema da água da chuva
+  - `A` [Distância Levenshtein](src/algorithms/string/levenshtein-distance) - Distância mínima de edição entre duas sequências
+  - `A` [Mais Longa Subsequência Comum](src/algorithms/sets/longest-common-subsequence) (LCS)
+  - `A` [Substring Comum Mais Longa](src/algorithms/string/longest-common-substring)
+  - `A` [Maior Subsequência Crescente](src/algorithms/sets/longest-increasing-subsequence)
+  - `A` [Supersequência Comum Mais Curta](src/algorithms/sets/shortest-common-supersequence)
+  - `A` [Problema da Mochila](src/algorithms/sets/knapsack-problem)
+  - `A` [Partição Inteira](src/algorithms/math/integer-partition)
+  - `A` [Subarray Máximo](src/algorithms/sets/maximum-subarray)
+  - `A` [Algoritmo de Bellman-Ford](src/algorithms/graph/bellman-ford) - Encontrar caminhos mais curtos para todos os vértices do grafo a partir de um único vértice
+  - `A` [Algoritmo de Floyd-Warshall](src/algorithms/graph/floyd-warshall) - Encontrar caminhos mais curtos entre todos os pares de vértices
+  - `A` [Expressões Regulares Correspondentes](src/algorithms/string/regular-expression-matching)
+- **Backtracking** - Da mesma forma que a força bruta, tente gerar todas as soluções possíveis, mas, cada vez que você gerar a próxima solução será necessário testar se a mesma satisfaz todas as condições, e só então continuará a gerar as soluções subsequentes. Caso contrário, volte atrás e siga um caminho diferente para encontrar uma solução. Normalmente, a passagem DFS do espaço de estados está sendo usada.
+  - `B` [Jogo do Salto](src/algorithms/uncategorized/jump-game)
+  - `B` [Caminhos Únicos](src/algorithms/uncategorized/unique-paths)
+  - `A` [Ciclo Hamiltoniano](src/algorithms/graph/hamiltonian-cycle) - Visite todos os vértices exatamente uma vez
+  - `A` [Problema das N-Rainhas](src/algorithms/uncategorized/n-queens)
+  - `A` [Passeio do Cavaleiro](src/algorithms/uncategorized/knight-tour)
+  - `A` [Soma de Combinação](src/algorithms/sets/combination-sum) - Encontre todas as combinações que formam uma soma específica
+- **Branch & Bound** - Lembre-se da solução de menor custo encontrada em cada etapa do retrocesso, pesquisar e usar o custo da solução de menor custo encontrada até o limite inferior do custo de
+  solução de menor custo para o problema, a fim de descartar soluções parciais com custos maiores que o
+  solução de menor custo encontrada até o momento. Normalmente, a travessia BFS em combinação com a passagem DFS do espaço de estados
+  árvore está sendo usada
 
 ## Como usar este repositório
 
 **Instalar todas as dependências**
+
 ```
 npm install
 ```
@@ -214,17 +217,21 @@ npm run lint
 ```
 
 **Execute todos os testes**
+
 ```
 npm test
 ```
 
 **Executar testes por nome**
+
 ```
 npm test -- 'LinkedList'
 ```
+
 **Solução de problemas**
 
 Caso o linting ou o teste estejam falhando, tente excluir a pasta node_modules e reinstalar os pacotes npm:
+
 ```
 rm -rf ./node_modules
 npm i
@@ -260,43 +267,43 @@ Fonte: [Notação Big-O Dicas](http://bigocheatsheet.com/).
 
 Abaixo está a lista de algumas das notações Big O mais usadas e suas comparações de desempenho em relação aos diferentes tamanhos dos dados de entrada.
 
-| Notação Big-O  | Cálculos para 10 elementos   | Cálculos para 100 elementos   | Cálculos para 1000 elementos    |
-| -------------- | ---------------------------- | ----------------------------- | ------------------------------- |
-| **O(1)**       | 1                            | 1                             | 1                               |
-| **O(log N)**   | 3                            | 6                             | 9                               |
-| **O(N)**       | 10                           | 100                           | 1000                            |
-| **O(N log N)** | 30                           | 600                           | 9000                            |
-| **O(N^2)**     | 100                          | 10000                         | 1000000                         |
-| **O(2^N)**     | 1024                         | 1.26e+29                      | 1.07e+301                       |
-| **O(N!)**      | 3628800                      | 9.3e+157                      | 4.02e+2567                      |
+| Notação Big-O  | Cálculos para 10 elementos | Cálculos para 100 elementos | Cálculos para 1000 elementos |
+| -------------- | -------------------------- | --------------------------- | ---------------------------- |
+| **O(1)**       | 1                          | 1                           | 1                            |
+| **O(log N)**   | 3                          | 6                           | 9                            |
+| **O(N)**       | 10                         | 100                         | 1000                         |
+| **O(N log N)** | 30                         | 600                         | 9000                         |
+| **O(N^2)**     | 100                        | 10000                       | 1000000                      |
+| **O(2^N)**     | 1024                       | 1.26e+29                    | 1.07e+301                    |
+| **O(N!)**      | 3628800                    | 9.3e+157                    | 4.02e+2567                   |
 
 ### Complexidade de operações de estrutura de dados
 
-| Estrutura de dados      | Acesso    | Busca     | Inserção  | Eliminação | Comentários |
-| ----------------------- | :-------: | :-------: | :-------: | :-------:  | :--------   |
-| **Array**               | 1         | n         | n         | n          |             |
-| **Stack**               | n         | n         | 1         | 1          |             |
-| **Queue**               | n         | n         | 1         | 1          |             |
-| **Linked List**         | n         | n         | 1         | 1          |             |
-| **Hash Table**          | -         | n         | n         | n          | Em caso de uma função hash perfeita, os custos seriam O(1) |
-| **Binary Search Tree**  | n         | n         | n         | n          | No caso de custos de árvore equilibrados seria O(log(n))
-| **B-Tree**              | log(n)    | log(n)    | log(n)    | log(n)     |             |
-| **Red-Black Tree**      | log(n)    | log(n)    | log(n)    | log(n)     |             |
-| **AVL Tree**            | log(n)    | log(n)    | log(n)    | log(n)     |             |
-| **Bloom Filter**        | -         | 1         | 1         | -          | Falsos positivos são possíveis durante a pesquisa |
+| Estrutura de dados     | Acesso | Busca  | Inserção | Eliminação | Comentários                                                |
+| ---------------------- | :----: | :----: | :------: | :--------: | :--------------------------------------------------------- |
+| **Array**              |   1    |   n    |    n     |     n      |                                                            |
+| **Stack**              |   n    |   n    |    1     |     1      |                                                            |
+| **Queue**              |   n    |   n    |    1     |     1      |                                                            |
+| **Linked List**        |   n    |   n    |    1     |     1      |                                                            |
+| **Hash Table**         |   -    |   n    |    n     |     n      | Em caso de uma função hash perfeita, os custos seriam O(1) |
+| **Binary Search Tree** |   n    |   n    |    n     |     n      | No caso de custos de árvore equilibrados seria O(log(n))   |
+| **B-Tree**             | log(n) | log(n) |  log(n)  |   log(n)   |                                                            |
+| **Red-Black Tree**     | log(n) | log(n) |  log(n)  |   log(n)   |                                                            |
+| **AVL Tree**           | log(n) | log(n) |  log(n)  |   log(n)   |                                                            |
+| **Bloom Filter**       |   -    |   1    |    1     |     -      | Falsos positivos são possíveis durante a pesquisa          |
 
 ### Complexidade dos Algoritmos de Ordenação de Matrizes
 
-| Nome                  | Melhor          | Média               | Pior                | Mémoria   | Estável   | Comentários |
-| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :--------   |
-| **Bubble sort**       | n               | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Sim       |             |
-| **Insertion sort**    | n               | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Sim       |             |
-| **Selection sort**    | n<sup>2</sup>   | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Não       |             |
-| **Heap sort**         | n&nbsp;log(n)   | n&nbsp;log(n)       | n&nbsp;log(n)       | 1         | Não       |             |
-| **Merge sort**        | n&nbsp;log(n)   | n&nbsp;log(n)       | n&nbsp;log(n)       | n         | Sim       |             |
-| **Quick sort**        | n&nbsp;log(n)   | n&nbsp;log(n)       | n<sup>2</sup>       | log(n)    | Não       | O Quicksort geralmente é feito no local com espaço de pilha O(log(n)) |
-| **Shell sort**        | n&nbsp;log(n)   | depende da sequência de lacunas | n&nbsp;(log(n))<sup>2</sup>     | 1      | Não    |                   |
-| **Counting sort**     | n + r           | n + r               | n + r               | n + r     | Sim       | r - maior número na matriz          |
-| **Radix sort**        | n * k           | n * k               | n * k               | n + k     | Sim       | k - comprimento da chave mais longa |
+| Nome               |    Melhor     |              Média              |            Pior             | Mémoria | Estável | Comentários                                                           |
+| ------------------ | :-----------: | :-----------------------------: | :-------------------------: | :-----: | :-----: | :-------------------------------------------------------------------- |
+| **Bubble sort**    |       n       |          n<sup>2</sup>          |        n<sup>2</sup>        |    1    |   Sim   |                                                                       |
+| **Insertion sort** |       n       |          n<sup>2</sup>          |        n<sup>2</sup>        |    1    |   Sim   |                                                                       |
+| **Selection sort** | n<sup>2</sup> |          n<sup>2</sup>          |        n<sup>2</sup>        |    1    |   Não   |                                                                       |
+| **Heap sort**      | n&nbsp;log(n) |          n&nbsp;log(n)          |        n&nbsp;log(n)        |    1    |   Não   |                                                                       |
+| **Merge sort**     | n&nbsp;log(n) |          n&nbsp;log(n)          |        n&nbsp;log(n)        |    n    |   Sim   |                                                                       |
+| **Quick sort**     | n&nbsp;log(n) |          n&nbsp;log(n)          |        n<sup>2</sup>        | log(n)  |   Não   | O Quicksort geralmente é feito no local com espaço de pilha O(log(n)) |
+| **Shell sort**     | n&nbsp;log(n) | depende da sequência de lacunas | n&nbsp;(log(n))<sup>2</sup> |    1    |   Não   |                                                                       |
+| **Counting sort**  |     n + r     |              n + r              |            n + r            |  n + r  |   Sim   | r - maior número na matriz                                            |
+| **Radix sort**     |    n \* k     |             n \* k              |           n \* k            |  n + k  |   Sim   | k - comprimento da chave mais longa                                   |
 
 > ℹ️ Outros [projetos](https://trekhleb.dev/projects/) e [artigos](https://trekhleb.dev/blog/) sobre JavaScript e algoritmos em [trekhleb.dev](https://trekhleb.dev)