Esistono due metodi di partizione quicksort menzionati in 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

Ignorando il metodo di scelta del perno, in quali situazioni è preferibile l'una all'altra? So ad esempio che Lomuto si preforma in modo relativamente scarso quando c'è un'alta percentuale di valori duplicati (cioè dove diciamo più di 2/3 l'array ha lo stesso valore), dove Hoare si comporta bene in quella situazione.

Quali altri casi speciali rendono significativamente migliore un metodo di partizione rispetto all'altro?

Dimensione pedagogica

Per la sua semplicità, il metodo di partizionamento di Lomuto potrebbe essere più semplice da implementare. C'è un bel aneddoto nella programmazione Pearl di Jon Bentley sull'ordinamento:

“La maggior parte delle discussioni su Quicksort utilizzano uno schema di partizionamento basato su due indici in avvicinamento [...] [ie Hoare's]. Sebbene l'idea di base di questo schema sia semplice, ho sempre trovato i dettagli difficili - una volta ho trascorso la maggior parte dei due giorni inseguendo un bug nascosto in un breve ciclo di partizionamento. Un lettore di una bozza preliminare si è lamentato del fatto che il metodo standard a due indici è in realtà più semplice di quello di Lomuto e ha abbozzato un po 'di codice per chiarire il punto; Ho smesso di occuparmi di aver trovato due bug. "

Dimensione delle prestazioni

Per un uso pratico, la facilità di implementazione potrebbe essere sacrificata per motivi di efficienza. Su base teorica, possiamo determinare il numero di confronti tra elementi e swap per confrontare le prestazioni. Inoltre, il tempo di esecuzione effettivo sarà influenzato da altri fattori, come le prestazioni di memorizzazione nella cache e le previsioni errate del ramo.

Come mostrato di seguito, gli algoritmi si comportano in modo molto simile su permutazioni casuali ad eccezione del numero di swap . Lomuto ha bisogno di tre volte più di Hoare!

Numero di confronti

$n-1$$n$

Numero di swap

Il numero di swap è casuale per entrambi gli algoritmi, a seconda degli elementi dell'array. Se assumiamo permutazioni casuali , ovvero tutti gli elementi sono distinti e ogni permutazione degli elementi è ugualmente probabile, possiamo analizzare il numero atteso di swap.

$1,\ldots,n$

Metodo di Lomuto

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

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

$n$

Metodo 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$

Infine, eseguiamo nuovamente la media su tutti i valori pivot per ottenere il numero complessivo previsto di swap per il partizionamento di Hoare:

(Una descrizione più dettagliata può essere trovata nella tesi del mio maestro , pagina 29.)

Pattern di accesso alla memoria

Entrambi gli algoritmi utilizzano due puntatori nell'array che lo scansionano in sequenza . Pertanto entrambi si comportano in modo quasi ottimale nella memorizzazione nella cache wrt.

Elementi uguali ed elenchi già ordinati

Come già accennato da Wandering Logic, le prestazioni degli algoritmi differiscono più drasticamente per gli elenchi che non sono permutazioni casuali.

$n/2$

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

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

Conclusione

Il metodo di Lomuto è semplice e facile da implementare, ma non dovrebbe essere utilizzato per implementare un metodo di ordinamento delle librerie.

Alcuni commenti aggiunti all'eccellente risposta di Sebastian.

Parlerò dell'algoritmo di riorganizzazione delle partizioni in generale e non del suo uso particolare per Quicksort .

Stabilità

L'algoritmo di Lomuto è semistabile : l'ordine relativo degli elementi che non soddisfano il predicato viene preservato. L'algoritmo di Hoare è instabile.

Pattern di accesso agli elementi

L'algoritmo di Lomuto può essere utilizzato con un elenco collegato singolarmente o strutture di dati forward-only simili. L'algoritmo di Hoare richiede bidirezionalità .

Numero di confronti

$n-1$$n$

Ma per fare questo dobbiamo sacrificare 2 proprietà:

1. La sequenza da partizionare non deve essere vuota.
2. L'algoritmo non è in grado di restituire il punto di partizione.

$n$