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

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

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

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)

Exemplo de particionamento
Selecionando o piv como v[(d+e)/2]
C C C C C C C A A A A A A A M M M M M H H I I I I I I I N N N N N N N H H H H H M M O O O O O O 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 C C C A A A A A A A A A C C C C C H H H H H H H H H I I I I I I I I I N N N N N N N N N M M A
7

M H H H H M M M M M N N N

O O O O O O O O O O O O O

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 + 1) C(n) = n + (n 1) + (n 2) + L + 1 = i = 2 i =1
n
9

Quicksort Anlise
Exemplo de pior caso
T T T T T T S V V V V U S T Y Y X S S U U Z U U U V V V S S S X X X X X X Y Y Y Y Y U Z Z Z Z Z 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 T T V V S Y Y U Z Z Z S S Y X X X U U 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 T T T V V S S Y Y U U Z Z Z S S Y X X X U U V

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 T T T V V S S Y Y U U Z Z Z S S Y X X X U U V

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