Algoritmos dividir para

Conquistar

1. Quicksort
2. Dividir para conquistar
3. Particionamento
4. Análise do pior caso
5. Quicksort ramdomizado
6. Análise
 Quicksort
• Proposto por C.A.R. Hoare in 1962.
• Algoritmo dividir para conquistar.
• Ordena no lugar (como algoritmo da inserção
mas não como mergesort).
• Muito pratico com otimizações
 Dividir para Conquistar
Quicksort sobre um array de n elementos :
1.Dividir: Partiticiona o array em dois subarrays em
torno de um pivot x tal que elementos no subarray
inferior ≤ x ≤ elementos no subarray superior.
≤x x ≥x
2.Conquistar: Ordena recursivamente os dois
subarrays.
3.Combinar: Trivial.
Chave: particionamento em tempo linear
 Subrotina de particionamento
PARTITION(A, p, q) ⊳ A[ p . . q]
x ← A[ p] ⊳ pivot = A[ p]
i←p
for j ← p + 1 to q
do if A[ j] ≤ x
then i ← i + 1
exchange A[i] ↔ A[ j]
exchange A[ p] ↔ A[i]
return i

Invariante x ≤x ≥x ?
\p i j q
Ex. particionamento
6 10 13 5 8 3 2 11
i j
Ex. particionamento
Ex. particionamento
Ex. particionamento
Ex. particionamento
Ex. particionamento
Ex. particionamento
Ex. particionamento
Ex. particionamento
Ex. particionamento
Ex. particionamento
Ex. particionamento
Pseudocodigo do quicksort
QUICKSORT(A, p, r)
if p < r
then q ← PARTITION(A, p, r)
QUICKSORT(A, p, q–1)
QUICKSORT(A, q+1, r)

Chamada: QUICKSORT(A, 1, n)
 Analise do quicksort

• Assume que todos os elementos são

diferentes.
• Na pratica, existem algoritmos de
particionamento melhores para quando
existem elementos duplicados
• Seja T(n) = o pior caso em uma array de n
elementos.
 Pior caso do quicksort
• A entrada está em ordem inversa
• Particiona sobre o elemento min ou max
• Um lado da partição sempre ficará sem
elementos

(série aritmetica)
Árvore do pior caso
T(n) = T(0) + T(n–1) + cn
Árvore do pior caso
T(n) = T(0) + T(n–1) + cn
T(n)
 Árvore do pior caso
T(n) = T(0) + T(n–1) + cn
cn
T(0) T(n–1)
 Árvore do pior caso
T(n) = T(0) + T(n–1) + cn

cn
T(0) c(n–1)

T(0) T(n–2)
 Árvore do pior caso
T(n) = T(0) + T(n–1) + cn
cn
T(0) c(n–1)

T(0) c(n–2)

T(0)
 Árvore do pior caso
T(n) = T(0) + T(n–1) + cn
cn
T(0) c(n–1)

T(0) c(n–2)
T(0)
Árvore do pior caso
T(n) = T(0) + T(n–1) + cn
 Análise do melhor caso
(acontece raramente)

Com sorte, PARTITION divide ao meio exato:

T(n) = 2T(n/2) + Θ(n)
= (mesmo do merge sort)
Mas se divisão é sempre ?

Qual é a solução para a recorrência?

Análise do “quase” melhor caso
T (n)
Análise do “quase” melhor caso
Análise do “quase” melhor caso
Análise do “quase” melhor caso

Folhas
 Análise do “quase” melhor caso

Folhas

Sorte
 Análise
Suponha que se alternem sorte e azar
L(n) = 2U(n/2) + Θ (n) sorte
U(n)= L(n –1) + Θ (n) azar
Resolvendo:
L(n) = 2(L(n/2 – 1) + Θ (n/2)) + Θ (n)
= 2L(n/2 – 1) + Θ (n)
= Θ (n lg n)
Sorte!
O que pode ser feito para se ter sorte em geral?
 Hoare
Hoare-Partition(A, p, r)
x = A[p]
i = p – 1
j = r + 1
while true
repeat
j = j - 1
until A[j] <= x // while ([j] > x)
repeat
i = i + 1
until A[i] >= x // while ([i] < x)
if i < j
swap( A[i], A[j] )
else return j
Hoare - Ex1 (pivot=5)
Hoare – Ex 2 (pivot=5)
 Hoare
• Quicksort original é mais rápido fazendo
menos trocas
• Vetor ordenado não faz nenhuma troca
• Vetor com todos os elementos repetidos
não tem O(n2) (é O(nlogn) )
 Quicksort randomizado
Idéia: Particionar em torno de um elemento ao
acaso.
• Tempo de execução é independente da ordem
da entrada
• Não existem suposições a serem feitas sobre
a distribuição de entrada.
• Nenhuma entrada específica leva ao pior caso.
• O pior caso é determinado somente pelo
gerador de números aleatórios
 Análise do quicksort randomizado
Seja T(n) o tempo de execução para o quicksort
randomizado com entrada n, assumindo um
gerador aleatório.
Para k = 0, 1, …, n–1, definimos o indicador de
variável aleatória
Se particionamento gera k : n–k–1 ,
caso contrário.
E[Xk] = Pr{Xk = 1} = 1/n, pois todos os
particionamentos tem a mesma probabilidade
assumindo que são distintos
Análise
 Calculando a expectancia

Tira a expectancia dos dois

lados
 Calculando a expectancia

Linearidade da expectancia
 Calculando a expectancia

Independência de Xk das outras

escolhas aleatórias
 Calculando a expectancia

Linearidade da expectancia; E[Xk] = 1/n .

Calculando a expectancia

Somas tem
termos idênticos
 Recorrencia

(Os k = 0, 1 termos podem ser absorvidos em Θ (n).)

Provar: E[T(n)] ≤ anlg n para uma constante a > 0 .
• Escolhe a grande o suficiente tal que an lg n
domina E[T(n)] para um n ≥ 2. suficientemente
pequeno
Usar:
Método da Substituição

Hipótese de indução
Método da Substituição
Método da Substituição

Expressado como desejado – residual.

Método da Substituição

se a é escolhido grande o suficiente

tal que an/4 domina o Θ(n).
 Quicksort na prática
• Quicksort é um ótimo algoritmo de uso geral
• Quicksort é tipicamente duas vezes mais rápido
que o merge sort.
• Quicksort pode se beneficiar substancialmente
de otimizações de código
• Quicksort tem bom desempenho mesmo em
sistemas com memória virtual e caching