Modelos de Ordenação: bubble sort, insertion sort, selection

sort, merge sort e quick sort.

BUBBLE SORT

O método de ordenação por bubble sort ou conhecido como bolha consiste em

compara dados armazenados em um vetor de tamanho qualquer, comparando cada
elemento de uma posição com o próximo elemento do vetor.

https://www.youtube.com/watch?v=lyZQPjUT5B4

A ordenação pode ser crescente ou decrescente basta trocar a ordem de comparação. Um laço
com a quantidade de elementos do vetor será executado (for(j=1;j<=n;j++)), e dentro deste, outro
laço que percorre da primeira à penúltima posição do (for(i=0;i<n−1;i++)).

Abaixo é mostrador o processo de ordenação bubble sort:

Exemplos da implementação do algoritmo em C ANIS:

#include <stdio.h>

int main(void) {

int x[5];
int n, i, aux;
for (i = 0; i <= 4; i++) {
printf("Digite o %i numero: ",i+1);
 scanf("%i,",&x[i]);
fflush(stdin);
}

for (n = 1; n <= 5; n++) {

for (i = 0; i <= 3; i++) {
if (x[i] > x[i + 1]) {
aux = x[i];
x[i] = x[i + 1];
x[i + 1] = aux;
}
}
}
printf("\n\nEm ordem:\n\n");

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

printf("%i numero: %i\n",i+1,x[i]);
}
return 0;

BUBBLE SORT melhorado (1ª versão)

Abaixo é mostrador o processo de ordenação bubble sort melhorado:

Exemplos da implementação do algoritmo em C ANSIa:

#include <stdio.h>

int main(void) {

int x[5];
int n, i, j, aux;
for (i = 0; i <= 4; i++) {
printf("Digite o %i numero: ",i+1);
scanf("%i,",&x[i]);
fflush(stdin);
}

for (j = 1; j <= 4; j++) {

for (i = 4; i >= j; i--) {
 if (x[i] < x[i - 1]) {
aux = x[i];
x[i] = x[i - 1];
x[i - 1] = aux;
}
}
}

printf("\n\nEm ordem:\n\n");
for (i = 0; i <= 4; i++) {
printf("%i numero: %i\n",i+1,x[i]);
}
return 0;
}

BUBBLE SORT melhorado (2ª versão)

Abaixo é mostrador o processo de ordenação bubble sort melhorado:

Exemplos da implementação do algoritmo em C ANSI:

#include <stdio.h>

int main(void) {

int x[5];
int n, i, j, aux, troca;
for (i = 0; i <= 4; i++) {
printf("Digite o %i numero: ",i+1);
scanf("%i,",&x[i]);
fflush(stdin);
}

n = 1;
troca = 1;

while (n <= 5 && troca == 1) {

troca = 0;
for (i = 0; i <= 3; i++) {
if (x[i] > x[i + 1]) {
troca = 1;
aux = x[i];
x[i] = x[i + 1];
x[i + 1] = aux;
}
}
n = n + 1;
 }

printf("\n\nEm ordem:\n\n");
for (i = 0; i <= 4; i++) {
printf("%i numero: %i\n",i+1,x[i]);
}
return 0;
}

Exercício:

1. Faça um programa que cadastre o nome e o salário de 10 funcionário, liste todos

os dados dos funcionários das seguintes formas:

a) em ordem crescente de salário;

b) em ordem decrescente de salário;
c) em ordem alfabética;

INSERTION SORT

Este método de ordenação por inserção se baseia na comparação do segundo número

inserido no vetor, os elementos são ordenados de forma crescente ou decrescente
dependendo da forma que o algoritmo é implementado.

https://www.youtube.com/watch?v=ROalU379l3U

Um laço com as comparações será executado do segundo elemento ao último, na

quantidade de vezes igual ao número de elementos do vetor menos um
(for(i=1;i<n;i++)), enquanto existirem elementos à esquerda do número e a posição
que atende a ordenação não for encontrada, o laço será executado.

Abaixo é mostrador o processo de ordenação insertion sort:

Exemplos da implementação do algoritmo em C ANSI:

#include <stdio.h>

int main(void) {

int x[5];
int i, j, eleito;
for (i = 0; i <= 4; i++) {
printf("Digite o %i numero: ",i+1);
scanf("%i,",&x[i]);
fflush(stdin);
}

for (i = 1; i <= 4; i++) {

eleito = x[i];
j = i - 1;
while (j >= 0 && x[j] > eleito) {
x[j + 1] = x[j];
j = j - 1;
}
x[j + 1] = eleito;
}

printf("\n\nEm ordem:\n\n");
for (i = 0; i <= 4; i++) {
printf("%i numero: %i\n",i+1,x[i]);
}
 return 0;
}

SELECTION SORT

Já neste método cada número do vetor, a partir do primeiro, é eleito e comparado

com o menor ou maior, dependendo da ordenação desejada, número dentre os que
estão à direita do eleito. Procura-se um número menor (quando crescente) ou um
maior (quando decrescente).

https://www.youtube.com/watch?v=LriMvv9qDrk

O número eleito está na posição i. Os números à direita estão nas posições de i+1 a n–1, sendo
n o número de elementos do vetor. O laço a ser executado para encontrar o menor elemento à
direita do eleito será (for(j=i+2;j<=n−1;j++)).

Abaixo é mostrador o processo de ordenação selection sort:

Exemplos da implementação do algoritmo em C ANSI:

#include <stdio.h>

int main(void) {

int x[5];
int i, j, eleito, menor, pos;
for (i = 0; i <= 4; i++) {
printf("Digite o %i numero: ",i+1);
scanf("%i,",&x[i]);
fflush(stdin);
}

for (i = 0; i <= 3; i++) {

eleito = x[i];
menor = x[i + 1];
pos = i + 1;
for (j = i + 2; j <= 4; j++) {
if (x[j] < menor) {
menor = x[j];
pos = j;
}
}
if (menor < eleito) {
 x[i] = x[pos];
x[pos] = eleito;
}
}

printf("\n\nEm ordem:\n\n");
for (i = 0; i <= 4; i++) {
printf("%i numero: %i\n",i+1,x[i]);
}
return 0;
}

Exercício:

2. Faça um programa que cadastre 15 números inteiros, ordene-os usando o método

insertion sort e em seguida encontre o menor número e quantas vezes ele apareceu
no vetor.
R.:

3. Faça um programa que cadastre 10 números reais, ordene-os usando o método

selection sort e em seguida encontre o maior número e quantas vezes ele apareceu
no vetor.
R.:

MERGE SORT

O vetor é dividido em vetores com a metade do tamanho do original por um

procedimento recursivo, até que o vetor fique com apenas um elemento e estes
sejam ordenados e intercalados.

http://www.youtube.com/watch?v=XaqR3G_NVoo

É aplicada a técnica da divisão e conquista.

● Dividir: dividir a sequência de n em duas subsequências de n/2 elementos

cada.
● Conquistar: ordenar as duas subsequências recursivamente utilizando a
ordenação por intercalação.
● Combinar: intercalar as duas subsequências ordenadas para produzir a
solução.

Abaixo é mostrador o processo de ordenação merge sort:

Exemplos da implementação do algoritmo em C ANSI:

#include <stdio.h>

void merge(int x[], int inicio, int fim) {

int meio;
if (inicio < fim) {
meio = (inicio + fim) / 2;
merge(x, inicio, meio);
merge(x, meio + 1, fim);
intercala(x, inicio, fim, meio);
}
}

void intercala(int x[], int inicio, int fim, int meio) {

int poslivre = inicio, iniciovetor1 = inicio, iniciovetor2 = meio + 1, i;
int aux[5];
while (iniciovetor1 <= meio && iniciovetor2 <= fim) {
if (x[iniciovetor1] <= x[iniciovetor2]) {
aux[poslivre] = x[iniciovetor1];
iniciovetor1++;
} else {
aux[poslivre] = x[iniciovetor2];
iniciovetor2++;
}
poslivre++;
}
for (i = iniciovetor1; i <= meio; i++) {
aux[poslivre] = x[i];
poslivre++;
}
for (i = iniciovetor2; i <= fim; i++) {
aux[poslivre] = x[i];
poslivre++;
}
for (i = inicio; i <= fim; i++) {
x[i] = aux[i];
}
}
int main(void) {

int x[5];
int i, j, eleito, menor, pos;
for (i = 0; i <= 4; i++) {
printf("Digite o %i numero: ",i+1);
scanf("%i,",&x[i]);
fflush(stdin);
}

merge(x, 0, 4);

printf("\n\nEm ordem:\n\n");
for (i = 0; i <= 4; i++) {
printf("%i numero: %i\n",i+1,x[i]);
}
return 0;
}

Exercício:

4. Faça um programa que cadastre 20 palavras em um vetor, ordene-os usando o

método merge sort, em seguida encontre as palavras que começam vogais e mostre
quais são elas.
R.:

QUICK SORT

O vetor é particionado por meio de um procedimento recursivo até que o vetor fique
com apenas um elemento, enquanto os demais ficam ordenados à medida que ocorre
o particionamento.

http://www.youtube.com/watch?v=ywWBy6J5gz8

A técnica é baseada na divisão e conquista, descrita a seguir:

● Dividir: o vetor X[p..r] é particionado em dois subvetores não vazios X[p..q]

e X[q+1..r], tais que cada elemento de X[p..q] é menor ou igual a cada
elemento de X[q+1..r]. Para determinar o índice q, escolhe-se o elemento que
se encontra na metade do vetor original, chamado de pivô, e rearranjam-se
os elementos do vetor de forma que os da esquerda de q são menores (ou
iguais) e os da direita são maiores (ou iguais) ao pivô.
● Conquistar: os dois subvetores são ordenados X[p..q] e X[q+1..r] por
chamadas recursivas ao QUICK SORT.
● Combinar: os elementos vão sendo ordenados no próprio vetor, sem
processamento nesta etapa.

Abaixo é mostrador o processo de ordenação quick sort:

Exemplos da implementação do algoritmo em C ANSI:

#include <stdio.h>

void quicksort(int vet[], int ini, int fim) {

int meio;

if (ini < fim) {

meio = partition(vet, ini, fim);
quicksort(vet, ini, meio);
quicksort(vet, meio + 1, fim);
}
}

int partition(int vet[], int ini, int fim) {

int pivo, topo, i;
pivo = vet[ini];
topo = ini;

for (i = ini + 1; i <= fim; i++) {

if (vet[i] < pivo) {
vet[topo] = vet[i];
vet[i] = vet[topo + 1];
topo++;
}
}
vet[topo] = pivo;
return topo;
}

int main(void) {

int x[5];
int i, j, eleito, menor, pos;
for (i = 0; i <= 4; i++) {
printf("Digite o %i numero: ",i+1);
scanf("%i,",&x[i]);
fflush(stdin);
}

quicksort(x, 0, 4);
 printf("\n\nEm ordem:\n\n");
for (i = 0; i <= 4; i++) {
printf("%i numero: %i\n",i+1,x[i]);
}
return 0;
}

Exercícios:

5. Construa um programa que gere um vetor 1000 números aleatórios mostre os

números em tela e depois usando o método de ordenação quick sort ordene este
vetor.
R.:

6. Elabore um programa que gere uma combinação de duas letras em um vetor de

100 posições, usando o método de ordenação quick sort ordene este vetor de letras
e mostre na tela.
R.: