ALGORITMOS DE ORDENAÇÃO

INTERNA
PROF. MARCOS PAULO DOS SANTOS SILVA
DEFINIÇÃO

• Algoritmo de ordenação na Computação é um algoritmo que coloca os

elementos de uma dada sequência em uma certa ordem, em outras palavras,
efetua sua ordenação completa ou parcial. As ordens mais usadas são a
numérica e a lexicográfica.
RAZÕES

• Existem várias razões para se ordenar uma sequência. Uma delas é a

possibilidade se acessar seus dados de modo mais eficiente.
• • A ordenação visa facilitar a recuperação posterior de itens do conjunto
ordenado.
OS MÉTODOS DE ORDENAÇÃO SE CLASSIFICAM EM:
• Ordenação Interna: onde todos os elementos a serem ordenados cabem na
memória principal e qualquer registro pode ser imediatamente acessado.
• Ordenação Externa: onde os elementos a serem ordenados não cabem na
memória principal e os registros são acessados sequencialmente ou em
grandes blocos. necessitam de armazenamento em memória auxiliar como
por exemplo o disco HD.
DENTRO DA ORDENAÇÃO INTERNA TEMOS:

• Métodos simples:
• Adequados para pequenos arquivos.
• Requerem O(n2) comparações.
• Produzem programas pequenos.
• Insertion sort, – Inserção
• Selection sort, Seleção
• Bubble sort, Bolha
• Comb sort,
CLASSIFICAÇÃO DOS MÉTODOS DE ORDENAÇÃO
INTERNA
• Métodos eficientes: ou sofisticados

• Adequados para arquivos maiores.

• Requerem O(n log n) comparações.
• Usam menos comparações.
• As comparações são mais complexas nos detalhes.
• Métodos simples são mais eficientes para pequenos arquivos.

• Merge sort, Heapsort, Shell sort, Radix sort, Gnome sort, Counting sort, Bucket sort,
Cocktail sort, Timsort, Quick sort
MÉTODOS SIMPLES

• Os métodos simples são adequados para pequenos vetores, são programas

pequenos e fáceis de entender. Possuem complexidade C(n) = O(n²), ou seja,
requerem O(n²) comparações. Exemplos: Insertion Sort, Selection Sort, Bubble Sort,
Comb Sort.
• Nos algoritmos de ordenação as medidas de complexidade relevantes são:
• Número de comparações C(n) entre chaves.
• Número de movimentações M(n) dos registros dos vetores.
• Onde n é o número de registros.
INSERTION SORT - INSERÇÃO

• Insertion Sort ou ordenação por inserção é o método que percorre um vetor de

elementos da esquerda para a direita e à medida que avança vai ordenando os
elementos à esquerda. Possui complexidade C(n) = O(n) no melhor caso e C(n) =
O(n²) no caso médio e pior caso. É considerado um método de ordenação estável.
• Um método de ordenação é estável se a ordem relativa dos itens iguais não se
altera durante a ordenação.
• O funcionamento do algoritmo é bem simples: consiste em cada passo a partir do
segundo elemento selecionar o próximo item da sequência e colocá-lo no local
apropriado de acordo com o critério de ordenação.
INSERTION SORT - INSERÇÃO
void insercao (int vet, int tam){
int i, j, x;
for (i=2; i<=tam; i++){
x = vet[i];
j=i-1;
vet[0] = x;
while (x < vet[j]){
vet[j+1] = vet[j];
j--;
}
vet[j+1] = x;
}

(Imagens: Wikipedia.org)
SELECTION SORT - SELEÇÃO

• A ordenação por seleção ou selection sort consiste em selecionar o menor item

e colocar na primeira posição, selecionar o segundo menor item e colocar na
segunda posição, segue estes passos até que reste um único elemento. Para
todos os casos (melhor, médio e pior caso) possui complexidade C(n) = O(n²)
e não é um algoritmo estável.
SELECTION SORT - SELEÇÃO
void selecao (int vet, int tam){
int i, j, min, x;
for (i=1; i<=n-1; i++){
min = i;
for (j=i+1; j<=n; j++){
if (vet[j] < vet[min])
min = j;
}
x = vet[min];
vet[min] = vet[i];
vet[i] = x;
}
}
BUBBLE SORT - BOLHA

• A idéia da ordenação por bolhas é flutuar o maior elemento para o fim.

• Repita n vezes a flutuação.

(Imagens: reddit.com)
BUBBLE SORT - BOLHA

1 void BubbleSort(int∗ v, int n) { //n é tamanho do vetor

2 int i, fim, aux;

3 for (fim = n−1; fim > 0; −−fim) {

4 for (i = 0; i < fim; ++i) {

5 if (v[i] > v[i+1]) {

6 aux = v[i];

7 v[i] = v[i+1];

8 v[i+1] = aux;

9}

10 }

11 }

12 }
MARGE SORT

• Criado em 1945 pelo matemático americano John Von Neumann o Mergesort é um exemplo de algoritmo de
ordenação que faz uso da estratégia “dividir para conquistar” para resolver problemas. É um método estável
e possui complexidade C(n) = O(n log n) para todos os casos.

• Esse algoritmo divide o problema em pedaços menores, resolve cada pedaço e depois junta (merge) os
resultados. O vetor será dividido em duas partes iguais, que serão cada uma divididas em duas partes, e
assim até ficar um ou dois elementos cuja ordenação é trivial.

• Para juntar as partes ordenadas os dois elementos de cada parte são separados e o menor deles é
selecionado e retirado de sua parte. Em seguida os menores entre os restantes são comparados e assim se
prossegue até juntar as partes.
void mergeSort(int *vetor, int posicaoInicio, int if (i == metadeTamanho + 1 ) { else {
posicaoFim) {
vetorTemp[k] = vetor[j]; vetorTemp[k] = vetor[j];
int i, j, k, metadeTamanho, *vetorTemp;
j++; j++;
if(posicaoInicio == posicaoFim) return;
k++; k++;
metadeTamanho = (posicaoInicio + posicaoFim
) / 2; } }
else { }

mergeSort(vetor, posicaoInicio, if (j == posicaoFim + 1) { }

metadeTamanho); vetorTemp[k] = vetor[i];
mergeSort(vetor, metadeTamanho + 1, i++; }
posicaoFim);
k++; for(i = posicaoInicio; i <= posicaoFim; i++) {
} vetor[i] = vetorTemp[i - posicaoInicio];
i = posicaoInicio;
else { }
j = metadeTamanho + 1;
if (vetor[i] < vetor[j]) { free(vetorTemp);
k = 0;
vetorTemp[k] = vetor[i]; }
vetorTemp = (int *) malloc(sizeof(int) *
(posicaoFim - posicaoInicio + 1)); i++;
k++;

while(i < metadeTamanho + 1 || j < }

posicaoFim + 1) {
SHELL SORT

• Criado por Donald Shell em 1959, o método Shell Sort é uma extensão do
algoritmo de ordenação por inserção. Ele permite a troca de registros
distantes um do outro, diferente do algoritmo de ordenação por inserção que
possui a troca de itens adjacentes para determinar o ponto de inserção. A
complexidade do algoritmo é desconhecida, ninguém ainda foi capaz de
encontrar uma fórmula fechada para sua função de complexidade e o
método não é estável.
SHELL SORT

• Os itens separados de h posições (itens distantes) são ordenados: o elemento na posição x é comparado e
trocado (caso satisfaça a condição de ordenação) com o elemento na posição x-h. Este processo repete até
h=1, quando esta condição é satisfeita o algoritmo é equivalente ao método de inserção.
• A escolha do salto h pode ser qualquer sequência terminando com h=1. Um exemplo é a sequencia abaixo:
• h(s) = 1, para s = 1
• h(s) = 3h(s - 1) + 1, para s > 1
• A sequência corresponde a 1, 4, 13, 40, 121, …
• Knuth (1973) mostrou experimentalmente que esta sequencia é difícil de ser batida por mais de 20% em
eficiência.
SHELL SORT
• void shellSort(int *vet, int size) {
• int i , j , value;
• int gap = 1;
• while(gap < size) {
• gap = 3*gap+1;
• }
• while ( gap > 1) {
• gap /= 3;
• for(i = gap; i < size; i++) {
• value = vet[i];
• j = i - gap;
• while (j >= 0 && value < vet[j]) {
• vet [j + gap] = vet[j];
• j -= gap;
• }
• vet [j + gap] = value;
• }
• }
• }
QUICK SORT
• O Algoritmo Quicksort, criado por C. A. R. Hoare em 1960, é o método de ordenação
interna mais rápido que se conhece para uma ampla variedade de situações.
• Provavelmente é o mais utilizado. Possui complexidade C(n) = O(n²) no pior caso e C(n) =
O(n log n) no melhor e médio caso e não é um algoritmo estável.
• É um algoritmo de comparação que emprega a estratégia de “divisão e conquista”. A ideia
básica é dividir o problema de ordenar um conjunto com n itens em dois problemas menores.
Os problemas menores são ordenados independentemente e os resultados são combinados
para produzir a solução final.
• Basicamente a operação do algoritmo pode ser resumida na seguinte estratégia: divide sua
lista de entrada em duas sub-listas a partir de um pivô, para em seguida realizar o mesmo
procedimento nas duas listas menores até uma lista unitária.
QUICK SORT

• Funcionamento do algoritmo:
• Escolhe um elemento da lista chamado pivô.
• Reorganiza a lista de forma que os elementos menores que o pivô fiquem de
um lado, e os maiores fiquem de outro. Esta operação é chamada de
“particionamento”.
• Recursivamente ordena a sub-lista abaixo e acima do pivô.
 ALGORITMO EM C
void quick(int vet[], int esq, int dir){ pivo++;
int pivo = esq, i,ch,j; }
for(i=esq+1;i<=dir;i++){ }
j = i; if(pivo-1 >= esq){
if(vet[j] < vet[pivo]){ quick(vet,esq,pivo-1);
ch = vet[j]; }
while(j > pivo){ if(pivo+1 <= dir){
vet[j] = vet[j-1]; quick(vet,pivo+1,dir);
j--; }
} }
vet[j] = ch;
CONCLUSÃO

• Neste artigo foi apresentado os principais métodos de ordenação com foco

no conceito e funcionamento de cada um deles.
VOCÊ PODE VER NA TABELA ABAIXO A COMPARAÇÃO
ENTRE ELES:

(Imagem: DECOM – UFOP)

 COMPARAÇÃO ENTRE OS MÉTODOS: TEMPO DE
EXECUÇÃO
• Observação: O método que levou menos tempo real para executar recebeu o
valor 1 e os outros receberam valores relativos a ele.
 OBSERVAÇÕES SOBRE OS MÉTODOS
1. Shellsort, Quicksort e Heapsort têm a mesma Heapsort é mais rápido que o
ordem de grandeza.
Shellsort.
2. O Quicksort é o mais rápido para todos os
7. O Inserção é o mais rápido para qualquer
tamanhos aleatórios experimentados.
tamanho se os elementos estão
3. A relação Heapsort/Quicksort se mantém
ordenados.
constante para todos os tamanhos.
8. O Inserção é o mais lento para qualquer
4. A relação Shellsort/Quicksort aumenta à
tamanho se os elementos estão
medida que o número de elementos aumenta.
em ordem descendente.
5. Para arquivos pequenos (500 elementos), o
Shellsort é mais rápido que o 9. Entre os algoritmos de custo O(n
Heapsort. 2), o Inserção é melhor para todos os
6. Quando o tamanho da entrada cresce, o tamanhos aleatórios experimentados.
 REFERÊNCIAS
• CORMEN, T. H.; LEISERSON, C. E.; RIVEST, R. L. e STEIN, C. Introduction to Algorithms,
3a edição, MIT Press, 2009.
• ZIVIANI, N. Projeto de Algoritmos: com implementações em Pascal e C, 2a edição,
Cengage Learning, 2009.
• QuickSort <http://www.knoow.net/ciencinformtelec/informatica/quicksort.htm>
• Acesso em: 05/03/2019.
• GnomeSort <http://rosettacode.org/wiki/Sorting_algorithms/Gnome_sort Acesso
• em: 05/03/2019.
• Estudo de métodos de ordenação <http://nicholasandre.com.br/sorting> Acesso
• em: 05/03/2019.