Introduo

Este trabalho se refere-se ao esclarecimento de como fazer uma classificao e

pesquisa usando estrutura de dados em C. Veremos como funciona 4 tipos de
pesquisa. Suas utilidades e para que servem dentro da programao em C.

1. Mtodos de Ordenao e Busca

1.1.

Selection Sort

Caractersticas:
Neste processo de ordenao percorre-se um conjunto inteiro de elementos, atravs do
mtodo mais simples possvel, a procura do maior ou menor elemento do conjunto. Aps encontrlo esse elemento movido para sua devida posio, e o processo se inicia novamente at que
todos os elementos do conjunto estejam ordenados.
Complexidade:

Pior Caso:
n
n
Melhor Caso:
n
Caso Mdio:
Onde n corresponde ao nmero de elementos do conjunto.

1.2.

Insertion Sort

Caractersticas:
Neste processo de ordenao consiste em ordenar um conjunto de elementos, atravs de
um subconjunto no incio do conjunto, e em cada iterao, um novo elemento acrescentado a
esse subconjunto, esse processo repetido at o ltimo elemento do conjunto esteja ordenado.
Complexidade:

Pior Caso:
n
Melhor Caso:
n
Caso Mdio:
n
Onde n corresponde ao nmero de elementos do conjunto.

1.3.

Shell Sort

Caractersticas:
Considerado uma extenso do mtodo insertion sort, consiste em ordenar os elementos do
conjunto atravs de trocas de elementos distantes uns dos outros.
Complexidade:

Pior Caso:
n
Melhor Caso:
Depende da Sequncia do gap
Caso Mdio:
Onde n corresponde ao nmero de elementos do conjunto.

1.4.

Quick Sort:

Caractersticas:
Neste processo o conjunto de elementos dividido em dois subconjuntos, que so
ordenados independentemente, e posteriormente so unidos novamente formando o conjunto inicial
j ordenado.
Complexidade:
Pior Caso:
n
Melhor Caso:
Caso Mdio:
Onde n corresponde ao nmero de elementos do conjunto.

1.5.

Cdigo Fonte

#include <stdio.h>
#include <stdlib.h>
#include <cstring>

struct Residencia{
char rua[25];
int numCasa;
int numMedidor;
int medidaConsumo;
}vetResidencias[1000];

int MM;

int RandomInteger (int low, int high){

int k;
double d;
d= (double) rand()/((double) RAND_MAX + 1);
k = d * (high - low +1);
return low + k;
}

void exibir(struct Residencia *Res){

int i;
for (i=0;i<=999;i++){
printf("\n-------------------------");
printf("\n|Rua %s

|",Res[i].rua);

printf("\n|Numero %d

|",Res[i].numCasa);

printf("\n|Medidor %d

|",Res[i].numMedidor);

printf("\n|Medida de consumo %d |",Res[i].medidaConsumo);

printf("\n------------------------");
}
}

void swap(struct Residencia* i, struct Residencia* j)

{
struct Residencia t;
t = *i;
*i = *j;
*j = t;
}

void quick(struct Residencia *item, int e, int d) {

if(d <= e)

return;
int p;
p = (item, e, d);
quick(item, e, p-1);
quick(item, p+1, d);
}

int p(struct Residencia *item, int e, int d) {

int i = e; int j = d;
struct Residencia pivo = item[(d+e)/2];
while(1) {
if (MM==0){
while(item[i].medidaConsumo < pivo.medidaConsumo)
i++;
while(pivo.medidaConsumo < item[j].medidaConsumo)
j--;}
else{
while(item[i].medidaConsumo > pivo.medidaConsumo)
i++;
while(pivo.medidaConsumo > item[j].medidaConsumo)
j--;}
if(i >= j) break;
swap(&item[i], &item[j]);
i++;
j--;
}
swap(&item[i], &item[d]);
return i;
}

void select(struct Residencia *item, int count) {

int i,j,i_menor;
struct Residencia min;
for(i=0;i<count-1;i++) {
i_menor = i;
for(j=i+1;j<count;j++)
if (MM==0){
if(item[j].medidaConsumo < item[i_menor].medidaConsumo)
i_menor = j;
swap(&item[i],&item[i_menor]);}
else{
if(item[j].medidaConsumo > item[i_menor].medidaConsumo)
i_menor = j;
swap(&item[i],&item[i_menor]);
}
}
}

void insert(struct Residencia *item, int count){

int i,j;
struct Residencia aux;
for(i=1;i<count;i++){
aux = item[i];
if (MM==0){
for(j=i-1;(j>=0)&&(aux.medidaConsumo<item[j].medidaConsumo);j--)
item[j+1] = item[j];
item[j+1] = aux;}
else{

for(j=i-1;(j>=0)&&(aux.medidaConsumo>item[j].medidaConsumo);j--)
item[j+1] = item[j];
item[j+1] = aux;
}
}
}

void shell(struct Residencia *item, int count) {

int i, j, h;
struct Residencia aux;
for(h = 1; h < count; h = 3*h+1);
while(h > 0) {
h = (h-1)/3;
for(i = h; i < count; i++) {
aux = item[i];
j = i;
if (MM==0){
while(item[j-h].medidaConsumo > aux.medidaConsumo) {
item[j] = item[j-h];
j -= h;
if(j < h) break;
}
}
else {
while(item[j-h].medidaConsumo < aux.medidaConsumo) {
item[j] = item[j-h];
j -= h;
if(j < h) break;
}

}
item[j] = aux;
}
}
}

int sequencial(struct Residencia *item, int count, int chave)

{
register int t;
for(t=0;t<count;++t)
if(chave==item[t].numMedidor){
return t;}
return -1;
}

int binaria(struct Residencia *item, int count, int chave)

{
int esq, dir, meio;
esq=0;
dir=count-1;
while (esq<=dir)
{
meio=(esq + dir) / 2;
if (chave == item[meio].numMedidor)
return meio;
else if(chave<item[meio].numMedidor)
dir=meio-1;
else
esq=meio+1;

}
return -1;
}

int main(int argc, char** argv) {

int i;
int achous,achoub, busca,op;
for (i=0;i<=999;i++)
{
strcpy(vetResidencias[i].rua, "Augusta");
vetResidencias[i].numCasa=i;
vetResidencias[i].numMedidor = RandomInteger(1,2000);
vetResidencias[i].medidaConsumo = RandomInteger(1,2000);
}
printf("\n\t\t\xc9\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xc
d\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xbb");
printf("\n\t\t\xba\t\SmartXY XXI Informatica

\xba");

printf("\n\t\t\xc8\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xc
d\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xbc");
printf("\n");
printf("\n\xc9\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\
xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\x
cd\xcd\xbb");
printf("\n\xba\ Deseja ordenar os elementos em:
printf("\n\xba\ 0 - Ordem Crescente
printf("\n\xba\ 1 - Ordem Decrescente

\xba");
\xba");
\xba");

printf("\n\xc8\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\
xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\x
cd\xcd\xbc");
printf("\n\n");
printf("\nDigite a opcao desejada: ");

scanf("%d",&MM);
exibir (vetResidencias);
printf("\n\nDigite o numero do medidor: ");
scanf("%d",&busca);
achous=sequencial(vetResidencias,1000,busca);
if(achous!=-1)
printf("\nNumero do medidor encontrado atraves da pesquisa sequencial na posicao: %d \n\n",
achous);
else
printf("\nNumero do medidor nao encontrado!\n");
printf("\n\t\t\xc9\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xc
d\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd
\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xbb");
printf("\n\t\t\xba\t\ Escolha uma das formas de ordenacoes abaixo: \xba");
printf("\n\t\t\xba 1 - SelectionSort

\xba");

printf("\n\t\t\xba 2 - InsertionSort

\xba");

printf("\n\t\t\xba 3 - ShellSort
printf("\n\t\t\xba 4 - QuickSort

\xba");
\xba");

printf("\n\t\t\xc8\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xc
d\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd
\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xbc");
printf("\n\nDigite a opcao desejada: ");
scanf("%d",&op);
switch(op){

case 1: select(vetResidencias,1000);
break;

case 2: insert(vetResidencias,1000);
break;

case 3: shell(vetResidencias,1000);
break;

case 4: quick(vetResidencias,0,(1000-1));
break;

default: printf("Opcao invalida");

break;
}
achoub=binaria(vetResidencias,1000,busca);
if(achoub!=-1)
printf("Numero do medidor encontrado atraves da busca binaria na posicao: %d\n", achoub);
else
printf("Numero do medidor nao encontrado!\n");
exibir(vetResidencias);
return (EXIT_SUCCESS);
}

2. Resultados
Para a realizao dos testes para terminar o tempo de execuo a funo exibir() foi eliminada para
permitir a determinao dos valores com maior exatido. Todos os testes foram realizados no
mesmo computador.

Ordem Crescente
Mtodo
Tempo (s)
Selection Sort
5,954
Insertion Sort
6,458
Shell Sort
5,144
Quick Sort
3,945
Ordem Decrescente
Mtodo
Tempo (s)
Selection Sort
5,096
Insertion Sort
5,911
Shell Sort
5,389
Quick Sort
3,690

3. Concluso
O mtodo Quick Sort se mostrou mais eficiente e melhor desempenho na ordenao
dos elementos aleatrios. Por esse motivo o mtodo Quick Sort o mtodo
recomendado para a empresa Smart XY XXI Informtica.

Referncias Bibliogrficas
1. JUNIOR, J. M. R. S. Apostila de Algoritmo Estruturado. Disponvel
<https://docs.google.com/open?id=0Bx2ZnHfyWt9Qd3doSl81Rk01MDQ>.

em:

2. Aulas temas de Classificao e Pesquisa de dados com o Prof. Msc.

Thiago Salhab Alves da Faculdade Anhanguera de Santa Brbara
dOeste.