Presentazione di PowerPoint

1
Algoritmi di ordinamento ottimali

• Lalgoritmo Merge-Sort ha complessità O(n log(n))
  ? Algoritmo di ordinamento ottimale.
• A differenza degli algoritmi IS e SS, Merge-Sort
  non è però un algoritmo di ordinamento in loco.
  Infatti, la procedura Merge() richiede un vettore
  di appoggio in cui effettuare la fusione
• Ciò comporta (insieme alla gestione della
  struttura ricorsiva) una spesa in termini di
• Tempo (Nota non modifica landamento
  asintotico, ma si riflette sulle costanti
  moltiplicative)
• Spazio.

2
Algortimo di ordinamento heapsort

• Introduciamo un nuovo algoritmo di ordinamento
  detto Heap-Sort che ha le seguenti
  caratteristiche
• - T(n) O(n log(n)) ? Alg. Ordinamento
  ottimale
• Ordina in loco.
• Per fare ciò dobbiamo introdurre una struttura di
  dati detta heap.

Heap binario albero binario in cui ogni nodo
figlio ha valore minore o uguale al valore del
proprio nodo padre.
Es.
16
10
14
9
3
7
8
1
4
2
Lalbero è quasi completo ? Completo su tutti i
livelli tranne eventualmente sul livello più
basso che è riempito da sinistra.
Altezza dellalbero ? lunghezza del più lungo
cammino discendente dalla radice ad una foglia.
3
Proprietà di un heap
Notiamo che

16
10
14
In questa direzione è presente un ordinamento
9
3
7
8
1
4
2
In questa direzione non è presente un
ordinamento.

• Proprietà di ordinamento parziale dello heap
• Ogni nodo interno contiene un valore maggiore
  uguale del valore contenuto nei figli. Da ciò
  segue che
• lelemento più grande dello heap è memorizzato
  nella radice.
• ogni nodo interno contiene un valore maggiore
  uguale del valore contenuto in tutti i suoi
  discendenti.

4
Come rappresentare uno heap
Albero binario Insieme di elementi su cui è
definita una relazione di parentela.
i1
16
3
2
10
14
7
6
5
4
9
3
7
8
9
10
8
1
4
2
Un albero binario quasi completo può essere
descritto da un array in cui il figlio sinistro
ed il figlio destro di un nodo i si trovano nelle
posizioni 2i e 2i1 rispettivamente.
i1
2
3
4
5
6
7
8
9
10


LengthA
16
14
10
8
7
9
3
2
4
1



Heap-sizeA
N.B. Stiamo assumendo che lindice i parta da 1.
5
i1
16
3
2
10
14
7
6
5
4
9
3
7
8
9
10
8
1
4
2
i1
2
3
4
5
6
7
8
9
10


LengthA
16
14
10
8
7
9
3
2
4
1



Heap-sizeA
Heap-sizeA ? LengthA
Per muoverci allinterno dellalbero definiamo le
seguenti procedure
Right(i) Return 2i1
Left(i) Return 2i
Parent(i) return?i/2?
Affinché un array A che rappresenta un albero
binario sia uno heap deve valere la
relazione A(parenti) ? Ai per
ogni i ? 1
6
Mostreremo che un array generico può essere
ordinato trasformandolo in un heap ed eseguendo
operazioni che hanno tempo di esecuzione al più
proporzionale alla altezza H dello
heap. Notiamo H3 H
altezza albero binario Se lalbero è
completo Nnodi 1 2 22 2H 2H( 1
(1/2) (1/2)H)
2H(2-(1/2)H) 2H1 1 Se
lalbero non è completo 2H -1 lt Nnodi lt 2 H1
1 ? H ?(log(n))
i1
16
3
2
10
14
7
6
5
4
9
3
7
8
9
10
8
1
4
2
7
Algoritmo Heapsort - strategia

• L idea di base è la seguente
• Trasformiamo un array A di dimensione n in un
  heap di dimensione n (creazione dellheap)
• Passo 1 Per le proprietà dello heap, sappiamo
  che lelemento massimo della sequenza iniziale è
  memorizzato in A1. Scambiamo A1 con
  lelemento An
• La sequenza A1An-1 che otteniamo non è più
  uno heap (A1 è fuori posto). Permutiamo i suoi
  elementi in moto da trasformarla in un heap di
  dimensione n-1 (mantenimento dellheap)
• Passo 2 Per le proprietà dello heap, sappiamo
  che lelemento massimo della sequenza
  A1An-1 è memorizzato in A1. Scambiamo
  A1 con lelemento An-1
• Ripetendo n-1 volte otteniamo una sequenza
  ordinata.
• Le operazioni che effettuiamo sono
• Creazione di un heap O(????)
• Agli step k1,2,n-1
• Scambio di due elementi O(1) (temporale e
  spaziale)
• Mantenimento dello heap O(????)
• Poiché abbiamo n-1 iterazioni se vogliamo
  T(n)O(nlog(n))
• - Creazione dello heap O(n log(n))

8
Procedura di mantenimento dellheap
Supponiamo che A sia uno heap. Alteriamo il
valore di A1. Larray che otteniamo non è più
un heap. I sottoalberi con radice in Aright(1)
ed Aleft(1) sono ancora heap. Dobbiamo scrivere
una procedura che permuti gli elementi
A1,A2,,Aheap-sizeA in modo da
ricostruire uno heap.
Heapify(A,i) l?left(i) r?right(i) If (l?
heap-sizeA) and (Al gt Ai) then
largest ? l else largest ? i If (r ?
heap-sizeA )and(Ar gt Alargest) then
largest ? r If (largest ? i) then
scambia(Ai, Alargest)
Heapify(A, largest)
La procedura Heapify fa scendere Ai nella
prima posizione utile. Ipotesi - I sottoalberi
con radice in Aright(i) ed Aleft(i) sono
heap. Tesi Qualunque sia il valore Ai, per
effetto della procedura Heapify(A,i), lalbero
con radice in Ai diviene uno heap. Tempo di
esecuzione di Heapify(A,i) ? O(hi) hi altezza
del nodo i (il livello più basso delle foglie ha
altezza 0)
9
Heapify - esempio
i1
16
3
2
10
4
7
6
5
4
9
3
7
14
9
10
8
1
8
2
i1
Lancio Heapify(A,2)
16
3
2
10
14
7
6
5
4
9
3
7
4
9
10
8
1
8
2
i1
16
3
2
10
14
7
6
5
4
9
3
7
8
9
10
8
1
4
2
10
Procedura di creazione di uno heap
La procedura Heapify può essere usata in modo
bottom-up per convertire un array A1n, in uno
heap di lunghezza n.
Build-heap(A) heap-sizeA ? lenghtA For i? ?
lenghtA/2? down to 1 do Heapify(A,i)
Build-heap attraversa i nodi non foglia dell
heap, dal basso verso lalto ed esegue heapify
su ciascuno di essi. ? Ad ogni step le ipotesi
necessarie per applicare heapify sono
automaticamente verificate.
Tempo di esecuzione di build-heap?
H altezza albero ? log2(n) Nnodi(h) numero di
nodi con altezza h ? n/2h1
Notare Si può costruire un heap da un array non
ordinato in tempo lineare!
11
Build-heap Un esempio
i1
4
3
2
3
1
7
6
5
4
9
10
16
2
9
10
8
7
8
14
i1
4
3
2
3
1
7
6
5
4
9
10
16
2
9
10
8
7
8
14
i1
4
3
2
3
1
7
6
5
4
9
10
16
14
9
10
8
7
8
2
12
Build-heap Un esempio (2)
i1
4
3
2
10
1
7
6
5
4
9
3
16
14
9
10
8
7
8
2
i1
4
3
2
10
16
7
6
5
4
9
3
1
14
9
10
8
7
8
2
i1
4
3
2
10
16
7
6
5
4
9
3
7
14
9
10
8
1
8
2
13
Build-heap Un esempio (3)
i1
16
3
2
10
4
7
6
5
4
9
3
7
14
9
10
8
1
8
2
i1
16
3
2
10
14
7
6
5
4
9
3
7
4
9
10
8
1
8
2
i1
16
3
2
10
14
7
6
5
4
9
3
7
8
9
10
8
1
4
2
E un heap!
14
Algoritmo Heapsort
Heapsort(A) Build-heap(A)
O(n) For i?
length(A) down to 2
O(n) do scambia(A1,Ai)
O(n)
HeapsizeA? HeapsizeA-1 O(n)
Heapify(A,1)
O(n log(n)) Tempo di
esecuzione ? O(n log(n))
Ordinamento in loco
Esempio
Input Alt4,1,3,2,16,9,10,14,8,7gt Build-heap(A) ?
A0 lt16,14,10,8,7,9,3,2,4,1gt
i1
scambio
16
3
2
10
14
7
6
5
4
9
3
7
8
9
10
8
1
4
2
15
Heap-size Heap-size -1
i1
1
3
2
10
14
7
6
5
4
9
3
7
8
9
10
8
16
4
2
Heapify(A,1)
i1
14
3
2
10
8
7
6
5
4
9
3
7
4
9
10
8
16
1
2
16
Scambio(A1,An-1)
i1
14
3
2
10
8
7
6
5
4
3
9
7
4
9
10
8
16
1
2
Heapify(A,1)
i1
1
3
2
10
8
7
6
5
4
9
3
7
4
10
8
16
14
2
E cosi via