O documento descreve o algoritmo de ordenação Selection Sort, explicando seu funcionamento passo a passo em um vetor de exemplo. Primeiro, um elemento é escolhido como "eleito" e comparado com os demais elementos à direita. Se um for menor/maior, depende da ordenação, ele se torna o novo "eleito". Após as comparações, os elementos na posição inicial e do "eleito" podem ser trocados.

1. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 1 de 11
SELECTION SORT
Selection Sort é um algoritmo de ordenação utilizado em arrays e listas dinâmicas. Este
algoritmo se comporta da seguinte maneira: um elemento do vetor é escolhido. Este elemento é
comparado com todos os outros elementos das posições à sua direita. Se a ordenação for
crescente, então se o elemento da próxima posição à direita do eleito for menor, eles devem
trocar de posição. Quando da ordenação decrescente, se o elemento da próxima posição à
direita for maior que o eleito, então eles devem trocar de posição.
É preciso tomar cuidado pois o último elemento de um vetor não tem mais elementos à
sua direita. Serão necessários dois FOR para a execução deste algoritmo, um dentro do outro,
ou seja, FOR aninhado. O FOR externo percorre e faz as trocas de posição, e o FOR interno
determina o eleito. O valor de eleito só é alterado se o valor do elemento da posição posterior é
maior (ou menor) que a posição atual, caso contrário, o valor de eleito deve ser mantido, então
utilizamos um IF para esta verificação, que deve estar dentro do FOR interno. Para efetuar a
mudança de posição, usamos um IF e uma variável auxiliar.
1. VETOR DESORDENADO
Suponha o seguinte vetor chamado V:
Índice 0 1 2 3 4
elemento 200 10 0 5 30
posição i i+1 i+2 i+3 i+4
Vamos utilizá-lo para analisar e testar o comportamento deste algoritmo. Apenas
reforçando que em Linguagem C o vetor começa na posição 0. Utilizamos o comando de controle
FOR para manipular vetores, então, aqui implementaremos um for que irá da posição 0 até a
posição 4 e será incrementado de 1, iniciando em zero.
Dentro deste for, determinamos o elemento eleito e incluiremos um segundo FOR, que
começará na posição j = i + 1 e passará por todas as posições do Vetor verificando se o elemento
da posição atual é menor que o elemento ELEITO. Se for VERDADEIRO, então, o ELEITO
passará a ser a posição j. Após o término da execução deste FOR, o algoritmo verifica se o
elemento do primeiro FOR é diferente ou igual ao eleito. Se sim, então uma troca de posições
acontece. Talvez ainda não esteja claro para o leitor, então, vamos verificar o passo a passo.

2. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 2 de 11
1.1. ORDENANDO DE FORMA CRESCENTE
1.ª Passagem no For: i = 0
Iteração 1
eleito = 0
j = 1
0 1 2 3 4
200 10 0 5 30
eleito j
numero[j] < numero[eleito]
numero[1] < numero[0]
10 < 200
V
eleito = j;
eleito = 1; (mudou)
Iteração 2
eleito = 1
j = 2
2 1 2 3 4
200 10 0 5 30
eleito j
numero[j] < numero[eleito]
numero[2] < numero[1]
0 < 10
V
eleito = j;
eleito = 2; (mudou)
Iteração 3
eleito = 2
j = 3
0 1 2 3 4
200 10 0 5 30
eleito j
numero[j] < numero[eleito]
numero[3] < numero[2]
5 < 0
F
eleito = j;
eleito = 2; (não muda)
Iteração 4
eleito = 2
j = 4
0 1 2 3 4
200 10 0 5 30
eleito j
numero[j] < numero[eleito]
numero[4] < numero[2]
30 < 0
F
eleito = j;
eleito = 2; (não muda)
Verificando e Trocando as Posições
eleito = 2
i = 0
0 1 2 3 4
200 10 0 5 30
i eleito

3. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 3 de 11
numero [ i ] != numero [ eleito ]
numero [ 0 ] != numero [ 2 ]
200 != 0
V
Aux = numero [ i ]
Aux = numero [ 0 ];
Aux = 200
numero [ i ] = numero [ eleito ]
numero [ 0 ] = numero [ 2 ]
numero [ 0 ] = 0
numero [ eleito ] = aux
numero [ 2 ] = 200
Estado do vetor após a troca
0 1 2 3 4
0 10 200 5 30
2.ª Passagem no For: i = 1
Iteração 1
eleito = 1
j = 2
0 1 2 3 4
0 10 200 5 30
eleito 2
numero[j] < numero[eleito]
numero[2] < numero[1]
200 < 10
F
eleito = j
eleito = 1 (não muda)
Iteração 2
eleito = 1
j = 3
0 1 2 3 4
0 10 200 5 30
eleito j
numero[j] < numero[eleito]
numero[3] < numero[1]
5 < 10
V
eleito = j
eleito = 3 (mudou)
Iteração 3
eleito = 3
j = 4
0 1 2 3 4
0 10 200 5 30
eleito j
numero[j] < numero[eleito]
numero[4] < numero[3]
30 < 5
F
eleito = j
eleito = 3 (não mudou)
Verificando e Trocando as Posições
eleito = 3
i = 1
0 1 2 3 4
0 10 200 5 30
i eleito

4. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 4 de 11
numero [ i ] != numero [ eleito ]
numero [ 1 ] != numero [ 3 ]
10 != 5
V
Aux = numero [ i ]
Aux = numero [ 1 ];
Aux = 10
numero [ i ] = numero [ eleito ]
numero [ 1 ] = numero [ 3 ]
numero [ 1 ] = 5
numero [ eleito ] = aux
numero [ 3 ] = 5
Estado do vetor após a troca:
0 1 2 3 4
0 5 200 10 30
3.ª Passagem no For: i = 2
Iteração 1
eleito = 2
j = 3
0 1 2 3 4
0 5 200 10 30
eleito j
numero[j] < numero[eleito]
numero[3] < numero[2]
10 < 200
V
eleito = j
eleito = 3 (mudou)
Iteração 2
eleito = 3
j = 4
0 1 2 3 4
0 5 200 10 30
eleito j
numero[j] < numero[eleito]
numero[4] < numero[3]
30 < 10
F
eleito = j
eleito = 3 (não mudou)
Verificando e Trocando as Posições
eleito = 3
i = 2
0 1 2 3 4
0 5 200 10 30
i eleito
numero [ i ] != numero [ eleito ]
numero [ 2 ] != numero [ 3 ]
200 != 10
V
Aux = numero [ i ]
Aux = numero [ 2];
Aux = 200
numero [ i ] = numero [ eleito ]
numero [ 2 ] = numero [ 3 ]
numero [ 2 ] = 10
numero [ eleito ] = aux
numero [ 3 ] = 200
Estado do vetor após a troca

5. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 5 de 11
0 1 2 3 4
0 5 10 200 30
4.ª Passagem no For: i = 3
Iteração 1
eleito = 3
j = 4
0 1 2 3 4
0 5 10 200 30
eleito j
numero[j] < numero[eleito]
numero[4] < numero[3]
30 < 200
V
eleito = j
eleito = 4 (mudou)
Verificando e Trocando as Posições
eleito = 4
i = 3
0 1 2 3 4
0 5 10 200 30
i eleito
numero [ i ] != numero [ eleito ]
numero [ 3 ] != numero [ 4 ]
200 != 30
V
Aux = numero [ i ]
Aux = numero [ 3];
Aux = 200
numero [ i ] = numero [ eleito ]
numero [ 3 ] = numero [ 4 ]
numero [ 3 ] = 30
numero [ eleito ] = aux
numero [ 4 ] = 200
Estado do vetor após a troca
0 1 2 3 4
0 5 10 30 200
FIM DA EXECUÇÃO DO ALGORITMO
CÓDIGO FONTE
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
void imprimir();
int i, j, aux, eleito, numero[5];
int main()
{
setlocale(LC_ALL, "Portuguese");
printf("n--------------------------------------------");
printf("nEXEMPLO SELECTION SORT");

6. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 6 de 11
printf("n--------------------------------------------");
printf("nInicializando o Array");
for(i=0; i<5; i++)
{
numero[i] = 0;
}
imprimir();
printf("n--------------------------------------------");
printf("nInserindo valores no Arrayn");
for(i=0; i<5; i++)
{
printf("n|Posição %d |Digite um número: t", i);
scanf("%d%*c",&numero[i]);
}
printf("n--------------------------------------------");
printf("nValores armazenados no array");
imprimir();
printf("n--------------------------------------------");
printf("nOrdenando o Array");
for (i = 0; i < 4; i++)
{
eleito = i;
for (j = (i+1); j < 5; j++)
{
if(numero[j] < numero[eleito])
{
eleito = j;
}
}
if (numero[i] != numero[eleito])
{
aux = numero[i];
numero[i] = numero[eleito];
numero[eleito] = aux;
}
}
printf("n--------------------------------------------");
printf("nValores ordenados");
imprimir();
printf("n--------------------------------------------");
return 0;
}
void imprimir()
{
printf("n--------------------------------------------");
for (i=0; i<5; i++)
{

7. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 7 de 11
printf("n|Posicao: %d | Número: %d|", i, numero[i]);
}
}
1.1. ORDENANDO DE FORMA DECRESCENTE
1.ª Passagem no For: i = 0
Iteração 1
eleito = 0
j = 1
0 1 2 3 4
200 10 0 5 30
eleito j
10 > 200 = F eleito = 0 j = 1 + 1
Iteração 2
eleito = 0
j = 2
0 1 2 3 4
200 10 0 5 30
eleito j
0 > 200 = F eleito = 0 j = 2 + 1
Iteração 3
eleito = 0
j = 3
0 1 2 3 4
200 10 0 5 30
eleito j
5 > 200 = F eleito = 0 j = 3 + 1
Iteração 4
eleito = 0
j = 4
0 1 2 3 4
200 10 0 5 30
eleito j
30 > 200 = F eleito = 0 j = 4 + 1
Verificando e Trocando as Posições
eleito = 0
i = 0
0 1 2 3 4
200 10 0 5 30
i
eleito
200 != 200 = F não há mudança

8. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 8 de 11
2.ª Passagem no For: i = 1
Iteração 1
eleito = 1
j = 2
0 1 2 3 4
200 10 0 5 30
eleito j
0 > 10 = F eleito = 0 j = 1 + 1
Iteração 2
eleito = 1
j = 3
0 1 2 3 4
200 10 0 5 30
eleito j
5 > 10 = F eleito = 0 j = 2 + 1
Iteração 3
eleito = 1
j = 4
0 1 2 3 4
200 10 0 5 30
eleito j
30 > 10 = V eleito = 4 j = 3 + 1
Iteração 4
eleito = 4
j = 5
0 1 2 3 4
200 10 0 5 30
eleito
Verificando e Trocando as Posições
eleito = 4
i = 1
0 1 2 3 4
200 10 0 5 30
i eleito
10 != 30 = V troca
Estado do vetor após a mudança:
0 1 2 3 4
200 30 0 5 10
3.ª Passagem no For: i = 2
Iteração 1

9. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 9 de 11
eleito = 2
j = 3
0 1 2 3 4
200 30 0 5 10
eleito j
5 > 0 = V eleito = 3 j = 3 + 1
Iteração 2
eleito = 3
j = 4
0 1 2 3 4
200 30 0 5 10
eleito j
10 > 5 = V eleito = 4 j = 4 + 1
Iteração 3
eleito = 4
j = 5
0 1 2 3 4
200 30 0 5 10
eleito
Verificando e Trocando as Posições
eleito = 4
i = 2
0 1 2 3 4
200 30 0 5 10
i eleito
0 != 10 = V troca
Estado do vetor após a mudança:
0 1 2 3 4
200 30 10 5 0
4.ª Passagem no For: i = 3
Iteração 1
eleito = 3
j = 4
0 1 2 3 4
200 30 10 5 0
eleito j
0 > 5 = F eleito = 3 j = 4 + 1
Iteração 2
eleito = 3
j = 5
0 1 2 3 4
200 30 10 5 0
eleito

10. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 10 de 11
Verificando e Trocando as Posições
eleito = 3
i = 3
0 1 2 3 4
200 30 0 5 10
I
eleito
0 != 0 = F não troca
FIM DA EXECUÇÃO DO ALGORITMO
Código Fonte
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
void imprimir();
int i, j, aux, eleito, numero[5];
int main()
{
setlocale(LC_ALL, "Portuguese");
printf("n--------------------------------------------");
printf("nEXEMPLO SELECTION SORT");
printf("n--------------------------------------------");
printf("nInicializando o Array");
for(i=0; i<5; i++)
{
numero[i] = 0;
}
imprimir();
printf("n--------------------------------------------");
printf("nInserindo valores no Arrayn");
for(i=0; i<5; i++)
{
printf("n|Posição %d |Digite um número: t", i);
scanf("%d%*c",&numero[i]);
}
printf("n--------------------------------------------");
printf("nValores armazenados no array");
imprimir();
printf("n--------------------------------------------");
printf("nOrdenando o Array");
for (i = 0; i < 4; i++)
{
eleito = i;
for (j = (i+1); j < 5; j++)
{

11. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Selection Sort
(2017) Página 11 de 11
if(numero[j] > numero[eleito])
{
eleito = j;
}
}
if (numero[i] != numero[eleito])
{
aux = numero[i];
numero[i] = numero[eleito];
numero[eleito] = aux;
}
}
printf("n--------------------------------------------");
printf("nValores ordenados");
imprimir();
printf("n--------------------------------------------");
return 0;
}
void imprimir()
{
printf("n--------------------------------------------");
for (i=0; i<5; i++)
{
printf("n|Posicao: %d | Número: %d|", i, numero[i]);
}
}