CENTRO UNIVERSITÁRIO UNIVESC

CURSO DE CIÊNCIA DA COMPUTAÇÃO

JOÃO MOTA

MÉTODOS ORDENAÇÃO

LAGES
2010
Seleção
Ordenação por seleção é um algoritmo de ordenação baseado em se passar
sempre o menor valor do vetor para a primeira posição (ou o maior dependendo da
ordem requerida), depois o de segundo menor valor para a segunda posição, e assim é
feito sucessivamente com os (n-1) elementos restantes, até os últimos dois elementos.
Inserção
Ordenação por inserção é um simples algoritmo de ordenação, eficiente quando
aplicado a um pequeno número de elementos. Em termos gerais, ele percorre um vetor
de elementos da esquerda para a direita e à medida que avança vai deixando os
elementos mais à esquerda ordenados. O algoritmo de inserção funciona da mesma
maneira com que muitas pessoas ordenam cartas em um jogo de baralho como o pôquer.
QuickSort

O Quick Sort é um dos métodos mais rápidos de ordenação, apesar de às vezes

partições desequilibradas poderem conduzir a uma ordenação lenta. Esse método de
ordenação utiliza a técnica divide and conquer (dividir o problema inicial em dois
subproblemas e resolver um problema menor utilizando a recursividade).

ShellSort
ShellSort é o mais eficiente algoritmo de classificação dentre os de
complexidade quadrática. É um refinamento do método de inserção direta. O algoritmo
difere do método de inserção direta pelo fato de no lugar de considerar o array a ser
ordenado como um único segmento, ele considera vários segmentos sendo aplicado o
método de inserção direta em cada um deles. Basicamente o algoritmo passa várias
vezes pela lista dividindo o grupo maior em menores. Nos grupos menores é aplicado o
método da ordenação por inserção.
Tabela comparação tempo:

Para um vetor de dez mil itens gerado com valores randômicos entre zero e
cinquenta mil, os seguintes métodos de organização levaram certo tempo conforme a
tabela seguinte.

Método Ordenação Tempo

Seleção 0.293000 Segundos
Inserção 0.184000 Segundos
QuickSort 0.003000 Segundos
ShellSort 0.002000 Segundos

Conclusão

Em um vetor com dez mil elementos gerados randomicamente os métodos de

ordenação QuickSort e ShellSort tiveram uma boa vantagem para organizar o vetor em relação
a outros métodos mais simples como o método de Seleção e Inserção.
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#include <windows.h>
#include <time.h>

int vini[10000];
double t_selecao, t_insercao, t_shell, t_quick;
void quickSort( int[], int, int);
int dividir( int[], int, int);

void quickSort( int a[], int l, int r)

{
int j;

if( l < r )
{
j = dividir( a, l, r);
quickSort( a, l, j-1);
quickSort( a, j+1, r);
}

int dividir( int a[], int l, int r) {

int pivo, i, j, t;
pivo = a[l];
i = l; j = r+1;

while( 1)
{
do ++i; while( a[i] <= pivo && i <= r );
do --j; while( a[j] > pivo );
if( i >= j ) break;
t = a[i]; a[i] = a[j]; a[j] = t;
}
t = a[l]; a[l] = a[j]; a[j] = t;
return j;
}

void insercao(int n, int v[]){

int i, j, x;
for (j = 1; j < n; j++){
x = v[j];
for (i = j - 1; i >= 0 && v[i] > x; i--){
v[i + 1] = v[i];
}
v[i + 1] = x;
 }
}
void selecao(int n, int v[]){
int i, j, min, x;
for (i = 0; i < n - 1; i++){
min = i;

for (j = i + 1; j < n; j++){

if (v[j] < v[min]) min = j;
}

x = v[i];
v[i] = v[min];
v[min] = x;
}
}
void shellsort(int * v, int n) {
int i , j , value;
int gap = 1;
do {
gap = 3*gap+1;
} while(gap < n);
do {
gap /= 3;
for(i = gap; i < n; i++) {
value =v[i];
j = i - gap;
while (j >= 0 && value < v[j]) {
v [j + gap] =v[j];
j -= gap;
}
v [j + gap] = value;
}
} while ( gap > 1);
}

void geravetor(){
int vet[10000];
int i,j;
for (int i=0; i<10000; i++){
vet[i] = rand () % 50000;
vini[i] = vet[i];
}
}

int main(){
int escolha=1;
while (escolha!=8){
printf("\n\n --------------------------- ");
printf("\n\n 4a.Fase / Joao Mota ");
 printf("\n\n");
printf("\n 1 - Gerar Vetor ");
printf("\n 2 - Mostrar Vetor ");
printf("\n 3 - Ordenar Por Selecao ");
printf("\n 4 - Ordenar Por Insercao ");
printf("\n 5 - Ordenar Por ShellSort ");
printf("\n 6 - Ordenar Por QuickSort ");
printf("\n 7 - Tabela Tempo ");
printf("\n 8 - Fechar Programa ");
printf("\n\n Escolha uma opcao: ");
scanf("%d",&escolha);
switch (escolha) {
case 1:{
system("cls");
geravetor();
printf("\n\n Vetor Gerado com Sucesso! ");
break;
}
case 2:{
system("cls");
int i;
for (i = 0; i < 10000; i++){
printf("%d ", vini[i]);
}
break;
}
case 3:{
system("cls");
clock_t t0, tf;
int ordsele[10000];
int i;
for (i=0; i<10000; i++){
ordsele[i]=vini[i];
}
t0 = clock();
selecao(10000, ordsele);
tf = clock();
t_selecao = ((double)(tf-t0))/CLOCKS_PER_SEC;
for (i=0; i<10000; i++){
printf("%d ", ordsele[i]);
}
printf("\n\n Tempo gasto: %lf s\n", t_selecao);
break;
}
case 4:{
system("cls");
clock_t t0, tf;
int ordinse[10000];
int i;
for (i=0; i<10000; i++){
 ordinse[i]=vini[i];
}
t0 = clock();
insercao(10000, ordinse);
tf = clock();
t_insercao = ((double)(tf-t0))/CLOCKS_PER_SEC;
for (i=0; i<10000; i++){
printf("%d ", ordinse[i]);
}
printf("\n\n Tempo gasto: %lf s\n", t_insercao);
break;
}
case 5:{
system("cls");
clock_t t0, tf;
int ordshell[10000];
int i;
for (i=0; i<10000; i++){
ordshell[i]=vini[i];
}
t0 = clock();
shellsort(ordshell, 10000);
tf = clock();
t_shell = ((double)(tf-t0))/CLOCKS_PER_SEC;
for (i=0; i<10000; i++){
printf("%d ",ordshell[i]);
}
printf("\n\n Tempo gasto: %lf s\n", t_shell);
break;
}
case 6:{
system("cls");
clock_t t0, tf;
int ordquick[10000];
int i;
for (i=0; i<10000; i++){
ordquick[i]=vini[i];
}
t0 = clock();
quickSort( ordquick, 0, 10000);
tf = clock();
t_quick = ((double)(tf-t0))/CLOCKS_PER_SEC;
for (i=0; i<10000; i++){
printf("%d ",ordquick[i]);
}
printf("\n\n Tempo gasto: %lf s\n", t_quick);
break;
}
case 7:{
system("cls");
 printf("\n\n Tabela tempo gasto");
printf("\n\n Ordenacao - Tempo");
printf("\n\n");
printf("\n 1-Selecao - %lf s",t_selecao);
printf("\n 2-Insercao - %lf s",t_insercao);
printf("\n 3-ShellSort - %lf s",t_shell);
printf("\n 4-QuickSort - %lf s",t_quick);
break;
}
default:{
system("cls");
if( escolha==8){
continue;
}
printf("\n\n Nenhuma opcao foi escolhida ");
break;
}
}
}
if( escolha==8)
printf("\n\n O Programa foi fechado");
getch();