Quicksort

Algoritmos e Estruturas de Dados II

Histria

Proposto por Hoare em 1960 e publicado em 1962

o algoritmo de ordenao interna mais rpido que
se conhece para uma ampla variedade de situaes

Provavelmente o mais utilizado

2
Algoritmo

Dividir o problema de ordenar um conjunto com n
itens em dois problemas menores

Os problemas menores so ordenados
independentemente

As parties so combinadas para produzir a
soluo final

3
Particionamento

A parte mais delicada do quicksort o processo de
partio

O vetor v rearranjado por meio da escolha
arbitrria de um piv p

O vetor v particionado em dois:

Partio esquerda: chaves p

Partio direita: chaves p

4
Algoritmo para particionamento

Escolha arbitrariamente o piv p

Percorra a partir da esquerda at que v[e] p

Percorra a partir da direita at que v[d] p

Troque v[e] com v[d]

Repita os passos anteriores at que e e d se
cruzarem (d < e)

5
Exemplo de particionamento

Selecionando o piv como v[(d+e)/2]
C A M I N H O
C A M I N H O
C A M I N H O
C A M I N H O
C A M I N H O
C A H I N M O
C A H I N M O

Ao final do particionamento

O piv est em sua posio final

Elementos na partio da esquerda so menores

Elementos na partio da direita so maiores que o piv
6
Exemplo quicksort
C A H I N M O
C A H I
C A H I N H O
C A H I N H O
A C H I N H O
A C H I N H O
A C H I N M O
A C H I N M O
A C H I N M O
N M O
N M O
M N O
M N O
A C H I M N O

7
Quicksort
void quicksort(struct item *v, int e, int d) {
if(d <= e) return;
int p = particao(v, e, d);
quicksort(v, e, p-1);
quicksort(v, p+1, d);
}

void particao(struct item *v, int e, int d) {

int i = e; int j = d; struct item pivo = v[(d+e)/2];
while(1) {
while(v[i].chave < pivo.chave) i++;
while(pivo.chave < v[j].chave) j--;
if(i >= j) break;
troca(v[i], v[j]); i++; j--;
}
troca(v[i], v[d]);
No funciona quando
return i;
tem elementos repetidos!
}

8
Quicksort Anlise

Pior caso

Acontece quando o piv sempre o maior ou menor
elemento (parties de tamanho desequilibrado)
void quicksort(struct item *v, int e, int d) {
if(d <= e) return;
int p = particao(v, e, d); /* p = d; */
quicksort(v, e, p-1); /* quicksort(v, e, d-1); */
quicksort(v, p+1, d); /* quicksort(v, d+1, d); */
}
n comparaes
n-1 comparaes
zero comparaes
n
n(n + 1)
C(n) = n + (n 1) + (n 2) + L + 1 = i =
i =1 2
9
Quicksort Anlise

Exemplo de pior caso
T V Y Z S X U
T V Y U S X Z
T V X U S Y Z
T V S U X Y Z
T U S V X Y Z
T S U V X Y Z
S T U V X Y Z

10
 Quicksort Anlise

Melhor caso

Acontece quando as parties tm sempre o mesmo
tamanho (parties balanceadas)
void quicksort(struct item *v, int e, int d) {
if(d <= e) return;
int p = particao(v, e, d); /* p = (d+e)/2; */
quicksort(v, e, p-1); /* quicksort(v, e, (d+e)/2-1); */
quicksort(v, p+1, d); /* quicksort(v, (d+e)/2+1, d); */
}
n comparaes
n/2 comparaes
n/2 comparaes

C(n) = 2C(n / 2) + n n lg n

11
Quicksort Anlise

Caso mdio

Parties podem ser feitas em qualquer posio no vetor
1 n
C(n) = n + 1 + C(i 1) + C(n i)
n i =1
2 n
= n + 1 + C(i 1)
n i =1

nC(n) (n 1)C(n 1) = 2n + 2C(n 1)

C(n) C(n 1) 2
= + 2 ln n = 1,39 lg n
(n + 1) n n +1
12
Quicksort Anlise

Melhor caso
C(n) n lg n = O(n lg n)

Caso mdio
C(n) 1,39n lg n = O(n lg n)

Pior caso
n(n + 1)
C(n) = = O(n2 )
2

13
Vantagens e desvantagens

Vantagens:

Melhor opo para ordenar vetores grandes

Muito rpido por que o lao interno simples

Memria auxiliar para a pilha de recurso pequena

Complexidade no caso mdio O(n lg(n))

Desvantagens:

No estvel (no conhecemos forma eficiente para
tornar o quicksort estvel)

Pior caso quadrtico

14
Otimizao Mediana de trs

Para evitar o pior caso do quicksort, podemos
escolher o piv como a mediana de trs elementos
T V Y Z S X U
T V Y Z S X U
T S U Z Y X V

Aumentar o nmero de elementos considerados na

mediana, por exemplo pra 5 ou 9, no ajuda muito

15
Otimizao Partio menor primeiro

Implementaes no recursivas do quicksort
precisam manter uma pilha auxiliar

No pior caso, a pilha auxiliar pode ter tamanho n

Para limitar o crescimento da pilha auxiliar basta
ordenar a partio menor primeiro
T V Y Z S X U
T V Y Z S X U
T S U Z Y X V
T S U

16
Otimizao Parties pequenas

Quando a partio a ordenar pequena, o mtodo
de ordenao por insero mais rpido que o
quicksort

No tem chamadas recursivas

Lao interno muito eficiente

T V Y Z S X U
T V Y Z S X U
T S U Z Y X V
T S U

17
Pontos extras

1 ponto para os trs primeiros alunos que apresentarem
cdigo do quicksort que usa mediana de trs

1 ponto para os trs primeiros alunos que apresentarem
cdigo do quicksort que usa insero em parties
pequenas

1 ponto para os trs primeiros alunos que apresentarem
quicksort no recursivo e que limita o tamanho da pilha
auxiliar ordenando parties pequenas primeiro

Cada aluno pode ganhar apenas 1 dos pontos acima

A soluo deve ser constrda como extenso do cdigo
colocado na pgina do curso

18