Existem dois métodos de partição quicksort mencionados em Cormen:

Hoare-Partition(A, p, r)
x = A[p]
i = p - 1
j = r + 1
while true
    repeat
        j = j - 1
    until A[j] <= x
    repeat
        i = i + 1
    until A[i] >= x
    if i < j
        swap( A[i], A[j] )
    else
        return j

e:

Lomuto-Partition(A, p, r)
x = A[r]
i = p - 1
for j = p to r - 1
    if A[j] <= x
        i = i + 1
        swap( A[i], A[j] )
swap( A[i +1], A[r] )
return i + 1

Desconsiderando o método de escolha do pivô, em que situações uma é preferível à outra? Eu sei, por exemplo, que o Lomuto pré-forma relativamente mal quando há uma alta porcentagem de valores duplicados (ou seja, onde digamos que mais de 2/3 da matriz é o mesmo valor), onde Hoare se sai bem nessa situação.

Que outros casos especiais tornam um método de partição significativamente melhor que o outro?

Dimensão Pedagógica

Devido à sua simplicidade, o método de particionamento do Lomuto pode ser mais fácil de implementar. Há uma boa anedota em Programming Pearl, de Jon Bentley, sobre Classificação:

“A maioria das discussões sobre o Quicksort usa um esquema de particionamento baseado em dois índices que se aproximam [...] [isto é, de Hoare]. Embora a idéia básica desse esquema seja direta, sempre achei os detalhes complicados - uma vez passei a maior parte de dois dias perseguindo um bug escondido em um curto loop de particionamento. Um leitor de um rascunho preliminar reclamou que o método padrão de dois índices é de fato mais simples que o de Lomuto e esboçou algum código para expressar sua opinião; Parei de cuidar e encontrei dois insetos.

Dimensão de desempenho

Para uso prático, a facilidade de implementação pode ser sacrificada em prol da eficiência. Em uma base teórica, podemos determinar o número de comparações e swaps de elementos para comparar o desempenho. Além disso, o tempo de execução real será influenciado por outros fatores, como desempenho do cache e previsões incorretas de ramificações.

Como mostrado abaixo, os algoritmos se comportam de maneira muito semelhante em permutações aleatórias, exceto pelo número de swaps . Lá, Lomuto precisa de três vezes mais que Hoare!

Número de comparações

$n-1$$n$

Número de Swaps

O número de trocas é aleatório para os dois algoritmos, dependendo dos elementos na matriz. Se assumirmos permutações aleatórias , ou seja, todos os elementos são distintos e toda permutação dos elementos é igualmente provável, podemos analisar o número esperado de swaps.

$1,\ldots,n$

Método de Lomuto

$j$$A[j]$$x$$1,\ldots,n$$x-1$$x$$x-1$$x$

$\{1,\ldots,n\}$$\frac1n$

$n$

Método de Hoare

$x$

$i$$j$$x$$i$$j$

$x$

$\mathrm{Hyp}(n-1,n-x,x-1)$$n-x$$x-1$$(n-x)(x-1)/(n-1)$$x$

Por fim, calculamos a média novamente de todos os valores de pivô para obter o número geral esperado de swaps para o particionamento de Hoare:

(Uma descrição mais detalhada pode ser encontrada na minha tese de mestrado , página 29.)

Padrão de acesso à memória

Ambos os algoritmos usam dois ponteiros na matriz que a varrem sequencialmente . Portanto, ambos se comportam em cache wrt quase ideal.

Elementos iguais e listas já ordenadas

Como já mencionado pela Wandering Logic, o desempenho dos algoritmos difere drasticamente para listas que não são permutações aleatórias.

$n/2$

$0$$i$$j$$\mathcal O(n\log n)$

$0$A[j] <= x$i=n$$\Theta(n^2)$

Conclusão

O método do Lomuto é simples e fácil de implementar, mas não deve ser usado para implementar um método de classificação de bibliotecas.

Alguns comentários foram adicionados à excelente resposta de Sebastian.

Vou falar sobre o algoritmo de rearranjos de partição em geral e não sobre seu uso específico para o Quicksort .

Estabilidade

O algoritmo de Lomuto é semi - estável : a ordem relativa dos elementos que não satisfazem o predicado é preservada. O algoritmo de Hoare é instável.

Padrão de acesso ao elemento

O algoritmo do Lomuto pode ser usado com lista vinculada única ou estruturas de dados somente para frente semelhantes. O algoritmo de Hoare precisa de bidirecionalidade .

Número de comparações

$n-1$$n$

Mas, para fazer isso, temos que sacrificar 2 propriedades:

1. A sequência a ser particionada não deve estar vazia.
2. O algoritmo não pode retornar o ponto de partição.

$n$