DEV Community: Isadora Ariane

TOP 25 ALGORITMOS | Selection Sort Array

Isadora Ariane — Wed, 08 Apr 2026 15:23:52 +0000

Selection Sort é um algoritmo de classificação baseado em comparação. Ele classifica um array selecionando repetidamente o menor (ou maior) elemento da porção não classificada e trocando-o com o primeiro elemento não classificado. Esse processo continua até que o array inteiro seja classificado.

📁 | Resumo

🤖 | Código

function selectionSort(arr) {
  let n = arr.length;
  for (let i = 0; i < n - 1; i++) {

      // Assuma que a posição atual é válida o elemento mínimo
      let min_idx = i;

      // Iterar pela parte não classificada para encontrar o mínimo real
      for (let j = i + 1; j < n; j++) {
          if (arr[j] < arr[min_idx]) {

              // Atualiza min_idx se um elemento menor for encontrado
              min_idx = j;
          }
      }

      // Move o elemento mínimo para seu posição correta
      let temp = arr[i];
      arr[i] = arr[min_idx];
      arr[min_idx] = temp;
  }
}

🕰️ | Complexidade de Tempo
Como há dois loops aninhados, um loop para selecionar um elemento do array um por um (O(n)) e outro loop para comparar esse elemento com todos os outros elementos do array (O(n)), a complexidade de tempo será: O(n) ∙ O(n) = O(n ∙ n) = O(n²)

📦 | Complexidade de Espaço
A complexidade de espaço é constante, ou seja, O(1).

✔️ | Vantagens
✦ Fácil de entender e implementar, tornando-o ideal para ensinar conceitos básicos de classificação;
✦ Requer menos número de trocas (ou gravações de memória) em comparação a muitos outros algoritmos padrão;

❌ | Desvantagens
✦ Mais lenta em comparação a algoritmos como Quick Sort ou Merge Sort;
✦ Não preserva a ordem relativa de itens com chaves iguais, o que significa que não é estável;

TOP 25 ALGORITMOS | Knuth-Morris-Pratt (KMP) Array

Isadora Ariane — Wed, 08 Apr 2026 15:19:11 +0000

Este algoritmo é um algoritmo de busca de strings que é usado para encontrar um padrão dentro de textos grandes de forma eficiente. Ao contrário do algoritmo de busca de padrões ingênuos que começa do início do padrão após cada incompatibilidade, o KMP usa a estrutura do padrão para evitar comparações redundantes. Ele pré-processa a string do padrão e cria uma matriz chamada matriz Longest Prefix Suffix (lps) que indica quanto do padrão pode ser reutilizado após uma incompatibilidade.

📁 | Resumo

🤖 | Código

function constructLps(pat, lps) {

  // len armazena o comprimento do prefixo mais longo que também é um sufixo para o índice anterior
  let len = 0;


  // lps[0] é sempre 0
  lps[0] = 0;


  let i = 1;
  while (i < pat.length) {

      // Se os caracteres corresponderem, incremente o tamanho de lps
      if (pat[i] === pat[len]) {
          len++;
          lps[i] = len;
          i++;
      }

      // Se houver uma incompatibilidade
      else {
          if (len !== 0) {

              // Atualiza len para o valor lps anterior para evitar comparações redundantes
              len = lps[len - 1];
          } else {

              // Se nenhum prefixo correspondente for encontrado, defina lps[i] como 0
              lps[i] = 0;
              i++;
          }
      }
  }
}


function search(pat, txt) {
  const n = txt.length;
  const m = pat.length;


  const lps = new Array(m);
  const res = [];


  constructLps(pat, lps);


  // Ponteiros i e j, para percorrer o texto e o padrão
  let i = 0;
  let j = 0;


  while (i < n) {

      // Se os caracteres corresponderem, mova ambos os ponteiros para frente
      if (txt[i] === pat[j]) {
          i++;
          j++;


          // Se o padrão inteiro for correspondido armazena o índice inicial no resultado
          if (j === m) {
              res.push(i - j);

              // Utiliza o LPS do índice anterior para pula comparações desnecessárias
              j = lps[j - 1];
          }
      }

      // Se houver uma incompatibilidade
      else {

          // Use o valor lps do índice anterior para evitar comparações redundantes
          if (j !== 0)
              j = lps[j - 1];
          else
              i++;
      }
  }
  return res; 
}

🕰️ | Complexidade de Tempo
Como N é o comprimento do texto e M é o comprimento do padrão. Isso ocorre porque criar o array LPS (Longest Prefix Suffix) leva tempo O(M), e a busca pelo texto leva tempo O(N). Logo, a complexidade de tempo será O(N + M).

📦 | Complexidade de Espaço
Como há necessidade de espaço temporário auxiliar, a complexidade de espaço será O(M).

✔️ | Vantagens
✦ Eficiente;

❌ | Desvantagens
✦ Nada intuitivo e nada fácil de implementar;

TOP 25 ALGORITMOS | Floyd’s Cycle Finding Array

Isadora Ariane — Wed, 08 Apr 2026 15:16:43 +0000

É um algoritmo de ponteiro que usa apenas dois ponteiros, movendo-se pela sequência em velocidades diferentes. Este algoritmo é usado para encontrar um loop em uma lista encadeada. Ele usa dois ponteiros, um movendo-se duas vezes mais rápido que o outro. O mais rápido é chamado de ponteiro rápido e o outro é chamado de ponteiro lento.

📁 | Resumo

🤖 | Código

class Node {
  constructor(x) {
      this.data = x;
      this.next = null;
  }
}

// Função que retorna true se houver um loop em lista encadeada senão retorna false.
function detectLoop(head) {

  // Ponteiros rápidos e lentos apontam inicialmente para cabeça
  let slow = head, fast = head;

  // Loop que é executado enquanto os ponteiros rápido e lento estão não é nulo e não é igual
  while (slow !== null && fast !== null
         && fast.next !== null) {
      slow = slow.next;
      fast = fast.next.next;

      // Se o ponteiro rápido e lento apontar para o mesmo nó, então o ciclo é detectado
      if (slow === fast) {
          return true;
      }
  }
  return false;
}

// Crie uma lista linkada: 10 -> 20 -> 30 -> 40 -> 50 -> 60
let head = new Node(10);
head.next = new Node(20);
head.next.next = new Node(30);
head.next.next.next = new Node(40);
head.next.next.next.next = new Node(50);
head.next.next.next.next.next = new Node(60);

head.next.next.next.next = head;

if (detectLoop(head))
  console.log("true");
else
  console.log("false");

🕰️ | Complexidade de Tempo
Como depende do número de nós, a complexidade de tempo será O(n).

📦 | Complexidade de Espaço
Como NÃO há necessidade de espaço temporário auxiliar, a complexidade de espaço será O(1).

✔️ | Vantagens
✦ Eficiente;

❌ | Desvantagens
✦ Nada intuitivo e nada fácil de implementar;

TOP 25 ALGORITMOS | Kadane's Array

Isadora Ariane — Wed, 08 Apr 2026 15:15:00 +0000

A ideia do algoritmo de Kadane é percorrer o array da esquerda para a direita e, para cada elemento, encontrar a soma máxima entre todos os subarrays que terminam naquele elemento. O resultado será o máximo de todos esses valores.

📁 | Resumo

🤖 | Código

function maxSubarraySum(arr) {
  let res = arr[0];

  // Loop externo para ponto inicial do subarray
  for (let i = 0; i < arr.length; i++) {
      let currSum = 0;

      // Loop interno para ponto final do subarray
      for (let j = i; j < arr.length; j++) {
          currSum = currSum + arr[j];

          // Atualiza res se currSum for maior que res
          res = Math.max(res, currSum);
      }
  }

  return res;
}

🕰️ | Complexidade de Tempo
Como estamos percorrendo a matriz apenas uma vez, a complexidade de tempo será O(n).

📦 | Complexidade de Espaço
Como estamos percorrendo a matriz apenas uma vez, a complexidade de espaço será O(1).

TOP 25 ALGORITMOS | Counting Sort

Isadora Ariane — Wed, 08 Apr 2026 15:12:33 +0000

É um algoritmo de classificação não baseado em comparação. Ele é particularmente eficiente quando o intervalo de valores de entrada é pequeno comparado ao número de elementos a serem classificados. A ideia básica é contar a frequência de cada elemento distinto no array de entrada e usar essa informação para colocar os elementos em suas posições corretas classificadas.

📁 | Resumo

🤖 | Código

function countSort(inputArray) {
  const N = inputArray.length;

  // Encontrando o elemento máximo de inputArray
  let M = 0;
  for (let i = 0; i < N; i++) {
      M = Math.max(M, inputArray[i]);
  }

  // Inicializando countArray com 0
  const countArray = new Array(M + 1).fill(0);

  // Mapeando cada elemento de inputArray como um índice de countArray
  for (let i = 0; i < N; i++) {
      countArray[inputArray[i]]++;
  }

  // Calculando a soma do prefixo em cada índice de countArray
  for (let i = 1; i <= M; i++) {
      countArray[i] += countArray[i - 1];
  }

  // Criando outputArray a partir de countArray
  const outputArray = new Array(N);
  for (let i = N - 1; i >= 0; i--) {
      outputArray[countArray[inputArray[i]] - 1] = inputArray[i];
      countArray[inputArray[i]]--;
  }

  return outputArray;
}

🕰️ | Complexidade de Tempo
Requer DOIS ESPAÇOS de memória extra temporária. Logo, sua complexidade de espaço será descrita por O(P + M), sendo P o inputArray[ ] e M o countArray[ ].

📦 | Complexidade de Espaço
Requer DOIS ESPAÇOS de memória extra temporária. Logo, sua complexidade de espaço será descrita por O(N + M), sendo N o correspArray[ ] e M o countArray[ ].

✔️ | Vantagens
✦ Fácil de implementar, estável e rápido;

❌ | Desvantagens
✦ Precisa de espaço auxiliar;
✦ Não funciona em valores decimais;
✦ Ineficiente se o intervalo de valores a serem ordenados for muito grande;

TOP 25 ALGORITMOS | Quick Sort

Isadora Ariane — Wed, 08 Apr 2026 15:10:15 +0000

É um algoritmo de classificação baseado em Dividir e Conquistar que escolhe um elemento como pivô e particiona o array fornecido em torno do pivô escolhido, colocando o pivô em sua posição correta no array classificado.

📁 | Resumo

🤖 | Código

function partition(arr, low, high){

  // Escolha o pivô
  let pivot = arr[high];

  // Índice do menor elemento e indica a posição correta do pivô encontrada até agora
  let i = low - 1;

  // Percorre arr[low..high] e move todos os elementos menores para o lado esquerdo. Elementos de low para i são menores após cada iteração
  for (let j = low; j <= high - 1; j++) {
      if (arr[j] < pivot) {
          i++;
          swap(arr, i, j);
      }
  }

  // Move o pivô após elementos menores e retorna sua posição
  swap(arr, i + 1, high);
  return i + 1;
}

function swap(arr, i, j){
  let temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

🕰️ | Complexidade de Tempo
✦ Melhor Cenário: ocorre quando o elemento pivô divide a matriz em duas metades iguais O(Ω ∙ (n ∙ log (n)));
✦ Cenário Comum: em média, o pivô divide a matriz em duas partes, mas não necessariamente iguais O(θ ∙ (n ∙ log (n)));
✦ Pior Cenário: ocorre quando o menor ou maior elemento é sempre escolhido como pivô (por exemplo, matrizes classificadas), O(n²);

📦 | Complexidade de Espaço
Requer apenas um espaço de memória extra temporária. Logo, sua complexidade de espaço será descrita por O(n).

✔️ | Vantagens
✦ Rápido;
✦ Baixa sobrecarga de memória;
✦ Eficiente em grandes conjuntos de dados;

❌ | Desvantagens
✦ Não é estável;

TOP 25 ALGORITMOS | Merge Sort

Isadora Ariane — Wed, 08 Apr 2026 15:07:51 +0000

É um algoritmo de que funciona dividindo recursivamente o array de entrada em subarrays menores e classificando esses subarrays e, em seguida, mesclando-os novamente para obter o array classificado.

📁 | Resumo

🤖 | Código

function merge(arr, left, mid, right) {
  const n1 = mid - left + 1;
  const n2 = right - mid;

  // Cria matrizes temporárias
  const L = new Array(n1);
  const R = new Array(n2);

  // Copia dados para matrizes temporárias L[] e R[]
  for (let i = 0; i < n1; i++)
      L[i] = arr[left + i];
  for (let j = 0; j < n2; j++)
      R[j] = arr[mid + 1 + j];

  let i = 0, j = 0;
  let k = left;

  // Mescla as matrizes temporárias de volta em arr[left..right]
  while (i < n1 && j < n2) {
      if (L[i] <= R[j]) {
          arr[k] = L[i];
          i++;
      } else {
          arr[k] = R[j];
          j++;
      }
      k++;
  }

  // Copie os elementos restantes de L[], se houver algum
  while (i < n1) {
      arr[k] = L[i];
      i++;
      k++;
  }

  // Copie os elementos restantes de R[], se houver algum
  while (j < n2) {
      arr[k] = R[j];
      j++;
      k++;
  }
}

function mergeSort(arr, left, right) {
  if (left >= right)
      return;

  const mid = Math.floor(left + (right - left) / 2);
  mergeSort(arr, left, mid);
  mergeSort(arr, mid + 1, right);
  merge(arr, left, mid, right);
}

🕰️ | Complexidade de Tempo
O tempo de execução do algoritmo cresce em função do tamanho da entrada n multiplicado pelo logaritmo de n. Esse tipo de complexidade geralmente aparece em algoritmos que combinam operações lineares com alguma forma de divisão e conquista. Logo, sua complexidade de tempo será descrita por O(n ∙ log(n)).

✦ Melhor Cenário: se a lista já estiver classificada, ou seja, ordenada, O(n ∙ log (n));
✦ Cenário Comum: se a lista estiver classificada de forma aleatória, O(n ∙ log (n));
✦ Pior Cenário: se a lista estiver classificada de forma reversa (decrescente), O(n ∙ log (n));

📦 | Complexidade de Espaço
Requer apenas um espaço de memória extra temporária. Logo, sua complexidade de espaço será descrita por O(n).

✔️ | Vantagens
✦ Estável e eficiente;
✦ Simples de Implementar;
✦ Processamento em paralelo;

❌ | Desvantagens
✦ Requer memória adicional;
✦ Mais lento que o Quick Sort;

TOP 25 ALGORITMOS | Selection Sort

Isadora Ariane — Wed, 08 Apr 2026 15:05:26 +0000

É um algoritmo de classificação baseado em comparação. Ele classifica um array selecionando repetidamente o menor (ou maior) elemento da porção não classificada e trocando-o com o primeiro elemento não classificado. Esse processo continua até que o array inteiro seja classificado.

📁 | Resumo

🤖 | Código

function selectionSort(arr) {
  let n = arr.length;
  for (let i = 0; i < n - 1; i++) {

      // Assuma que a posição atual é válida o elemento mínimo
      let min_idx = i;

      // Iterar pela parte não classificada para encontrar o mínimo real
      for (let j = i + 1; j < n; j++) {
          if (arr[j] < arr[min_idx]) {

              // Atualizar min_idx se um elemento menor for encontrado
              min_idx = j;
          }
      }

      // Move o elemento mínimo para seu posição correta
      let temp = arr[i];
      arr[i] = arr[min_idx];
      arr[min_idx] = temp;
  }
}

🕰️ | Complexidade de Tempo
O tempo de execução de um algoritmo cresce de forma quadrática em relação ao tamanho da entrada n. Em outras palavras, se o tamanho da entrada dobra, o tempo de execução pode quadruplicar. Logo, sua complexidade de tempo será descrita por O(n²).

📦 | Complexidade de Espaço
Requer apenas um espaço de memória extra constante. Logo, sua complexidade de espaço será descrita por O(1).

✔️ | Vantagens
✦ Fácil de entender e implementar;
✦ Requer apenas um espaço de memória extra constante O(1);
✦ Requer menos número de swaps (ou gravações de memória) em comparação a muitos outros algoritmos padrão;

❌ | Desvantagens
✦ Processamento lento;
✦ Não mantém a ordem relativa de elementos iguais;
✦ Não preserva a ordem relativa de itens com chaves iguais, o que significa que é instável;

TOP 25 ALGORITMOS | Heap Sort

Isadora Ariane — Wed, 08 Apr 2026 15:03:29 +0000

É uma técnica de classificação baseada em comparação baseada na Binary Heap Data Structure. Pode ser vista como uma otimização sobre a classificação por seleção, onde primeiro encontramos o elemento máximo (ou mínimo) e o trocamos com o último (ou primeiro). Repetimos o mesmo processo para os elementos restantes.

📁 | Resumo

🤖 | Código

function heapify(arr, n, i) {

  // Inicializa o maior como raiz
  let largest = i;

  // Index da esquerda = 2*i + 1
  let l = 2 * i + 1; 

  // Index da direita = 2*i + 2
  let r = 2 * i + 2; 

  // Se o filho da esquerda for maior que a raiz
  if (l < n && arr[l] > arr[largest]) {
      largest = l;
  }

  // Se o filho da direita for maior que o largest até agora
  if (r < n && arr[r] > arr[largest]) {
      largest = r;
  }

  // Se o maior não for raiz
  if (largest !== i) {
      let temp = arr[i]; // Swap
      arr[i] = arr[largest];
      arr[largest] = temp;

      // Heapificar recursivamente a subárvore afetada
      heapify(arr, n, largest);
  }
}

// Função principal para fazer heap sort
function heapSort(arr) {
  let n = arr.length;

  // Construir heap (rearrange array)
  for (let i = Math.floor(n / 2) - 1; i >= 0; i--) {
      heapify(arr, n, i);
  }

  // Extrai um por um um elemento do heap
  for (let i = n - 1; i > 0; i--) {

      // Mover a raiz atual para o fim
      let temp = arr[0];
      arr[0] = arr[i];
      arr[i] = temp;

      // Chama max heapify no heap reduzido
      heapify(arr, i, 0);
  }
}

// Uma função utilitária para imprimir um array de tamanho n
function printArray(arr) {
  for (let i = 0; i < arr.length; i++) {
      console.log(arr[i] + " ");
  }
  console.log();
}

📦 | Complexidade de Espaço
A quantidade de memória que um algoritmo usa cresce de forma logarítmica em relação ao tamanho da entrada n. Isso significa que, mesmo que a entrada n aumente significativamente, o espaço adicional necessário cresce lentamente. Logo, sua complexidade de espaço será descrita por O(log(n)).

✔️ | Vantagens
✦ Rápido, econômico e simples;

❌ | Desvantagens
✦ Instabilidade e ineficiência;

TOP 25 ALGORITMOS | Insertion Sort

Isadora Ariane — Wed, 08 Apr 2026 15:00:31 +0000

É um algoritmo de classificação simples que funciona inserindo iterativamente cada elemento de uma lista não classificada em sua posição correta em uma parte classificada da lista. É como classificar cartas de baralho em suas mãos. Você divide as cartas em dois grupos: as cartas classificadas e as cartas não classificadas. Então, você escolhe uma carta do grupo não classificado e a coloca no lugar certo no grupo classificado.

📁 | Resumo

🤖 | Código

function insertionSort(arr) {
  for (let i = 1; i < arr.length; i++) {
      let key = arr[i];
      let j = i - 1;

      /* Move elementos de arr[0..i-1], que são maiores que key, para uma posição à frente de sua posição atual */
      while (j >= 0 && arr[j] > key) {
          arr[j + 1] = arr[j];
          j = j - 1;
      }
      arr[j + 1] = key;
  }
}

🕰️ | Complexidade de Tempo
✦ Melhor Cenário: se a lista já estiver classificada, ou seja, ordenada, O(n);
✦ Cenário Comum: se a lista estiver classificada de forma aleatória, O(n²);
✦ Pior Cenário: se a lista estiver classificada de forma reversa (decrescente), O(n²);

📦 | Complexidade de Espaço
A classificação por inserção requer espaço adicional, o que a torna um algoritmo de classificação com uso eficiente de espaço. Logo, a complexidade de espaço será de O(1).

✔️ | Vantagens
✦ Simples e fácil de implementar;
✦ Algoritmo de classificação estável;
✦ Eficiente para listas pequenas e listas quase classificadas;
✦ Eficiente em termos de espaço, pois é um algoritmo no local;
✦ O número de inversões é diretamente proporcional ao número de trocas (swaps).

❌ | Desvantagens
✦ Ineficiente para listas grandes;

TOP 25 ALGORITMOS | Breadth First Search (BFS)

Isadora Ariane — Wed, 08 Apr 2026 14:58:26 +0000

O algoritmo começa de uma fonte dada e explora todos os vértices alcançáveis da fonte dada. Como a árvore, começamos com a fonte dada (na árvore, começamos com a raiz) e atravessamos os vértices nível por nível usando uma estrutura de dados de fila. O único problema aqui é que, diferentemente das árvores, os gráficos podem conter ciclos, então podemos chegar ao mesmo nó novamente. Para evitar processar um nó mais de uma vez, usamos um array booleano visitado.

📁 | Resumo

🤖 | Código

function bfs(adj, s) {
  const visited = Array(V).fill(false); 
  const queue = []; 

  // Marca o nó de origem como visitado e o enfileira
  visited[s] = true;
  queue.push(s);

  // Itera sobre a fila
  while (queue.length) {

      // Desfila um vértice da fila e o imprime
      const curr = queue.shift();
      process.stdout.write(curr + " ");

      // Obtém todos os vértices adjacentes do vértice desenfileirado. Se um adjacente não foi visitado, marca-o como visitado e o enfileira
      for (const x of adj[curr]) {
          if (!visited[x]) {
              visited[x] = true;
              queue.push(x);
          }
      }
  }
}

// Função para adicionar uma aresta ao gráfico
function addEdge(u, v) {
  adj[u].push(v);
  adj[v].push(u);
}

🕰️ | Complexidade de Tempo
A complexidade depende do número de vértices (V) e de arestas (A) do grafo, sendo portanto, O(V+A).

📦 | Complexidade de Espaço
A complexidade depende do número de vértices (V), sendo portanto, O(V).

✔️ | Vantagens
✦ Nunca ficará preso em looping;
✦ Se houver uma solução, o algoritmo irá encontrar;
✦ Se houver mais de uma solução, o algoritmo pode irá encontrar a mais eficiente;

❌ | Desvantagens
✦ É limitado pelo uso de memória;

TOP 25 ALGORITMOS | Depth First Search (DFS)

Isadora Ariane — Wed, 08 Apr 2026 14:55:21 +0000

O algoritmo começa de uma fonte dada e explora todos os vértices alcançáveis da fonte dada. Em um grafo (tipo de estrutura de dados), pode haver loops. Então usamos um array visitado extra para garantir que não processemos um mesmo vértice novamente.

📁 | Resumo

🤖 | Código

function dfsRec(adj, visited, s){
  // Marcar o vértice atual como visitado
  visited[s] = true;

  // Imprima o vértice atual
  process.stdout.write(s + " ");

  // Visita recursivamente todos os vértices adjacentes que ainda não foram visitados
  for (let i of adj[s]) {
      if (!visited[i]) {
          dfsRec(adj, visited, i);
      }
  }
}

function dfs(adj, s){
  const visited = new Array(adj.length).fill(false);

  // Chamar a função DFS recursiva
  dfsRec(adj, visited, s);
}

function addEdge(adj, s, t){
  // Adicione a aresta do vértice s ao t
  adj[s].push(t);
  // Devido ao gráfico não direcionado
  adj[t].push(s);
}

const V = 5; // Número de vértices no gráfico

// Crie uma lista de adjacências para o gráfico
const adj = Array.from({length : V}, () => []);

// Defina as arestas do gráfico
const edges =
  [ [ 1, 2 ], [ 1, 0 ], [ 2, 0 ], [ 2, 3 ], [ 2, 4 ] ];

// Preencha a lista de adjacências com arestas
for (let e of edges) {
  addEdge(adj, e[0], e[1]);
}

🕰️ | Complexidade de Tempo
A complexidade depende do número de vértices (V) e de arestas (A) do grafo, sendo portanto, O(V+A).

📦 | Complexidade de Espaço
A complexidade depende do número de vértices (V) e de arestas (A) do grafo, sendo portanto, O(V+A).

Obs.: lembre que este algoritmo necessita da utilização de um espaço auxiliar!

✔️ | Vantagens
✦ A busca é limitada pelo tempo;
✦ Requisição linear de memória;

❌ | Desvantagens
✦ Um grafo finito pode gerar uma solução infinita;