la complessità media o(n log n) di quick-sort vale soltanto se tutte le permutazioni dellarray in...
TRANSCRIPT
La complessità media O(n log n) di Quick-Sort vale soltanto se tutte le permutazioni dell’array in ingresso sono ugualmente probabili.
In molte applicazioni pratiche questo non è vero!!!
Vi sono applicazioni in cui le permutazioni quasi ordinate sono molto più probabili e questo può aumentare la complessità media fino ad O(n2).
Randomized-Partition(A,p,r) i = Random(p,r) scambia A[i] e A[r] return Partition(A,p,r)
Randomized-Quicksort(A,p,r) if p < r then q = Randomized-Partition(A,p,r) Randomized-Quicksort(A,p,q-1) Randomized-Quicksort(A,q+1,r)
Complessità del problema
Se non facciamo ipotesi sul tipo degli elementi della sequenza le uniche operazioni permesse sono confronti e assegnazioni.
Problema dell’ordinamento
Input: sequenza a1,a2,...,an di elementi su cui è definito un ordine
Output: a'1,a'2,...,a'n permutazione di a1,a2,...,an tale che a'1 ≤ a'2 ≤ ... ≤ a'n
Siccome siamo interessati ad un limite inferiore possiamo contare solo alcune delle operazioni.Se un certo limite inferiore vale per il tempo richiesto per eseguire tali operazioni a maggior ragione varrà per il tempo calcolo totale.
Noi conteremo solo i confronti e dimostreremo che nel caso pessimo il numero di confronti è Ω(n log n).
Per fare questo è utile rappresentare la struttura di un algoritmo mediante un albero delle decisioni.
1:2
1:2
2:32:3
1:2>≤≤ >
Esempio. Albero delle decisioni di Insertion-Sort con un array di 3 elementi.
≤ >
≤ >≤ >
Insertion-Sort(A) n = A.length for j = 2 to n i = j – 1 while i ≥ 1 and A[i]>A[i+1] scambia A[i] con A[i+1] i = i – 1
Per dimostrare il limite inferiore etichettiamo l’albero delle decisioni nel seguente modo:
- la radice è etichettata con la sequenza in input a1,a2,...,an (che per semplicità assumiamo sia una permutazione di 1,2,...,n).
- le foglie sono etichettate con la sequenza risultato che deve essere una permutazione ordinata di a1,a2,...,an; nel nostro caso la sequenza 1,2,...,n.
Se l’algoritmo è corretto a permutazioni distinte in input devono corrispondere cammini distinti nell’albero. Perché?
1:2
a,b,c
a,b,c(1,2,3)
a,c,b(1,2,3)
c,b,a(1,2,3)
>≤b,c,a
(1,2,3)
b,a,c(1,2,3)≤ >
c,a,b(1,2,3)
Esempio. Albero delle decisioni di Insertion-Sort con un array di 3 elementi.
2:3a,b,c ≤ >
2:3b,a,c
≤ >1:2
b,c,a≤ >
1:2a,c,b
Le permutazioni di 1,2,...,n sono n! e quindi l’albero delle decisioni deve avere almeno n! foglie.
Dunque nel caso pessimo l’algoritmo deve eseguire almeno log2(n!) confronti.
Ma un albero binario con N foglie deve avere altezza almeno pari a log2(N).
Esercizio: Dimostrarlo per induzione su N.
e quindi per ogni algoritmo generale di ordinamento.
Ma
Possiamo concludere che Ω(n log n) è un limite inferiore per la complessità del problema dell’ordinamento.
)log()(max nnnT Alg
)log(2
log2
1
2log
2
2log)!(log
22
2
22
nn
nnn
nn
nn
n
L’algoritmo di ordinamento Heapsort risolve il problema dell’ordinamento con complessità massima
)log()(max nnOnT HS
Dunque O(n log n) è limite superiore per la complessità del problema dell’ordinamento.
Siccome limite superiore e inferiore coincidono (n log n) è limite stretto per il problema dell’ordinamento.
Considerazione sul limite inferiore Ω(n log n) per l’ordinamento
ATTENZIONE:
Il limite inferiore Ω(n log n) da noi dimostrato vale solo per algoritmi di ordinamento generali, ossia algoritmi che non fanno alcuna ipotesi sul tipo degli elementi da ordinare: le uniche operazioni ammesse su tali elementi sono confronti e assegnazioni.
Il limite inferiore Ω(n log n) vale anche per ordinare numeri reali sui quali, oltre a confronti ed assegnazioni, si possono usare anche le quattro operazioni aritmetiche.
In questo caso la dimostrazione del limite inferiore è molto più difficile e si basa su alcuni risultati di geometria algebrica.
La dimostrazione si può trovare nel testo di Geometria Computazionale di F. Preparata.
Possiamo usare il limite Ω(n log n) per l’ordinamento per dimostrare limiti inferiori per altri problemi.
La tecnica che si usa è quella della riduzione dei problemi.
Illustriamo questa tecnica con un esempio.
Il problema dell’involucro convesso: “Dati n punti del piano trovare il più piccolo poligono convesso che li contiene tutti”
piq4
q2 q1
q7
q5
q8
q6
q9q3
Input: p1,…,pn in ordine qualsiasiOutput: q1,…,qm in ordine antiorario
Sia Alg un algoritmo qualsiasi che risolve il problema dell’involucro convesso.
Lo possiamo utilizzare per ordinare una sequenza a1,a2,...,an di numeri reali nel modo seguente :
A = (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
Q = (q1, q2, q3, q4, q5, q6, q7, q8, q9, q10)
A = (x8, x9, x10, x1, x2, x3, x4, x5, x6, x7)
p1
a1
a12
x
y
P = (p1, p2, p3, p4, p5, p6, p7, p8, p9, p10) ),( 2iii aap
q7
q8
q5
q4
q3
q2
q1
q10
q9
q6
x8
2xy
a. Costruiamo i punti p1,p2,...,pn di coordinate pi (ai , ai
2 ) Tempo Θ(n).
b. Usiamo Alg per trovare l’involucro convesso q1,q2,...,qn Tempo TAlg(n).
c. Cerchiamo qk con coordinata x minima Tempo Θ(n).
d. Prendiamo le coordinate x dei punti q1,q2,...,qn nell’ordine xk, ... ,xn,x1, ... ,xk-1 Tempo Θ(n).
))(( lg nTn A
Abbiamo un algoritmo di ordinamento di complessitàSe Alg avesse complessità massima inferiore a (n log n) potremmo ordinare un array di reali in tempo inferiore a (n log n).
))(( lg nTn A
Questo è impossibile a causa del limite inferiore Ω(n log n) per il problema dell’ordinamento.
Quindi Ω(n log n) è limite inferiore anche per il problema dell’involucro convesso.
Ordinamento in tempo lineare Il limite inferiore Ω(n log n) vale per tutti gli algoritmi di ordinamento generali, ossia per algoritmi che non fanno alcuna ipotesi sul tipo degli elementi della sequenza da ordinare.
Se facciamo opportune ipotesi restrittive sul tipo degli elementi possiamo trovare algoritmi più efficienti. Naturalmente il limite inferiore banale Ω(n) vale comunque per tutti gli algoritmi di ordinamento.
Algoritmo Counting-Sort
Per ordinare un array A Counting-Sort richiede un secondo array B in cui mette la sequenza ordinata e un array ausiliario C[0..k].
Assume che gli elementi dell’array siano interi compresi tra 0 e k con k costante.
C 2 2 3 0 10 1 2 3 4
B1 2 3 4 5 6 7 8
A 1 4 2 0 1 2 0 21 2 3 4 5 6 7 8
C 2 4 7 7 80 1 2 3 4
2
6
0
1
2
5
1
3
0
0
2
4
4
7
1
2
Counting-Sort(A,B,k) // A contiene a1,...,an
for i = 0 to k C[i] = 0 for j = 1 to A.length x = A[j], C[x] = C[x] + 1 // C[x] è il numero di elementi aj = x
for i = 1 to k C[i] = C[i] + C[i-1] // C[x] è il numero di elementi aj ≤ x
for j = A.length downto 1 // i = C[x] è la posizione in B dove // mettere il prossimo aj = x
x = A[j], i = C[x], B[i] = x C[x] = C[x] - 1
Counting-Sort(A,B,k) // Complessità for i = 0 to k // C[i] = 0 // for j = 1 to A.length // x = A[j], C[x] = C[x] + 1 // for i = 1 to k // C[i] = C[i] + C[i-1] // for j = A.length downto 1 // x = A[j], i = C[x], B[i] = A[j] // C[x] = C[x] - 1 //
)(n
)(k
)(k
)(n
Complessità: TCS(n,k) = (n+k)
Se k = O(n) allora TCS(n,k) = (n)
Osservazione: Nell’ultimo ciclo for dell’algoritmo gli elementi dell’array A vengono copiati nell’array B partendo dall’ultimoCosa succede se partiamo dal primo?
B1 2 3 4 5 6 7 8
A 1 4 2 0 1' 2' 0' 2"1 2 3 4 5 6 7 8
C 2 4 7 7 80 1 2 3 4
1
3
4
7
2
6
0
1
1'
Succede che l’algoritmo è ancora corretto ma gli elementi uguali vengono ricopiati in ordine inverso.
Quando un algoritmo di ordinamento mantiene l’ordine iniziale tra due elementi uguali si dice che esso è stabile.
L’algoritmo Counting-Sort (con l’ultimo ciclo for decrescente) è stabile.
Algoritmo Radix-SortAssume che i valori degli elementi dell’array siano interi rappresentabili con al più d cifre in una certa base b.
Per ordinare l’array si usa d volte un algoritmo di ordinamento stabile (ad esempio Counting-Sort) per ordinare l’array rispetto a ciascuna delle d cifre partendo dalla meno significativa.
Ad esempio interi di d = 5 cifre decimali (b = 10), interi di d = 4 byte (cifre in base b = 256) o stringhe di d caratteri (b = 256).
4 3 2 1
1 4 2 7
0 2 4 1
7 5 2 5
3 1 6 2
9 8 9 0
1 2 3 9
8 2 2 3
0 0 3 9
A[1]
A[2]
A[3]
A[4]
A[5]
A[6]
A[7]
A[8]
4 3 2 1
1 4 2 7
0 2 4 1
7 5 2 5
3 1 6 2
9 8 9 0
1 2 3 9
8 2 2 3
0 0 3 9
4 3 2 1
1 4 2 7
0 2 4 1
7 5 2 5
3 1 6 2
9 8 9 0
1 2 3 9
8 2 2 3
0 0 3 9
4 3 2 1
1 4 2 7
0 2 4 1
7 5 2 5
3 1 6 2
9 8 9 0
1 2 3 9
8 2 2 3
0 0 3 94 3 2 1
1 4 2 7
0 2 4 1
7 5 2 5
3 1 6 2
9 8 9 0
1 2 3 9
8 2 2 3
0 0 3 9