Quicksort

Rodrigo Richard Gomes

Quicksort
Criado em 1960 por C. A. R. Hoare
um algoritmo muito popular
No difcil de implementar ;-)
Funciona bem para diferentes tipos de dados
Consome menos recursos
(processador/memria) do que outros
algoritmos em diversas situaes
Quicksort
Vantagens:
Inplace (algoritmo que transforma uma
estrutura de dados usando um pequeno e
constante espao de armazenamento) 4
Complexidade n log n para a maioria das
situaes
Quicksort
Desvantagens:
No estvel
Complexidade n
2
no pior caso (semelhante
ao BubbleSort)
um algoritmo frgil
Qualquer erro simples na implementao pode
levar a um baixo desempenho
Quicksort
O algoritmo bsico
um algoritmo do tipo dividir-para-
conquistar
Funciona particionando um vetor em duas
partes e ento ordenando essas partes
independentemente
Quicksort
A parte mais importante do algoritmo o
processo de particionamento, o qual rearranja o
vetor de modo a respeitar as trs condies a
seguir:
O elemento a[i] est em sua posio final no vetor
para qualquer i
Nenhum dos elementos a[esq],...,a[i-1] maior que
a[i]
Nenhum dos elementos a[i+1],...,a[dir] menor que
a[i]
Quicksort
Quicksort
O algoritmo de particionamento
Escolha um elemento do vetor (piv)
Percorra o vetor partir da esquerda at encontrar um
elemento maior que o piv
Percorra o vetor partir da direita at encontrar um
elemento menor que o piv
Os elementos a[i] e a[j] esto fora de sua posio.
Troque-os de lugar.
Continue at que os ndices i e j se cruzem em algum
ponto do vetor
Quicksort
int particao(int a[], int l, int r)
{
int i = l-1, j = r;
int v = a[r], temp;
for (;;)
{
while(a[++i] < v); // varre o vetor esq -> dir procurando um elemento
// menor que v (piv)
while (v < a[--j]) // varre o vetor dir -> esq procurando um elemento
if (j == l) break; // menor que v (piv)
if (i >= j) break; // verifica se os ndices i(esq) e j(dir) se cruzaram
temp = a[i];
a[i] = a[j]; // troca a posio
a[j] = temp;
}
temp = a[i];
a[i] = a[r]; // troca a posio do piv
a[r] = temp;
return i; // retorna o ndice do piv, o qual sabemos que est
// no lugar correto
}
Quicksort
void quicksort(int a[], int l, int r)
{
if (r <= l) return;
int i = particao(a, l, r);
quicksort(a, l, i-1);
quicksort(a, i+1, r);
}
R L P M S X O G N I T E E A A
R L P M S X O G N I T E E A A
R L P M S X O G N I T E E A A
R L P M S X O G N I T E E A A
E L P M S X O G N I T R E A A
E L P M S X O G N I T R E A A
E L P M S X E G N I T R O A A
E L P M S X E G N I T R O A A
E L P M S X E G N I T R O A A
E L P M A X E G N I T R O S A
E L P M A X E G N I T R O S A
E L P M A X E G N I T R O S A
14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Quicksort
S T X R N P O M G I L E E A A
S T X R M P O N G I L E E A A
S T X R M P O N G I L E E A A
S T X R M P O G N I L E E A A
S T X R M P O G N I L E E A A
S T X R M P O G N I L E E A A
R T X S M P O G N I L E E A A
R T X S M P O G N I L E E A A
R T X M S P O G N I L E E A A
R T X M S P O G N I L E E A A
R T P M S X O G N I L E E A A
R T P M S X O G N I L E E A A
R L P M S X O G N I T E E A A
R L P M S X O G N I T E E A A
14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Quicksort
X T S R P O N M L I G E E A A
X T S R P O N M L I G E E A A
X T S R P O N M L I G E E A A
X T S R P O N M L I G E E A A
S T X R P O N M L I G E E A A
S T X R P O N M L I G E E A A
S T X R P O N M L I G E E A A
S T X R P O N M L I G E E A A
S T X R O P N M L I G E E A A
S T X R O P N M L I G E E A A
S T X R N P O M L I G E E A A
S T X R N P O M L I G E E A A
S T X R N P O M L I G E E A A
S T X R N P O M L I G E E A A
S T X R N P O M L I G E E A A
S T X R N P O M G I L E E A A
S T X R N P O M G I L E E A A
14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
Quicksort
Quicksort