2.2 Selection Sort

10/08/2026 • Guilherme Avelar • 6 min de leitura

Se o Bubble Sort funciona empurrando o maior valor para o final (como uma bolha), o Selection Sort (Ordenação por Seleção) faz o caminho oposto de forma muito mais direta: ele varre a lista, encontra o menor elemento de todos e o coloca na primeira posição. Depois encontra o segundo menor, e coloca na segunda posição, e assim por diante.

Imagine um esquilo faminto diante de uma pilha de nozes de tamanhos variados. Ele quer comer a menor noz primeiro para abrir o apetite. Ele olha todas as nozes da pilha, pega a menorzinha e a separa. Depois olha o que sobrou, pega a próxima menor e separa. Ele está fazendo um Selection Sort!

Esquilo organizando nozes por tamanho

🔍 Entendendo o Passo a Passo

Vamos usar os mesmos números caóticos do nosso exemplo anterior:

5
0
3
1
8
2
4
3
2
4

Passada 1

O algoritmo começa na primeira posição (o índice 0, onde está o 5). O objetivo é descobrir se existe algum número menor que ele no resto do array.

Nós guardamos o 5 como o “menor número encontrado até agora”.

5
0
3
1
8
2
4
3
2
4

Agora olhamos o 3. O 3 é menor que 5? Sim. Então atualizamos nosso “menor número” para ser o 3.

5
0
3
1
8
2
4
3
2
4

Olhamos o 8. É menor que 3? Não. Olhamos o 4. É menor que 3? Não. Olhamos o 2. É menor que 3? Sim!

5
0
3
1
8
2
4
3
2
4

Terminamos de olhar a lista inteira. O menor número de toda a lista é, definitivamente, o 2. Como ele é o menor de todos, nós o trocamos de lugar com o número que estava na primeira posição (o 5).

2
0
3
1
8
2
4
3
5
4

🎉 Fim da Passada 1! O 2 está na sua posição definitiva. A primeira noz do esquilo foi separada com sucesso.

2
0
3
1
8
2
4
3
5
4

Passada 2

Ignoramos a primeira posição (porque já está ordenada) e focamos no resto do array. O primeiro número não-ordenado agora é o 3. Ele é o nosso candidato a menor.

2
0
3
1
8
2
4
3
5
4

Olhamos o 8. É menor que 3? Não. Olhamos o 4. É menor que 3? Não. Olhamos o 5. É menor que 3? Não.

Ao final, descobrimos que o 3 já era o menor elemento do resto da lista! Ele não precisa trocar de lugar com ninguém, apenas garantimos o lugar dele.

2
0
3
1
8
2
4
3
5
4

Passada 3

Agora o primeiro não-ordenado é o 8. Olhamos o 4. É menor que 8? Sim! Nosso menor agora é o 4. Olhamos o 5. É menor que 4? Não.

O menor número restante é o 4. Vamos trocá-lo de lugar com o cara que estava no início (o 8).

2
0
3
1
4
2
8
3
5
4

O 4 está no lugar definitivo!

2
0
3
1
4
2
8
3
5
4

Passada 4 (Final)

Temos apenas o 8 e o 5. O primeiro é o 8. Comparamos com o 5. O 5 é menor. Trocamos o 8 pelo 5.

2
0
3
1
4
2
5
3
8
4

E automaticamente, se o 5 está no lugar certo, o 8 (sendo o último) também está! O caos foi derrotado novamente.

2
0
3
1
4
2
5
3
8
4

📜 Como fica no Código?

A implementação do Selection Sort exige uma lógica de rastreamento de índices. Vamos analisar como os laços refletem a estratégia de encontrar o menor valor.

def selection_sort(lista):
    n = len(lista)
    for i in range(n):
        indice_menor = i
        for j in range(i + 1, n):
            if lista[j] < lista[indice_menor]:
                indice_menor = j  # Atualiza a posição do menor elemento encontrado.
        lista[i], lista[indice_menor] = lista[indice_menor], lista[i]
        
    return lista

🧠 Dissecando a Lógica

O código do Selection Sort é um ótimo exemplo prático de como rastrear índices. Vamos olhar de perto como ele constrói essa lógica:

  1. Onde começa a desordem? (for i in range(n)): A variável i funciona como uma divisória entre a “área limpa” e a “área bagunçada” do array. Tudo à esquerda de i já está ordenado. O trabalho desse laço é apontar para o primeiro assento vazio e dizer: “Agora precisamos encontrar quem vai sentar na cadeira número i”.

  2. Quem é o menor? (indice_menor = i): Antes de varrer a área bagunçada, o algoritmo faz uma aposta segura. Ele assume que a pessoa que já está sentada na cadeira i é o menor valor restante. Se ele achar alguém menor pelo caminho, ele só precisa atualizar quem ganha esse índice.

  3. Olhando para o resto da fila (for j in range(i + 1, n)):

    • Não começamos a busca do zero porque o lado esquerdo do array já está pronto. E começamos de i + 1 porque não faz sentido o elemento atual apostar corrida contra ele mesmo!
    • Durante a busca, se acharmos um valor (lista[j]) menor que o nosso campeão atual (lista[indice_menor]), nós não trocamos os valores de lugar imediatamente. Nós simplesmente anotamos a posição do novo vencedor: indice_menor = j.

  4. Trocando de lugar apenas uma vez: A troca real (o swap) só acontece totalmente fora do laço interno, quando já temos certeza absoluta de que olhamos todos os candidatos. É isso que faz o Selection Sort ser tão elegante: ele economiza processamento e acessos à memória realizando apenas uma troca por rodada!

⏳ Complexidade (Big O)

O Selection Sort é mais limpo que o Bubble Sort, pois ele faz muito menos trocas. No entanto, o número de comparações continua alto.

Para encontrar o menor elemento na primeira vez, você olhou todos os n elementos. Na segunda vez, n - 1. Depois n - 2… No final, você fez operações proporcionais a O(n²), independentemente do array estar bagunçado ou já ordenado (pois ele sempre tem que procurar até o fim para ter certeza de que encontrou o menor).

O Selection Sort não é super veloz, mas é elegante e muito intuitivo. No próximo capítulo, vamos aprender o algoritmo que você (provavelmente) usa quando está ordenando cartas de baralho na sua mão!

← 2.1 Bubble Sort 2.3 Insertion Sort →