Ordenação por seleção (selection sort)

O algoritmo por seleção é a ferramenta mais natural para classificação de

elementos dentro de uma estrutura de dados. Esse algoritmo é usado para ordenar
um vetor por meio do K-ésimo menor ou maior elemento em uma estrutura de dados
complexa, por exemplo, um array ou lista (DEITEL; DEITEL, 2010).
O algoritmo percorre a matriz várias vezes, selecionando o menor próximo item
e posicionando-o no local correto, ou seja, funciona seguindo os seguintes passos:
• Encontre o menor elemento dentro da estrutura de dados;
• Compare com o elemento a seguir;
• Se for menor, troque esse elemento com o primeiro da matriz.

Figura – Mecânica do selection sort

Inicialmente, o primeiro elemento da matriz é considerado o menor elemento

(2.5).

Figura– Menor elemento

Em seguida, é feita uma busca para encontrar o menor elemento da matriz,

neste caso, é o número um. Se o valor do menor elemento for inferior ao do elemento
primeiro, ocorre uma troca. Caso contrário, as posições se mantêm.
 O próximo laço considera o segundo elemento da tabela e executa o algoritmo
novamente, desta vez buscando o segundo menor valor.

Figura– Comparação e troca

Complexidade

Esse algoritmo também possui uma complexidade quadrática, ou seja, usa o

termo O(n2). Como, em cada iteração, ele compara um elemento a todos os outros,
não existe melhor ou pior caso, afinal, mesmo que o array esteja perfeitamente
ordenado, o algoritmo será executado do começo ao fim.
 Figura– Complexidade

Esse algoritmo apresenta as seguintes vantagens:

• Simplicidade de implementação;
• Não utiliza vetores auxiliares de armazenamento temporário, por isso
não ocupa muito espaço memoria;
• Possui velocidade para algoritmo de ordenação para estruturas
pequenas.
Apesar disso, possui algumas desvantagens como:
• Operação vagarosa em estruturas de dados muito grandes;
• Sempre executa (n²-n)/2 comparações, independentemente do quão
ordenada está o array/lista.

Análise do algoritmo

A figura mostra um script em linguagem Java implementado com o algoritmo

por seleção em uma estrutura de dados tipo array composta por 10 elementos não
ordenados do tipo inteiro.
 Figura– Algoritmo de ordenação por seleção

Nota-se que os valores do array e a variável que o recebe estão declarados,

respectivamente, nas linhas 28 e 29.
Na linha 30, o comando de exibição do array é organizado pelo método de
ordenação por seleção. Método este que tem início na linha sete com recebimento de
parâmetros, um vetor e um tamanho de vetor.
Repare que o método é composto de dois comandos de repetição, um mais
externo e outro mais interno. O loop mais externo (linha nove) é responsável por
percorrer todo o array e é executado n-1 vezes. Para cada iteração (i) entre 0 e n-2, o
loop interno interage j= (n-1) - i vezes. Como as comparações de chaves são
realizadas no laço interno, ocorrem O(n2) comparações, sendo n o número de
elementos da matriz. Esse número é fixo tanto no melhor quanto no pior dos casos.

Podem ocorrer variações no script como posicionar o número maior no final da

matriz ao invés do menor no início, entretanto elas não alteram a maneira básica como
o elemento mínimo (ou máximo) é encontrado e nem melhoram a eficiência do
algoritmo.
 Ordenação por pente (comb sort)

O algoritmo de ordenação por pente (combo sort) opera na base de troca de

posições exatamente como o algoritmo por bolha (bubble sort), entretanto realiza a
operação de maneira melhorada, pois processa os dados previamente. Sua principal
função é organizar estruturas de dados como listas e arrays (ELKAHLOUT;
MAGHARI, 2017).
Uma comparação dos elementos é realizada por passos de posições
distanciadas umas das outras. A esses espaços é dado o nome de GAP. Em cada
iteração, esse passo se torna menor até se igualar a um. O princípio do algoritmo é
que os elementos maiores sejam movidos na direção do final da matriz para evitar as
chamadas tartarugas (valores pequenos no final do array) que prejudicam o
desempenho do algoritmo de bolha.

Figura– GAP de 3 posições

O algoritmo de pente faz uso de um fator de encolhimento de valor

1.247330950103979 que determina o GAP a ser usado na ordenação da lista, sempre
arredondando para o valor mais próximo.
Desta forma, pode-se dizer que, enquanto o GAP do algoritmo de bolha é
sempre 1, o de pente apresenta uma variação que tem início em X e termina em 1.

GAP = 3/1,3 = 2,3 = 2.

 Figura– GAP reduzido
A cada iteração, os valores das extremidades do GAP são comparados. Se o
valor inicial for menor que o final, eles são trocados. Caso contrário são mantidos. O
GAP se desloca, casa por casa, para a direita até o final da estrutura.

Figura– Troca dos valores

Complexidade

No melhor dos cenários, quando a matriz já está perfeitamente ordenada e não

são necessárias alterações, a complexidade da ordenação por pente é de O(n), por
outro lado, no pior dos casos ela é de O(n²).
Uma das principais vantagens desse algoritmo é que, durante as etapas de
classificação, não é necessário manter controle das operações de troca para saber
qual é o momento de parar. Além disso, apresenta maior eficiência nas primeiras
iterações e menor nas ultimas, pois passa a se comportar de maneira parecida com o
método de ordenação por bolha.
Ensaios experimentais indicam que o desempenho da ordenação por pente
pode ser comparado ao Quick Sort que é considerado o algoritmo de ordenação mais
rápido disponível.

Análise do algoritmo

Na figura, podemos ver um script em linguagem Java que implementa o

algoritmo de ordenação por pente para organizar uma estrutura de dados tipo array.
Por meio de sua análise, seremos mais capazes de compreender a aplicação do
algoritmo.

Figura– Algoritmo de ordenação por pente

 O algoritmo da figura ordena uma estrutura de dados do tipo array composto
por nomes que são declarados na linha 33 do código. Uma varável tipo array de string
que recebe o vetor ordenado do método combsort() que possui o parâmetro (nomes)
é determinado na linha 34.
Além disso, são declarados:
• O método de ordenação combSort (Linha nove);
• A variável de GAP (Linha dez);
• Uma varável do tipo primitiva Boleana (linha 11).
Ocorre um cascateamento de dois comandos de repetição, um externo que é
responsável pela análise do GAP e da variável de troca; e um interno cuja função é
trocar a posição dos elementos dentro da estrutura, além de fazer as comparações.
Nota-se que o fator de encolhimento foi usado para determinar o tamanho do
GAP no laço mais externo. Já no laço mais interno, foi empregado para fazer uma
comparação de elementos por meio de comando ‘compareTo’. Na linha 25 é
incrementada a iteração e na linha 28 é determinado que, após a ordenação, o array
retorna para ser exibido na linha 35 do código.
Pode-se concluir que, no algoritmo por pente, se o tamanho do GAP aumenta,
o número de trocas diminui. Isso, na maioria das vezes, torna o algoritmo mais veloz
e eficiente.

Coquetel (CockTail)

O algoritmo do tipo coquetel recebeu esse nome porque percorre a matriz de

um lado para o outro como se a estivessem chacoalhando. É similar ao sistema de
ordenação por bolha, afinal, ambos pertencem à família de algoritmos baseados em
comparação.
A principal diferença entre esses dois sistemas é a maneira como eles
percorrem a estrutura dos dados. Enquanto o algoritmo por bolha se movimenta da
esquerda para a direita, o coquetel percorre ambas as direções (ELKAHLOUT;
MAGHARI, 2017) o que faz com que a sua implementação seja muito mais difícil
(DEITEL; DEITEL, 2010)
 O algoritmo de coquetel, em sua primeira iteração, envia o maior elemento para
o final da lista. Na segunda, transporta o menor valor para o início da matriz e continua
intercalando até o array estar completamente ordenado.

Figura– Percorre em ambas as direções

A ideia é posicionar os elementos maiores no final da fila e os menores no início.

Sempre começando pela esquerda na primeira corrida.

Figura– Posicionamento dos elementos

Complexidade
Esse algoritmo de ordenação pode ser aplicado em estruturas de dados como
arrays e listas. O seu nível de complexidade é de O(n 2) no pior dos casos e O(n) no
melhor dos cenários.
Sua maior vantagem é resolver as tartarugas (elementos menores no final da
matriz) e os coelhos (elementos maiores no meio da estrutura). Isso faz com que seu
desempenho seja superior à ordenação por bolha.
 Análise do código

A figura mostra um script em linguagem Java implementado com o algoritmo

coquetel de uma estrutura de dados do tipo array. Por meio de sua análise, é possível
ter uma compreensão melhor do algoritmo.

Figura – Algoritmo de ordenação coquetel

O script da figura contém um array de dez elementos desordenados de valores

do tipo inteiro entre zero e nove que foi estabelecido na linha 31. Uma variável do tipo
array recebe, na linha 32, o conjunto ordenado que retornou do método cocktailSort().
O método cocktailSort tem início na linha sete com o recebimento do parâmetro
que, neste caso é o array de inteiros não ordenado. Nas linhas nove e dez, são
declaradas as variáveis de controles. Logo em seguida, um primeiro comando de
repetição é usado para fazer a análise da variável de troca e se a variável de início é
menor que a do fim.
Dentro desse laço, existem dois comandos de repetição.
 No primeiro, é feita uma comparação entre os elementos para entender qual é
o maior valor entre os pares e para posicioná-lo no final da matriz. No segundo, é feito
um contraste entre os pares para analisar qual é o elemento de menor valor para,
então, movê-lo para o início do conjunto. Esse processo se repete até que a condição
inicial do primeiro laço não seja satisfeita. Na linha 27, o array já ordenado retorna
impresso na linha 33.
Embora o algoritmo coquetel seja ligeiramente mais eficiente que o algoritmo
por bolha, é quase sempre mais lento que o de inserção. Desta forma não é muito
adequado para o uso em produção.