1

Contedo
Relatrio 1 Pesquisa de Dados. ...................................................
......................................... 2
Cdigo Fonte: ....................................................................
.................................................. 2
Relatrio 2: Mtodos de Ordenao ......................................................
................................. 6
Selection Sort: ................................................................
..................................................... 6
Insertion Sort: ................................................................
...................................................... 6
Shell Sort: ....................................................................
........................................................ 6
Quick Sort: ....................................................................
...................................................... 7
Cdigo Fonte: ....................................................................
.................................................. 7
Resultados: ....................................................................
........................................................ 11
Concluso: .......................................................................
..................................................... 12
2
Relatrio 1 Pesquisa de Dados.
Cdigo Fonte:
#include <stdio.h>
#include <stdlib.h>
struct Residencia{
char rua[25];
int numCasa;
int numMedidor;
int medidaConsumo;
}vetResidencias[1000];
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<=4;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-----------------------");
3
}
}

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

{
struct Residencia t;
t = *i;
*i = *j;
*j = t;
}
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(item[j].medidaConsumo < item[i_menor].medidaConsumo)
i_menor = j;
swap(&item[i],&item[i_menor]);
}
}
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;}
4
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;
for (i=0;i<=4;i++){
strcpy(vetResidencias[i].rua, "Augusta");
vetResidencias[i].numCasa=i;
vetResidencias[i].numMedidor = RandomInteger(1,2000);
5
vetResidencias[i].medidaConsumo = RandomInteger(1,2000);
}
exibir (vetResidencias);
printf("Digite o numero do medidor:");

scanf("%d",&busca);
achous=sequencial(vetResidencias,5,busca);
if(achous!=-1)
printf("Numero do medidor encontrado atraves da pesquisa sequencial na pos
icao: d\n",
achous); 95
else
printf("Numero do medidor nao encontrado!\n");
select(vetResidencias,5);
achoub=binaria(vetResidencias,5,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);
}
6
Relatrio 2: Mtodos de Ordenao
Selection Sort:
Caractersticas:
Neste processo
os,
atravs do mtodo
nto.
Aps encontr-lo
se inicia
novamente at que

de ordenao percorre-se o um conjunto inteiro de element

mais simples possvel, a procura do maior ou menor elemento do conju
esse elemento movido para sua devida posio, e o processo
todos os elementos do conjunto estejam ordenados.

Complexidade:
Pior Caso: n
Melhor Caso: n
Caso Mdio: n
Onde n corresponde ao nmero de elementos do conjunto.
Insertion Sort:
Caractersticas:
Neste processo de ordenao consiste em ordenar um conjunto de elementos
,
atravs de um subconjunto no inicio do conjunto, e em cada iterao, um n
ovo elemento
acrescentado a esse subconjunto, esse processo repetido at o ultimo elemento do c
onjunto
esteja ordenado.
Complexidade:
Pior Caso: n
Melhor Caso: n
Caso Mdio: n
Onde n corresponde ao nmero de elementos do conjunto.

Shell Sort:
Caractersticas:
Considerado uma extenso do mtodo insertion sort, consiste em ordenar o
s
elementos do conjunto atravs de trocas de elementos distantes uns dos outros.
Complexidade:
Pior Caso:
Melhor Caso: n
Caso Mdio: Depende da Sequncia do gap
Onde n corresponde ao nmero de elementos do conjunto.
7
Quick Sort:
Caractersticas:
Neste processo o conjunto de elementos dividido em dois subconjuntos, que
so ordenados independentemente, e posteriormente so unidos novamente forma
ndo o
conjunto inicial j ordenado.
Complexidade:
Pior Caso: n
Melhor Caso:
Caso Mdio:
Onde n corresponde ao nmero de elementos do conjunto.
Cdigo Fonte:
#include <stdio.h>
#include <stdlib.h>
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)
{
8
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 = particao(item, e, d);
quick(item, e, p-1);
quick(item, p+1, d);
}
int particao(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{
9

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;
}
}
10
}

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("Deseja ordenar os elementos em: \n");
printf("0 - Ordem Crescente \n 1 - Ordem Decrescente");
scanf("%d",&MM);
exibir (vetResidencias);
printf("Digite o numero do medidor:");
scanf("%d",&busca);
achous=sequencial(vetResidencias,1000,busca);
if(achous!=-1)
11
printf("Numero do medidor encontrado atraves da pesquisa sequencial na posic
ao:
%d\n", achous);
else
printf("Numero do medidor nao encontrado!\n");
printf("Escolha uma das formas de ordenacoes abaixo:\n ");
printf("1 - SelectionSort\n");
printf("2 - InsertionSort\n");
printf("3 - ShellSort\n");
printf("4 - QuickSort\n");
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);
}
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. T
odos os
testes foram realizados no mesmo computador.
12
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
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.