UNIVERSIDADE ESTADUAL DO MARANHO UEMA

CENTRO DE CINCIAS TECNOLGICAS CCT

DISCIPLINA: ESTRUTURAS DE DADOS AVANADOS
PROFESSOR: LUS CARLOS
ADRIANO CARVALHO DA COSTA COD: 1309137

RESOLUO DE ATIVIDADE

So Lus MA
2014

ATIVIDADE
1) Modifique o algoritmo Quicksort de forma a ele utilizar um outro mtodo de
ordenao simples para quando as colees ficarem menores (preferencialmente
insero).
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define MaxTam 1000000
#define MaxRand 1000
#define Max 10000
//Quando as colees so menores o Quick Sort utiliza um outro
mtodo de ordenao simples
void imprimir_lista();
typedef struct {
int chave;
}TItem;
TItem lista[MaxTam];
void iniciar_lista(){
// Inicializar o gerador de nmeros aleatrios Com time(NULL)
srand(time(NULL));
int i;
for (i = 0; i < MaxTam; i++){
lista[i].chave = rand() % MaxRand;
}
}
void preencher_lista()
{
int i;

for(i = 0;i < MaxTam;i++)

{
printf("\n%d%c elemento: ",i+1,167);
scanf("%d",&lista[i].chave);
}
}
void InsertionSort(int tam) {
int i, j;
TItem value;
for(i = 1; i < tam; ++i) {
value.chave = lista[i].chave;
for (j = i - 1; j >= 0 && lista[j].chave > value.chave; --j) {
lista[j + 1] = lista[j];
lista[j] = value;
}
}
}
void troca(int i,int j)
{
TItem aux;
aux = lista[i];
lista[i] = lista[j];
lista[j] = aux;
}
int particao(int p,int r)
{
TItem pivo;
int i,j;
pivo = lista[(p+r)/2];
//printf("numero do pivo: %d\n",pivo.chave);
i = p - 1;

j = r + 1;
while(i < j)
{
do
{
j = j - 1;
}while(lista[j].chave > pivo.chave);
do
{
i = i + 1;
}while(lista[i].chave < pivo.chave);
if (i < j)
troca(i,j);
}
return j;
}
void quicksort(int p,int r)
{
int q;
if(p < r)
{
q = particao(p,r);
quicksort(p,q);
quicksort(q+1,r);
}
if((r-p) < Max)
InsertionSort(r-p+1);
return;
}
void imprimir_lista(){

printf("****** Lista ********\n");

int i;
for (i = 0; i < MaxTam; i++)
printf("lista[%5d] = %5d\n", i + 1, lista[i].chave);
printf("****************\n");
}
void imprime_tempo(clock_t tinicial, clock_t tfinal){
printf ("Tempo = %2.5f segundos\n",
((double)( tfinal - tinicial ) / ((double)CLOCKS_PER_SEC )));
}
main(){
clock_t tinicial, tfinal;
iniciar_lista();
tinicial = clock();
quicksort(0,MaxTam-1);
tfinal = clock();
imprime_tempo(tinicial, tfinal);
getchar();
scanf("c\n");
}

2) Prepare uma resenha analisando todos os mtodos incluindo a anlise do tempo

de execuo real de todos algoritmos testados.
Bubble Sort

Bubble sort o algoritmo mais simples, mas o menos eficientes. Neste

algoritmo cada elemento da posio i ser comparado com o elemento da posio i + 1,
ou seja, um elemento da posio 2 ser comparado com o elemento da posio 3. Caso o
elemento da posio 2 for maior que o da posio 3, eles trocam de lugar e assim
sucessivamente. Por causa dessa forma de execuo, o vetor ter que ser percorrido
quantas vezes que for necessria, tornando o algoritmo ineficiente para listas muito
grandes.

Esquema de funcionamento do Buble Sort

verificado se o 3 maior que 5, por essa condio ser falsa, no h troca.

verificado se o 5 maior que 1, por essa condio ser verdadeira, h uma

troca.

verificado se o 5 maior que 2, por essa condio ser verdadeira, h uma

troca.

verificado se o 5 maior que 4, por essa condio ser verdadeira, h uma

troca.

O mtodo retorna ao incio do vetor realizando os mesmos processos de

comparaes, isso feito at que o vetor esteja ordenado.

Selection Sort
Este algoritmo baseado em se passar sempre o menor valor do vetor para a
primeira posio (ou o maior dependendo da ordem requerida), depois o segundo menor
valor para a segunda posio e assim sucessivamente, at os ltimos dois elementos.
Neste algoritmo de ordenao escolhido um nmero a partir do primeiro, este
nmero escolhido comparado com os nmeros a partir da sua direita, quando
encontrado um nmero menor, o nmero escolhido ocupa a posio do menor nmero
encontrado. Este nmero encontrado ser o prximo nmero escolhido, caso no for
encontrado nenhum nmero menor que este escolhido, ele colocado na posio do
primeiro nmero escolhido, e o prximo nmero sua direita vai ser o escolhido para
fazer as comparaes. repetido esse processo at que a lista esteja ordenada.

Esquema de funcionamento do Selection Sort

Neste passo o primeiro nmero escolhido foi o 3, ele foi comparado com todos
os nmeros sua direita e o menor nmero encontrado foi o 1, ento os dois
trocam de lugar.

O mesmo processo do passo 1 acontece, o nmero escolhido foi o 5 e o menor

nmero encontrado foi o 2.

No foi encontrado nenhum nmero menor que 3, ento ele fica na mesma
posio.

O nmero 5 foi escolhido novamente e o nico nmero menor que ele sua
direita o 4, ento eles trocam.

Vetor j ordenado.

Insertion sort
O Insertion sort um algoritmo simples e eficiente quando aplicado em
pequenas listas. Neste algoritmo a lista percorrida da esquerda para a direita, medida
que avana vai deixando os elementos mais esquerda ordenados.
O algoritmo funciona da mesma forma que as pessoas usam para ordenar cartas
em um jogo de baralho como o pquer.

Esquema de funcionamento do Insertion Sort

Neste passo verificado se o 5 menor que o 3, como essa condio falsa,

ento no h troca.

verificado se o quatro menor que o 5 e o 3, ele s menor que o 5, ento os

dois trocam de posio.

verificado se o 2 menor que o 5, 4 e o 3, como ele menor que 3, ento o 5

passa a ocupar a posio do 2, o 4 ocupa a posio do 5 e o 3 ocupa a posio do
4, assim a posio do 3 fica vazia e o 2 passa para essa posio.
O mesmo processo de comparao acontece com o nmero 1, aps esse

processo o vetor fica ordenado.

Quick sort
O Quicksort o algoritmo mais eficiente na ordenao por comparao. Nele
se escolhe um elemento chamado de piv, a partir disto organizada a lista para que
todos os nmeros anteriores a ele sejam menores que ele, e todos os nmeros
posteriores a ele sejam maiores que ele. Ao final desse processo o nmero piv j est
em sua posio final. Os dois grupos desordenados recursivamente sofreram o mesmo
processo at que a lista esteja ordenada.

Esquema de funcionamento do Quick Sort

O nmero 3 foi escolhido como piv, nesse passo procurado sua direita um
nmero menor que ele para ser passado para a sua esquerda. O primeiro nmero
menor encontrado foi o 1, ento eles trocam de lugar.

Agora procurado um nmero sua esquerda que seja maior que ele, o primeiro
nmero maior encontrado foi o 5, portanto eles trocam de lugar.

O mesmo processo do passo 1 acontece, o nmero 2 foi o menor nmero

encontrado, eles trocam de lugar.

O mesmo processo do passo 2 acontece, o nmero 4 o maior nmero

encontrado, eles trocam de lugar.

O vetor desse exemplo um vetor pequeno, portanto ele j foi ordenado, mas se
fosse um vetor grande, ele seria dividido e recursivamente aconteceria o mesmo
processo de escolha de um piv e comparaes.

3) Investigue o funcionamento e implemente o algoritmo de intercalao.

#include<stdio.h>
void intercalar (int v[],int aux[],int ini1, int ini2,int fim2)
{
int in1=ini1,in2=ini2,fim1=in2-1,au=0,i;
while(in1<=fim1 && in2<=fim2)
{
if (v[in1]<v[in2])
{
aux[au++] = v[in1++];
}
else
{
aux[au++] = v[in2++];
}
}
while(in1<=fim1)
{
aux[au++] = v[in1++];
}
while(in2<=fim2)
{
aux[au++] = v[in2++];

}
for(i=0;i<au;i++)
{
v[i+ini1]=aux[i];}
}
void mergeSort (int v[], int aux[],int esq, int dir)
{
int meio,i;
if(esq<dir)
{
meio=(esq+dir)/2;
mergeSort(v,aux,esq,meio);
mergeSort(v,aux,meio+1,dir);
intercalar(v,aux,esq,meio+1,dir);
}
}
int main()
{
int v[9]={53,25,46,32,23,37,41,17,10},aux[9],i;
mergeSort(v,aux,0,8);
for(i=0;i<9;i++)
{
printf("%d\t",v[i]);
}
return 0;
}

A ideia bsica do Merge Sort criar uma sequncia ordenada a partir de duas
outras tambm ordenadas. Para isso, o algoritmo Merge Sort divide a sequncia original
em pares de dados, agrupa estes pares na ordem desejada; depois as agrupa as
sequncias de pares j ordenados, formando uma nova sequncia ordenada de quatro
elementos, e assim por diante, at ter toda a sequncia ordenada.
Algoritmo:
Os trs passos teis dos algoritmos dividir-para-conquistar, que se aplicam ao Merge
Sort so:
1. Dividir: Dividir os dados em subsequncias pequenas; Este passo realizado
recursivamente, iniciando com a diviso do vetor de n elementos em duas

metades, cada uma das metades novamente dividida em duas novas metades e
assim por diante, at que no seja mais possvel a diviso (ou seja, sobrem n
vetores com um elemento cada).
2. Conquistar: Classificar as duas metades recursivamente aplicando o merge sort;
3. Combinar: Juntar as duas metades em um nico conjunto j classificado.
Para completar a ordenao do vetor original de n elementos, faz-se o merge ou
a fuso dos sub-vetores j ordenados.
A desvantagem do Merge Sort que requer o dobro de memria, ou seja,
precisa de um vetor com as mesmas dimenses do vetor que est sendo classificado.
Na figura abaixo temos um Vetor original com elemento desordenado.
0

53

25

46

32

23

37

41

17

10

O vetor original subdividido em dois vetores.

0

53

25

46

32

23

37

41

17

10

Cada um dos subvetores novamente dividido.

0

53

25

46

32

23

37

41

17

10

E assim por diante.

0

53
53

25
25

46
46

32
32

23
23

37
37

41
41

17
17

10
10

Aps todo o processo de diviso, ocorre o processo da fuso ordenada dos subvetores.
O subvetor (53) com o subvetor (25). Ordenando os dois.
0

25

53

46

32

23

37

41

17

10

O subvetor (25, 53) com o subvetor (46). Ordenando os dois.

0

25

46

53

32

23

37

41

17

10

O subvetor (32) com o subvetor (23).

25

46

53

23

32

37

41

17

10

O subvetor (25,46,53) com o subvetor (23,32). Ordenando os dois.

0

23

25

32

46

53

37

41

17

10

O mesmo processo se repete no subvetor (37, 41, 17, 10).

0

23
23
23

25
25
25

32
32
32

46
46
46

53
53
53

37
37
10

41
41
17

17
10
37

10
17
41

Os subvetores resultantes (23,25, 32, 36,53) e (10, 17, 37, 41) so fundidos ordenados
durante a fuso.
0

10

17

23

25

32

37

41

46

53

O processo de ordenao termina.