CENTRO UNIVERSITRIO DA GRANDE DOURADOS

Nome: Fbio Ricardo Bareta

RGM: 122.839

Estrutura de Dados.
Quick Sort Vs Heap Sort.

Dourados
2010

Sumrio
Estrutura

de

Dados.

Quick Sort Vs Heap Sort.....................................................................................................1

Sumrio.........................................................................................................................2
Introduo.....................................................................................................................3
Os algoritmos de ordenao..........................................................................................4
Quick-sort.................................................................................................................4
Funcionamento..........................................................................................................4
Complexidade...........................................................................................................5
Pseudocdigo:...........................................................................................................5
Dourados...............................................................................................................1
Heap-sort...................................................................................................................6
Funcionamento..........................................................................................................6
Complexidade...........................................................................................................6
Pseudocdigo:...........................................................................................................6
A estabilidade dos mtodos..........................................................................................8
Quantos vetores usar?...................................................................................................9
O algoritmo de gerao.................................................................................................9
Os algoritmos:.........................................................................................................10
Gerao do vetor com nmeros pseudo-aleatrios:................................................10
A gravao do vetor em arquivo:............................................................................10
Clonando vetores nos tamanhos necessrios:.........................................................12
O teste da ordenao:..............................................................................................13
O teste da integridade:............................................................................................13
Resultados...................................................................................................................15
Trocas......................................................................................................................15
Comparaes...........................................................................................................16
Tempo ( em segundos )...........................................................................................18
Grficos.......................................................................................................................20
Concluso....................................................................................................................22
Bibliografia.................................................................................................................23

Dourados
2010

Introduo.

O seguinte trabalho tem a inteno de realizar uma anlise de funcionamento e

desempenho do mtodo de ordenao Quick Sort comparado ao mtodo de ordenao Heap
Sort, nesta analise sero apresentados demonstrativos de quanto tempo cada algoritmo leva
para ordenar uma seqncia, quantas trocas e quantas comparaes entre elementos so
realizadas por cada mtodo.
Todos os teste foram realizados em um notebook com processador Intel Core I5
430M , 4Gb de Memria Ram DDR3.

Dourados
2010

Os algoritmos de ordenao.
Uma apresentao da abordagem de cada mtodo com suas caractersticas peculiares,
importante lembrar que:
Para essa descrio foram omitidos os parmetros e todas as outras implementaes
feitas ao sistema de ordenao para a gerao do relatrio com os dados de execuo.

Quick-sort

Funcionamento
O Quick-sort adota a estratgia de diviso e conquista. Os passos so:
Escolha um elemento da lista, denominado piv;
Rearranje a lista de forma que todos os elementos anteriores ao piv sejam menores
que ele, e todos os elementos posteriores ao piv sejam maiores que ele. Ao fim do processo o
piv estar em sua posio final e haver duas sub listas no ordenadas. Essa operao
denominada partio;
Recursivamente ordene a sub lista dos elementos menores e a sub lista dos elementos
maiores;
A base da recurso so as listas de tamanho zero ou um, que esto sempre ordenadas.
O processo finito, pois a cada iterao pelo menos um elemento posto em sua posio final
e no ser mais manipulado na iterao seguinte.

Dourados
2010

Complexidade
No seu melhor e mdio caso O(n log2 n) e no pior caso O(n).

Pseudocdigo:
divide(V[], inicio, fim)
x <- V[inicio]
esquerda <- inicio - 1
direita <- fim + 1
sair <- 0
repita
repita
direita <- direita-1
at que V[direita] > x
repita
esquerda <- esquerda+1
at que V[esquerda] < x
se esquerda < direita faa
troca(V[esquerda],V[direita])
seno
sair <- 1
fim-se
at que sair = 1
Fim-divide.

No Quick-sort a funo divide faz a ordenao e retorna o novo piv para as

prximas chamadas da recurso.
quicksort(V[], inicio, fim)
se inicio < fim ento
meio=divide(V,inicio,fim)
quicksort(V,inicio,meio)
quicksort(V,meio+1,fim)

Dourados
2010

fim-se
fim-quicksort.

Heap-sort

Funcionamento
O heapsort utiliza uma estrutura de dados chamada heap, para ordenar os elementos a
medida que os insere na estrutura. Assim, ao final das inseres, os elementos podem ser
sucessivamente removidos da raiz da heap, na ordem desejada, lembrando-se sempre de
manter a propriedade de max-heap.
A heap pode ser representada como uma rvore (uma rvore binria com
propriedades especiais) ou como um vetor. Para uma ordenao crescente, deve ser construdo
um heap mximo (o maior elemento fica na raiz). Para uma ordenao decrescente, deve ser
construdo um heap mnimo (o menor elemento fica na raiz).

Complexidade
Melhor e pior caso: O(n log2n) o mesmo que O(n lgn).

Pseudocdigo:
Heapsort(A)
ConstroiHeap(A, n);
para tamanho de n decrescendo at 2 faa
t <- A[tamanho];

Dourados
2010

A[tamanho] <- A[1];

A[1] <- t;
Fim-para.
AjustaHeap(A, 1, tamanho);
Fim-Heapsort.
AjustaHeap(A, i , n)
se 2i n e A[2i ] A[i] ento
maximo <- 2*i;
seno
maximo <- i;
fim-se.
se 2*i + 1 n e A[2i + 1] A[maximo] ento
maximo <- 2*i + 1;
fim-se.
se maximo = i ento
t <- A[maximo];
A[maximo] <- A[i];
A[i] <- t;
fim-se.
AjustaHeap(A, maximo, n);
Fim-AjustaHeap.
ConstroiHeap(A, n)
para i de n / 2 decrescendo at 1 faa
AjustaHeap(A, i , n);
fim-para.
fim-ConstroiHeap.

Dourados
2010

A estabilidade dos mtodos.

Um algoritmo de ordenao diz-se estvel se preserva a ordem de registros de chaves

iguais. Isto , se tais registros aparecem na seqncia ordenada na mesma ordem em que esto
na seqncia inicial.
OBS: Certos algoritmos so estveis a partir de sua concepo original, como o
Merge-sort. Porm. possvel implementar estabilidade artificialmente em certos algoritmos.
Por exemplo, numa comparao de dois objetos de mesmo valor pode aplicar-se uma
comparao adicional para verificar se a ordem original dos registros associados foi mantida.
Neste caso, a implementao de estabilidade requer um custo adicional de eficincia.
Dos mtodos analisados temos que ambos so instveis.

Dourados
2010

Quantos vetores usar?

Um algoritmo de ordenao chamado in-place se nenhum espao usado alm do
vetor inicial que contm os elementos. Assim de nossos 2 mtodos analisados temos que
ambos so in-place.

O algoritmo de gerao.

O objetivo da anlise verificar o tempo gasto por cada mtodo bem como a
quantidade de trocas e comparaes feitas, para tal foram usadas 29 cadeias com tamanho
entre 100.000 e 2.900.000 posies, cada vetor foi preenchido com nmeros pseudo aleatrios
e todas as cadeias foram ordenadas 3 vezes para gerar uma mdia em cada mtodo de
ordenao.
O vetor usado foi mantido sempre o mesmo em todos os passos.
O algoritmo que faz o teste dos mtodos de ordenao consiste nas seguinte etapas:

Solicitado ao usurio informar o tamanho da primeira cadeia;

gerado um vetor com 50 vezes o tamanho informado preenchido de nmeros

inteiros pseudo-aleatrios;

O vetor gravado em arquivo, para qualquer eventualidade a ordenao ser retomada

caso o programa pare; (vetor.txt)

Caso a ordenao tenha sido interrompida, no solicitado o tamanho da cadeia ao

usurio, e sim o vetor lido do arquivo. Ao usurio solicitado de qual cadeia deve
ser retomada a ordenao.

Dourados
2010

Uma parte do vetor criado copiado e alocado na memria no tamanho ao qual se

deseja ordenar;

O vetor ordenado pelos 2 mtodos, 3 vezes para cada mtodo;

realizado o teste para ver se o vetor est realmente ordenado;

realizado o teste para verificar se o vetor continua com o mesmo tamanho depois da
ordenao;

Os resultados so gravados em arquivo. (rel.csv).

Os algoritmos:

Gerao do vetor com nmeros pseudo-aleatrios:

int* vetorize(int n){
int i, *v;
v = new int[n];
if (v == NULL) {
alertas(true,"Este computador nao tem memoria suficiente...Programa
abortado!");
}
srand(time(NULL));
for (i=0; i<n; i++){
v[i] = rand();
}
return v;
}
Onde:
n o tamanho do vetor.
Retorna vetor com n posies preenchidas aleatoriamente.

A gravao do vetor em arquivo:

void grava_vetor(int vetor[],int n){
int i;
ofstream fout;

Dourados
2010

10

fout.open("vetor.txt");
if(fout.fail()){
alertas(true,"Erro na abertura do arquivo");
}
fout<<n<<endl;
for(i=0;i<n;i++){
fout<<vetor[i]<<endl;
}
fout.close();
}
Onde:
vetor[] o vetor que ser gravado.
n o tamanho do vetor.

Leitura de vetor em arquivo:

int* le_vetor(int n){
int i, *v;
v = new int[n];
if (v == NULL) {
alertas(true,"Este computador nao tem memoria suficiente...Programa
abortado!");
}
ifstream fin;
fin.open("vetor.txt");
if( fin.fail() ){
alertas(true,"Vetor no pode ser lido... Programa abortado!");
}
int valor;
for(i=0;i<n+1;i++){
fin>>valor;
if(i>0){
v[i-1]=valor;
}
}
fin.close();
return v;
}
Onde:
n o tamanho vetor a ser lido e retornado pela funo.

Dourados
2010

11

o valor de n encontrado pela funo que confere se existe algum vetor

gravado:

int existe_vetor(){
ifstream fin;
fin.open("vetor.txt");
if(fin.fail()){
return 0;
}
int valor;
fin>>valor;
if(valor){
return valor;
}else{
return 0;
}
fin.close();
}

Clonando vetores nos tamanhos necessrios:

int* clona_vetor(int vetor[],int n){
int i, *vetor_molde;
vetor_molde = new int[n];
if (vetor_molde == NULL) {
alertas(true,"Este computador nao tem memoria suficiente...Programa
abortado!");
}
for(i=0;i<n;i++){

Dourados
2010

12

vetor_molde[i]=vetor[i];
}
return vetor_molde;
}
Onde:
vetor[] o vetor completo de onde se deseja tirar n elementos.
n a quantidade de elementos a serem retirados de vetor[]
retorna o novo vetor copiado do vetor passado a funo.

O teste da ordenao:
void confere_ordem(int vetor[],int n){
int i;
for(i=0;i<n-1;i++){
if(vetor[i]>vetor[i+1]){
alertas(true,"Vetor desordenado...Programa abortado!");
}
}
}
Onde:
vetor[] o vetor a que se deseja verificar se est ordenado.
n o tamanho do vetor a ser conferido.

O teste da integridade:
void confere_perdas(int vetor[],int vetor_molde[],int n){
int i;
stringstream v1,v2;
v1.str("");
v2.str("");
for(i=0;i<n;i++){
v1 << vetor[i];
}
for(i=0;i<n;i++){
v2 << vetor_molde[i];
}
if(v1.str().length()!=v2.str().length()){

Dourados
2010

13

alertas(true,"Vetor corrompido durante o processo...Programa

abortado!");
}
}
Onde:
vetor[] e vetor_molde[] so os vetores a que se deseja conferir se possuem
os

mesmos

elementos

(neste

caso

observado

se

ambos

possuem

mesmo

tamanho);
n o tamanho do vetor.

O relatrio armazenado em uma estrutura durante a execuo e a cada intervado de

tamanhos gravado.
struct info{
string metodo_nome;
int metodo;
ciclos tamanho[50];
};
struct ciclos{
int tamanho;
uint64_t trocas[3];
uint64_t comparacoes[3];
double tempo[3];
};

Para cada tamanho so armazenados 3 resultados (tempo, trocas e comparaes).

Dourados
2010

14

Resultados

Trocas
Tamanho

Quick Sort

Heap Sort

1000000
2000000
3000000
4000000

5773940
12600972
19783607
26993414

19048122
40096440
61972035
84190995
10691336

5000000

34724179

4
12993550

6000000

42383036

3
15310657

7000000

50278904

0
17638084

8000000

57991783

0
19996736

9000000
1000000

65943576

2
22382960

0
1100000

74380511

9
24780880

0
1200000

82393244

7
27187954

0
1300000

90652195

7
29601679

0
1400000

99100773
10691011

8
32022039

0
1500000

6
11595340

4
34446804

0
1600000

3
12478763

3
36876460

Dourados
2010

15

0
1700000

9
13271618

8
39317696

0
1800000

5
14129728

9
41793042

0
1900000

1
14975718

0
44276487

0
2000000

0
15835978

5
46766215

0
2100000

4
16691200

6
49261777

0
2200000

8
17577692

5
51762243

0
2300000

6
18427049

2
54267091

0
2400000

8
19374856

0
56775067

0
2500000

3
20159085

9
59288275

0
2600000

7
21139151

1
61803471

0
2700000

4
21969116

1
64322376

0
2800000

7
22962935

7
66844124

0
2900000

7
23783437

8
69367983

Tabela 1: Nmero de trocas dos 2 mtodos.

Comparaes
tamanh
o
100000
0
200000
0
300000
0
400000
0
500000
0
600000
0

Quick
Sort

Heap
Sort

6773939
1460097
1
2278360
6
3099341
3
3972417
8
4838303
5

9049932
1910124
3
2941402
7
4020258
7
5090756
3
6182920
7

Dourados
2010

16

700000
0
800000
0
900000
0
100000
00
110000
00
120000
00
130000
00
140000
00
150000
00
160000
00
170000
00
180000
00
190000
00
200000
00
210000
00
220000
00
230000
00
240000
00
250000
00
260000
00
270000
00
280000
00
290000
00

5727890
3
6599178
2
7494357
5
8438051
0
9339324
3
1026521
94
1121007
72
1209101
15
1309534
02
1407876
38
1497161
84
1592972
80
1687571
79
1783597
83
1879120
07
1977769
25
2072704
97
2177485
62
2265908
56
2373915
13
2466911
66
2576293
56
2668343
77

7293751
0
8441003
2
9566289
9
1068101
75
1181462
51
1296494
42
1412887
94
1528855
56
1647693
11
1768183
44
1889556
46
2003248
55
2119708
81
2236319
44
2356375
25
2472884
93
2592710
25
2713030
97
2836912
45
2955771
21
3076420
89
3197654
32
3321728
61

Tabela 2: Nmero de comparaes dos 2 mtodos.

Dourados
2010

17

Tempo ( em segundos )
tamanh Quick
Heap
o
Sort
Sort
100000
0
0,47
1,09
200000
0
0,95
2,73
300000
0
1,45
4,59
400000
0
1,94
6,42
500000
0
2,47
8,20
600000
0
2,98
10,40
700000
0
3,49
12,80
800000
0
3,99
14,56
900000
0
4,56
16,48
100000
00
5,09
18,89
110000
00
5,59
21,79
120000
00
6,10
23,41
130000
00
6,66
25,42
140000
00
7,20
28,11
150000
00
7,69
31,21
160000
00
8,28
33,01
170000
00
8,78
35,03
180000
00
9,31
37,94
190000
00
9,84
41,62
200000
00
10,36
43,11

Dourados
2010

18

210000
00
220000
00
230000
00
240000
00
250000
00
260000
00
270000
00
280000
00
290000
00

10,94

45,19

11,58

48,52

12,04

52,23

12,55

53,87

13,23

56,06

13,76

59,22

14,21

63,59

14,82

64,63

15,41

66,30

Tabela 3: Tempo de ordenao dos 2 mtodos em segundos.

Dourados
2010

19

Grficos

Grfico 1: Tempo de ordenao

Grfico 2: Nmero de trocas

Dourados
2010

20

Grfico 3: Nmero de comparaes

Dourados
2010

21

Concluso
Aps a analise de todos os mtodos, podemos ver que o heap sort teve um
desempenho inferior ao quick-sort. Isto analisando numero de comparaes, trocas e o tempo
para realizar a ordenao, onde o quick-sort tem valores bem abaixo. No foram analisados
casos com vetores ordenados e nem ordenados inversamente, somente com nmeros
aleatrios onde o quick-sort se mostrou mais rpido.
Tendo como base o tempo de ordenao, do mais rpido ao mais lento, colocamos os
mtodos na seguinte ordem:
1. Quick sort;
2. Heap sort;
Vale observar que o quick-sort com seu pior caso em O(n), de acordo com o caso de
uso pode-se tornar um grande problema, mesmo tendo o pior caso em forma rara.
De acordo com os vetores analisados a estabilidade dos mtodos no representa
diferena no resultado, comparados a outros mtodos mais lerdos temos que um instvel
mais rpido. Como no tnhamos nenhum dado ligado a chave de ordenao esta propriedade
nesse estudo indiferente.

Dourados
2010

22

Bibliografia
http://pt.wikipedia.org/wiki/Heapsort
http://www.inf.ufsc.br/~ine5384-hp/Estruturas.Quick.html
http://www.allgoritmos.com/2009/08/poscomp-2005-q33-algoritmos-de.html
http://www.personal.kent.edu/~rmuhamma/Algorithms/MyAlgorithms/Sorting/heapS
ort.htm
http://w3.ualg.pt/~hshah/ped/Aula%2014/Heap_Sort_final.html
http://pt.wikipedia.org/wiki/Quicksort
http://www.ime.usp.br/~pf/algoritmos/aulas/quick.html
http://max.cs.kzoo.edu/~kschultz/CS510/ClassPresentations/Heapsort.cpp.html
.

Dourados
2010

23