algoritmi e strutture dati quicksort. algoritmo di ordinamento “sul posto” che ha tempo di...
TRANSCRIPT
![Page 1: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/1.jpg)
Algoritmi e Strutture Dati
QuickSort
![Page 2: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/2.jpg)
QuickSort
Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è:
� O(n2) nel caso peggiore� O(n log n) nel caso medio
Nonostante le cattive prestazioni nel caso peggiore, rimane il miglior algoritmo di ordinamento in media
![Page 3: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/3.jpg)
QuickSort
È basato sulla metodologia Divide et Impera:
Dividi: L’array A[p…r] viene “partizionato” (tramite spostamenti di elementi) in due sotto-array non vuoti A[p…q] e A[q+1…r] in cui:ogni elemento di A[p…q] è minore o uguale ad ogni
elemento di A[q+1…r]
Conquista: i due sottoarray A[p…q] e A[q+1…r] vengono ordinati ricorsivamente con QuickSort
Combina: i sottoarray vengono ordinati anche reciprocamente, quindi non è necessaria alcuna combinazione. A[p…r] è già ordinato.
![Page 4: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/4.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
![Page 5: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/5.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
Indice mediano
q è l’indice che divide l’array in due sottoarray dove tutti gli elementi a sinistra di q (compreso l’elemento
in posizione q) sono minori o uguali tutti gli elementi a destra di q
![Page 6: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/6.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
Ordinamento dei due sottoarray
Poiché il sottoarray di sinistra contiene elementi tutti minori o uguali a tutti quelli del sottoarray di destra, ordinare i due sottoarray separatamente fornisce la soluzione del problema
![Page 7: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/7.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
passo Dividi
Partition è la chiave di tutto l’algoritmo !
![Page 8: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/8.jpg)
Algoritmo Partiziona
L’array A[p…r] viene “suddiviso” in due sotto-array “non vuoti” A[p…q] e A[q+1…r] in cui ogni elemento di A[p…q] è minore o uguale ad ogni elemento di A[q+1…r]:l’algoritmo sceglie un valore dell’array che fungerà
da elemento “spartiacque” tra i due sotto-array, detto valore pivot.
sposta i valori maggiori del pivot verso l’estremità destra dell’array e i valori minori verso quella sinistra.
• q dipenderà dal valore scelto come pivot: sarà l’indice della posizione in cui si troverà alla fine l’elemento più grande minore o uguale al pivot.
![Page 9: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/9.jpg)
Algoritmo Partiziona
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
![Page 10: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/10.jpg)
Algoritmo Partiziona
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
Elemento Pivot
Gli elementi minori o uguali al Pivot verranno spostati tutti verso sinistraGli elementi maggiori o uguali al Pivot verranno spostati tutti verso destra
![Page 11: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/11.jpg)
Algoritmo Partiziona
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
La condizione true è sempre vera!
Il ciclo WHILE continua fino ...
![Page 12: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/12.jpg)
Algoritmo Partiziona
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
La condizione true è sempre vera!
Il ciclo WHILE continua fino all’esecuzione del return
![Page 13: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/13.jpg)
Algoritmo Partiziona
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
Cerca il primo elemento da destra che sia minore
o uguale al Pivot x
![Page 14: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/14.jpg)
Algoritmo Partiziona
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
Cerca il primo elemento da sinistra che sia maggiore o
uguale al Pivot x
![Page 15: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/15.jpg)
Algoritmo Partiziona
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
Se l’array non è stato scandito completamente (da destra e da sinisra):
• A[i] x• A[j] x
gli elementi vengono scambiati
![Page 16: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/16.jpg)
Algoritmo Partiziona
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
Se l’array è stato scandito completamente (da destra e
da sinisra) i j : j è l’indice mediano q dell’array
![Page 17: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/17.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
20 14 28 34 15 45 12 30 21 25 16 22
i j
x
![Page 18: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/18.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
20 14 28 34 15 45 12 30 21 25 16 22
i j
x
![Page 19: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/19.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
20 14 28 34 15 45 12 30 21 25 16 22i j
x
![Page 20: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/20.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
20 14 28 34 15 45 12 30 21 25 16 22i j
x
![Page 21: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/21.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 28 34 15 45 12 30 21 25 20 22i j
x
![Page 22: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/22.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 28 34 15 45 12 30 21 25 20 22i j
x
![Page 23: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/23.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 28 34 15 45 12 30 21 25 20 22
i j
x
![Page 24: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/24.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 28 34 15 45 12 30 21 25 20 22
i j
x
![Page 25: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/25.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 12 34 15 45 28 30 21 25 20 22
i j
x
![Page 26: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/26.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 12 34 15 45 28 30 21 25 20 22
i j
x
![Page 27: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/27.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 12 34 15 45 28 30 21 25 20 22
i j
x
![Page 28: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/28.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 12 15 34 45 28 30 21 25 20 22
i j
x
![Page 29: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/29.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 12 15 34 45 28 30 21 25 20 22
ij
x
![Page 30: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/30.jpg)
Algoritmo Partiziona: partiziona(A,1,12)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
16 14 12 15 34 45 28 30 21 25 20 22
ij
x
![Page 31: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/31.jpg)
Algoritmo Partiziona: casi estremi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
1 14 28 34 15 45 12 30 21 25 16 22
i j
x
Se esiste un solo elemento minore o uguale al pivot, ...
![Page 32: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/32.jpg)
Algoritmo Partiziona: casi estremi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
1 14 28 34 15 45 12 30 21 25 16 22
i j
x
Se esiste un solo elemento minore o uguale al pivot, ...
![Page 33: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/33.jpg)
Algoritmo Partiziona: casi estremi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
1 14 28 34 15 45 12 30 21 25 16 22
i j
x
Se esistono un solo elemento minore o uguale al pivot,
l’array è partizionato in due porzioni: quella sinistra ha
dimensione 1 e quella destra ha dimensione n-1
![Page 34: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/34.jpg)
Algoritmo Partiziona: casi estremi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
2 1 28 34 15 45 12 30 21 25 16 22
i j
x
Se esistono solo due elementi minori o uguali al
pivot, ...
![Page 35: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/35.jpg)
Algoritmo Partiziona: casi estremi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
2 1 28 34 15 45 12 30 21 25 16 22
i j
x
Se esistono solo due elementi minori o uguali al
pivot, ...
![Page 36: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/36.jpg)
Algoritmo Partiziona: casi estremi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
1 2 28 34 15 45 12 30 21 25 16 22
i j
x
Se esistono solo due elementi minori o uguali al
pivot, ...
![Page 37: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/37.jpg)
Algoritmo Partiziona: casi estremi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
1 2 28 34 15 45 12 30 21 25 16 22
j i
x
Se esistono solo due elementi minori o uguali al
pivot, ...
![Page 38: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/38.jpg)
Algoritmo Partiziona: casi estremi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
1 2 3 4 5 6 7 8 9 10 11 12
1 2 28 34 15 45 12 30 21 25 16 22
j i
x
Se esistono solo due elemento minori o uguali al
pivot, l’array è partizionato in due porzioni: quella sinistra
ha dimensione 1 e quella destra ha dimensione n-1
![Page 39: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/39.jpg)
Algoritmo Partiziona: casi estremi
Partiziona è quindi tale che:
SE il numero di elementi dell’array minori o uguali all’elemento A[p], scelto come pivot, è pari a 1 (cioè A[p] è l’elemento minimo) o a 2,
ALLORA le dimensioni delle partizioni restituite sono 1 per la partizione di sinistra e n - 1 per quella di destra.
![Page 40: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/40.jpg)
Algoritmo QuickSort
1 2 3 4 5 6 7 8 9 10 11 12
20 14 28 34 15 45 12 30 21 25 16 22p r
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
![Page 41: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/41.jpg)
Algoritmo QuickSort
1 2 3 4 5 6 7 8 9 10 11 12
20 14 28 34 15 45 12 30 21 25 16 22p r
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
![Page 42: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/42.jpg)
Algoritmo QuickSort
1 2 3 4 5 6 7 8 9 10 11 12
p r
16 14 12 15 34 45 28 30 21 25 20 22
q
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
![Page 43: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/43.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p r
16 14 12 15 34 45 28 30 21 25 20 22
q
5 6 7 8 9 10 11 12
34 45 28 30 21 25 20 22
![Page 44: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/44.jpg)
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
16 14 12 15 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
![Page 45: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/45.jpg)
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
16 14 12 15 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
![Page 46: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/46.jpg)
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
15 14 12 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
q
![Page 47: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/47.jpg)
4
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
15 14 12 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
q
16
![Page 48: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/48.jpg)
4
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
15 14 12 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
16
![Page 49: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/49.jpg)
4
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
16
q
![Page 50: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/50.jpg)
4
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
16
q
![Page 51: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/51.jpg)
4
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
16
3
15
![Page 52: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/52.jpg)
4
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
16
3
15
![Page 53: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/53.jpg)
4
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
16
q
![Page 54: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/54.jpg)
4
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
16
![Page 55: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/55.jpg)
4
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
16
![Page 56: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/56.jpg)
5 6 7 8 9 10 11 12
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
r
34 45 28 30 21 25 20 22
![Page 57: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/57.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
rq
![Page 58: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/58.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 34 45 28 30 21 25 20 22
r
![Page 59: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/59.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 22 20 28 30 21 25 45 34
rq
![Page 60: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/60.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 22 20 28 30 21 25 45 34
r
11 12
45 34
q
![Page 61: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/61.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 21 20 28 30 22 25 45 34
r
11 12
45 34
q
![Page 62: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/62.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 21 20 28 30 22 25 45 34
r
11 12
45 34
q
![Page 63: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/63.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 21 20 28 30 22 25 45 34
r
11 12
45 34
7 8 9 10
28 30 22 25
![Page 64: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/64.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
11 12
45 34
7 8 9 10
28 30 22 25
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 20 21 28 30 22 25 45 34
rq
![Page 65: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/65.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
11 12
45 34
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 20 21 28 30 22 25 45 34
rq
![Page 66: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/66.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
11 12
45 34
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 20 21 28 30 22 25 45 34
r
![Page 67: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/67.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
11 12
45 34
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 20 21 25 22 30 28 45 34
rq
![Page 68: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/68.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
11 12
45 34
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 20 21 22 25 28 30 45 34
rq
![Page 69: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/69.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 20 21 22 25 28 30 45 34
rq
![Page 70: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/70.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 20 21 22 25 28 30 45 34
r
![Page 71: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/71.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 20 21 22 25 28 30 34
45rq
![Page 72: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/72.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
p
12 14 15 16 20 21 22 25 28 30 34 45
rq
![Page 73: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/73.jpg)
Algoritmo QuickSort
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
1 2 3 4 5 6 7 8 9 10 11 12
12 14 15 16 20 21 22 25 28 30 34 45
L’array A ora è ordinato!
![Page 74: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/74.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
![Page 75: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/75.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
2 Casi. Partiziona effettua: • nessuno spostamento• almeno uno spostamento
1 2 3 4 5 6 7 8 9 10 11 12
1 14 12 15 34 45 28 30 21 25 20 45
j
p rx
i
![Page 76: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/76.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
1 2 3 4 5 6 7 8 9 10 11 12
1 14 12 15 34 45 28 30 21 25 20 45
j
p rx
… REPEAT j = j - 1 UNTIL A[j] x REPEAT i = i + 1 UNTIL A[i] x …
i
![Page 77: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/77.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
1 2 3 4 5 6 7 8 9 10 11 12
1 14 12 15 34 45 28 30 21 25 20 45
p rx
nessuno spostamento A[ j ] x per j pA[i ] x per i p
… REPEAT j = j - 1 UNTIL A[j] x REPEAT i = i + 1 UNTIL A[i] x …
ij
![Page 78: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/78.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
1 2 3 4 5 6 7 8 9 10 11 12
21 14 12 15 34 45 28 30 1 25 20 45
p rx
… REPEAT j = j - 1 UNTIL A[j] x REPEAT i = i + 1 UNTIL A[i] x …
ji
![Page 79: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/79.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
… REPEAT j = j - 1 UNTIL A[j] x REPEAT i = i + 1 UNTIL A[i] x …
ji
1 2 3 4 5 6 7 8 9 10 11 12
21 14 12 15 34 45 28 30 1 25 20 45
p rx
![Page 80: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/80.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
1 2 3 4 5 6 7 8 9 10 11 12
p rx
dopo il primo spostamento, esiste un k tale che
A[k ] x per p k jesiste un z tale che
A[z ] x per i z r
ji
20 14 12 15 34 45 28 30 1 25 21 45
…IF i < j THEN “scambia A[i] con A[j]” ELSE return j…
![Page 81: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/81.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
p r
In generale, dopo ogni scambio:- un elemento minore o uguale ad x viene spostato tra p e j -1- un elemento maggiore o uguale ad x viene spostato tra i +1 e r
… REPEAT j = j - 1 UNTIL A[j] x REPEAT i = i + 1 UNTIL A[i] x …
x
20 14 12 15 34 45 28 30 1 25 21 45 1 2 3 4 5 6 7 8 9 10 11 12
ji
![Page 82: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/82.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
j
p r
In generale, dopo ogni scambio:- tra p e j -1 ci sarà sicuramente un elemento minore o uguale ad x- tra i +1 e r ci sarà sicuramente un elemento maggiore o uguale ad x
i … REPEAT j = j - 1 UNTIL A[j] x REPEAT i = i + 1 UNTIL A[i] x …
x
20 14 12 15 34 45 28 30 1 25 21 45 1 2 3 4 5 6 7 8 9 10 11 12
![Page 83: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/83.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
j
p r
In generale, dopo ogni scambio:- tra p e j -1 ci sarà sicuramente un elemento minore o uguale ad x- tra i +1 e r ci sarà sicuramente un elemento maggiore o uguale ad x
i…IF i < j THEN “scambia A[i] con A[j]” ELSE return j…
x
20 14 12 15 1 45 28 30 34 25 21 45 1 2 3 4 5 6 7 8 9 10 11 12
![Page 84: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/84.jpg)
Algoritmo Partiziona: analisi
Gli indici i e j che scandiscono il sottoarray non ne eccedono mai i limiti. Cioè vale sempre che i r e j p
j
p r
In generale, dopo ogni scambio:- tra p e j -1 ci sarà sicuramente un elemento minore o uguale ad x- tra i +1 e r ci sarà sicuramente un elemento maggiore o uguale ad x
i … REPEAT j = j - 1 UNTIL A[j] x REPEAT i = i + 1 UNTIL A[i] x …
x
20 14 12 15 1 45 28 30 34 25 21 45 1 2 3 4 5 6 7 8 9 10 11 12
![Page 85: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/85.jpg)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
Algoritmo Partiziona: analisi
)(1
)(1
![Page 86: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/86.jpg)
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
Algoritmo Partiziona: analisi
i e j non possono eccedere i limiti dell’array, i e j sono sempre rispettiva- mente crescente e decrescente l’algoritmo termina quando i j quindi il costo del while sarà proporzionale ad n, cioè (n)
1 2 3 4 5 6 7 8 9 10 11 12
21 14 12 15 34 45 28 30 1 25 20 45
p rx
ji
![Page 87: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/87.jpg)
Algoritmo Partiziona: analisi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
)(n
)(1
![Page 88: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/88.jpg)
Algoritmo Partiziona: analisi
Partiziona(A,p,r)
x = A[p]
i = p - 1
j = r + 1
WHILE true DO
REPEAT j = j - 1
UNTIL A[j] x
REPEAT i = i + 1
UNTIL A[i] x
IF i < j
THEN “scambia A[i] con A[j]”
ELSE return j
)()( nnT
![Page 89: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/89.jpg)
Analisi di QuickSort: intuizioni
Il tempo di esecuzione di QuickSort dipende dalla bilanciamento delle partizioni effet-tuate dall’algoritmo partiziona
� Il caso migliore si verifica quando le partizioni sono perfettamente bilanciate, entrambe di dimensione n/2
� Il caso peggiore si verifica quando una partizione è sempre di dimensione 1 (la seconda è quindi di dimensione n - 1)
![Page 90: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/90.jpg)
Analisi di QuickSort: caso migliore
Le partizioni sono di uguale dimensione:
T(n) = 2T(n/2) + (n)
e per il caso 2 del metodo principale:
T(n) = (n log n)
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
![Page 91: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/91.jpg)
Analisi di QuickSort: caso migliore
Le partizioni sono di uguale dimensione:
T(n) = 2T(n/2) + (n)
e per il caso 2 del metodo principale:
T(n) = (n log n)
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
Quando si verifica il caso migliore, ad esempio?
![Page 92: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/92.jpg)
Analisi di QuickSort: caso peggiore
q
p r
1 | 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9 10 11 12
Pivot = 1
q
p r
2 | 3 4 5 6 7 8 9 10 11 12
2 3 4 5 6 7 8 9 10 11 12
Pivot = 2
q
p r
3 | 4 5 6 7 8 9 10 11 12
3 4 5 6 7 8 9 10 11 12
Pivot = 3
![Page 93: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/93.jpg)
Analisi di QuickSort: caso peggiore
La partizione sinistra ha dimensione 1 mentre quella sinistra ha dimensione n - 1:
T(n) = T(1) + T(n - 1) + (n)
poiché T(1) = 1 otteniamo
T(n) = T(n - 1) + (n)
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
![Page 94: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/94.jpg)
Analisi di QuickSort: caso peggiore
L’equazione di ricorrenza può essere risolta facilmente col metodo iterativo
T(n) = T(n - 1) + (n) =
= (n2)
n
kk
1)(
n
kk1
![Page 95: Algoritmi e Strutture Dati QuickSort. Algoritmo di ordinamento “sul posto” che ha tempo di esecuzione che teoricamente è: O(n 2 ) nel caso peggiore](https://reader035.vdocuments.pub/reader035/viewer/2022062702/5542eb77497959361e8e14ac/html5/thumbnails/95.jpg)
Analisi di QuickSort: caso peggiore
La partizione sinistra ha dimensione 1 mentre quella sinistra ha dimensione n - 1:
T(n) = T(n - 1) + (n) =
= (n2)
Quick-Sort(A,p,r)
IF p < r
THEN q = Partiziona(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
Quando si verifica il caso peggiore, ad esempio?