PROGRAMMAZIONE. Fusione Partizionamento Algoritmi avanzati di ordinamento. Prof.ssa Lanza - AA DIB 1/66

Transcript

1 PROGRAMMAZIONE Fusione Partizionamento Algoritmi avanzati di ordinamento Prof.ssa Lanza - AA DIB 1/66

2 Algoritmi su Array Algoritmi di base (conteggio, ricerca max/min, elimina duplicati, ) Algoritmi di supporto Partizionamento Fusione Ricerca Sequenziale Binaria (Basata su un ordinamento) Ordinamento Per selezione, Per scambio, Per inserzione Per fusioni successive, Per partizionamento (v.iterativa e ricorsiva) Prof.ssa Lanza - AA DIB 2/66

3 Tecniche Avanzate di Ordinamento Si può dimostrare che, in media, per dati casuali, gli elementi devono essere spostati di una distanza pari a n/3 rispetto alla loro posizione originaria Gli algoritmi semplici tendono a spostare solo gli elementi vicini e quindi necessitano di molti spostamenti in più per ordinare la lista Meno efficienza Gli algoritmi migliori sono in grado di scambiare, nelle prime fasi di ordinamento, valori che occupano posizioni molto distanti nella lista Prof.ssa Lanza - AA DIB 3/66

4 Partizionamento Dato un array non ordinato di n elementi, e un valore x dello stesso tipo degli elementi, partizionare gli elementi in due sottoinsiemi tali che Gli elementi x siano in un sottoinsieme Gli elementi > x siano nell altro sottoinsieme Esempio: a: x = 20 una possibile soluzione: > 20 Prof.ssa Lanza - AA DIB 4/66

5 Partizionamento Si potrebbe ordinare l array e trovare l indice dell elemento che separa i due sottoinsiemi > 20 Non richiesto suggerimento: l algoritmo non deve fare più di quanto venga richiesto Non necessario Da Matematica Discreta: P S unione P D = intero insieme (l unione delle parti copre l insieme originario e le parti a due a due non hanno intersezioni) Prof.ssa Lanza - AA DIB 5/66

6 Partizionamento Se è nota la posizione p che divide i due sottoinsiemi Alcuni elementi non vanno spostati Scorrendo l array da sinistra verso p, i valori x Scorrendo l array da destra verso p, i valori > x Alcuni elementi sono fuori posto Scambiare un elemento fuori posto da una parte con uno fuori posto dall altra parte. La posizione p può essere ricavata contando gli elementi x presenti nell array In tal caso, occorrono 2 scansioni dell array Determinare la posizione p Individuare e scambiare gli elementi fuori posto Si termina quando si arriva a p Prof.ssa Lanza - AA DIB 6/66

7 Partizionamento È possibile partizionare l array mediante una sola scansione? Si, procedendo dagli estremi verso il centro Mentre le due partizioni non si incontrano Estendere le partizioni sinistra e destra scambiando le coppie piazzate nella partizione sbagliata La posizione p sarà individuata automaticamente al termine della scansione Prof.ssa Lanza - AA DIB 7/66

8 Partizionamento Scansione effettuata tramite 2 indici i per la partizione sinistra Parte da 1 Incrementato j per la partizione destra Parte da n Decrementato Prof.ssa Lanza - AA DIB 8/66

9 Partizionamento Algoritmo Individuazione dei primi valori fuori posto Mentre l i-mo elemento è x e i < j Incrementare i Mentre il j-mo elemento è > x e i < j Decrementare j Mentre le partizioni non si sono incontrate Scambiare i valori nelle posizioni individuate Cercare i successivi valori fuori posto Al termine, j è la posizione p Limite inferiore per i valori > x nella partizione Prof.ssa Lanza - AA DIB 9/66

10 Partizionamento Note Implementative Gestione del caso in cui x è fuori dall intervallo dei valori assunti dall array Inserire un controllo supplementare dopo i cicli preliminari: Se il j-mo elemento è > x allora decrementa j Ciò assicura che k [1..j]: a[k] x Se x è maggiore di tutti gli elementi dell array, al termine dei cicli si ha i = j = n e il controllo non scatta Se x è minore di tutti gli elementi dell array, al termine del ciclo(1a) si ha i = 1, al termine del ciclo(1b) si ha j = 1 e a 1 non controllato, mentre dopo il controllo, j = 0 Prof.ssa Lanza - AA DIB 10/66

11 Partizionamento Esempio Dati x = n = 9 Il risultato è: i=1, j=n i=2, j= i=3, j= j=4 Dimensione di P S : p = 4 P D Partizione di destra ha dimensione: n-p Prof.ssa Lanza - AA DIB 11/66

12 Partizionamento Casi limite x = È già partizionato! P S è vuota P D coincide con l intera lista Tutti gli a[ j ] sono > x x = È già partizionato! P S coincide con l intera lista P D è vuota Tutti gli a[ i ] sono <= x Prof.ssa Lanza - AA DIB 12/66

13 inizio fine i = 1; j = n; Partizionamento Pseudo-codice mentre (i < j) e (a i <= x) esegui i = i + 1; /*estende P S verso il centro*/ mentre (i < j) e (a j > x) esegui j = j 1; /*estende P D verso il centro*/ se a j > x allora j = j 1; /* caso particolare: x a k k [1..n] */ mentre i < j esegui t = a i ; a i = a j ; a j = t; /* scambia */ i = i + 1; j = j 1; /* continua ad estendere P S e P D */ mentre (a i <= x) esegui i = i + 1; /*ricerca elemento da scambiare*/ mentre (a j > x) esegui j = j 1; /*ricerca elemento da scambiare*/ fine_mentre p = j; /* dimensione della P S */ Prof.ssa Lanza - AA DIB 13/66

14 Partizionamento Codice C Partition (a, 0, n-1, x, p) Nota 1: al posto di n posso usare una funzione che ritorni la lunghezza di un array - lenght(a) Prof.ssa Lanza - AA DIB 14/66

15 Partizionamento Programma Pascal begin i := 1; j := n; while (i < j) AND (a[i] <= x) do i := i + 1; while (i < j) AND (a[j] > x) do j := j 1; if a[j] > x then j := j 1; while i < j do begin t := a[i]; a[i] := a[j]; a[j] := t; i := i + 1; j := j 1; while (a[i] <= x) do i := i + 1; while (a[j] > x) do j := j 1; end; p := j; end; Prof.ssa Lanza - AA DIB 15/66

16 Ordinamento Veloce di Hoare (per partizionamento) Ordinamento basato sul partizionamento (partition-exchange) Noto come Quicksort in media è molto veloce Due versioni (iterativa, ricorsiva) tutti gli elementi + piccoli tutti gli elementi + grandi Il partizionamento aumenta il preordinamento Si riduce la dimensione del problema Ogni partizione può essere trattata separatamente Prof.ssa Lanza - AA DIB 16/66

17 Ordinamento Veloce Il partizionamento richiede un valore x (pivot o perno) in base al quale separare gli elementi. Come scegliere il pivot? Scelto a caso Potrebbe essere esterno ai valori della lista Avremmo una partizione vuota! Prenderne uno della lista stessa Scegliere il primo della lista (versione per EUCIP) Il tempo di esecuzione dipende dal fatto che il partizionamento sia o meno bilanciato Elemento mediano» Elemento in posizione media» Posizione media: (limite inferiore+limite superiore) /2 Prof.ssa Lanza - AA DIB 17/66

18 Ordinamento Veloce Situazione dopo il partizionamento: Parte sinistra Elementi minori dell elemento mediano Parte destra Elementi maggiori dell elemento mediano Sone escluse le interazioni fra partizioni Nessun elemento della parte sinistra potrà mai, nell ordinamento, finire nella parte destra Ciascuna può essere trattata (ordinata) separatamente Ciascuna contiene meno elementi della lista completa Prof.ssa Lanza - AA DIB 18/66

19 Ordinamento Veloce Per ciascuna delle 2 partizioni ottenute valgono le stesse considerazioni precedenti Problemi analoghi a quello iniziale (ordinamento) Dimensione minore Riapplichiamo su ciascuna i concetti già esposti Si ottengono, per ciascuna partizione, altre 2 partizioni Situazione dopo un certo numero di passi: elementi I partizione < elementi II partizione < < elementi n-ma partizione Criterio di stop: partizioni di un solo elemento Non ulteriormente partizionabili Già ordinate Prof.ssa Lanza - AA DIB 19/66

20 Ordinamento Veloce Meccanismo Base Mentre tutte le partizioni non risultano ancora ridotte a dimensione 1 esegui Scegli la prossima partizione da elaborare Individua un nuovo valore di partizionamento per la partizione scelta (il mediano) Partiziona la partizione attuale in due insiemi più piccoli parzialmente ordinati rispetto al mediano attuale Prof.ssa Lanza - AA DIB 20/66

21 Ordinamento Veloce Ogni passo genera 2 nuove partizioni Si può agire su una sola partizione alla volta! L elaborazione dell altra resta in sospeso Possibile esistenza, in un certo momento, di partizioni create in attesa di elaborazione Necessità di ricordarne i limiti destro e sinistro Salvare l informazione sui limiti di ciascuna» posizioni dell array originale Prof.ssa Lanza - AA DIB 21/66

22 Ordinamento Veloce Memorizzazione dei limiti delle partizioni lasciate in sospeso Ogni partizione richiede la memorizzazione di 2 valori che la individuano (gli estremi) Immagazzinati in un array di appoggio Relativi agli indici dell array di partenza 2 elementi dell array di appoggio per ogni partizione Scelta della prossima partizione Simulazione di una struttura a pila LastIn, First Out Prof.ssa Lanza - AA DIB 22/66

23 Ordinamento Veloce Man mano che il processo di partizionamento prosegue Il numero delle partizioni di cui salvare l informazione sui limiti aumenta (di 1) Le partizioni diventano più piccole Prof.ssa Lanza - AA DIB 23/66

24 Ordinamento Veloce Dimensione dell array di servizio Caso peggiore: 2 *(n 1) elementi Il partizionamento è il più sbilanciato possibile Si memorizzano n 1 partizioni lasciate in sospeso Ogni volta si elabora la partizione più grande Ogni volta la partizione più piccola contiene un solo elemento partizione elaborata per prima x Ciascuna partizione richiede 2 elementi Troppo Spazio! Cerchiamo di migliorare Prof.ssa Lanza - AA DIB 24/66

25 Ordinamento Veloce Ottimizzazione Elaborare per prima la partizione più piccola Minor numero di partizioni da tenere in sospeso Partizioni di dimensione 1 non generano altre partizioni Individuate e scartate subito dall elaborazione In ogni istante esiste una sola partizione in sospeso di cui vanno salvati i limiti corrispondono alla partizione più grande Prof.ssa Lanza - AA DIB 25/66

26 Ordinamento Veloce Ottimizzazione Ad ogni passo si elabora la più grande delle partizioni più piccole Attuale caso peggiore: 2 log 2 n Partizioni divise sempre a metà Dimensione dimezzata Caso peggiore senza ottimizzazione: 2*(n 1) elementi Accettabile! Prof.ssa Lanza - AA DIB 26/66

27 Ordinamento Veloce Test per decidere qual è la partizione più grande Se le partizioni cadono (si congiungono) a sinistra del medio Elabora la partizione sinistra (che è la più piccola) Salva i limiti di quella destra Altrimenti Elabora la partizione destra (che è la più piccola) Salva i limiti di quella sinistra La partizione più grande è sempre messa in attesa di elaborazione Gestione a pila Prof.ssa Lanza - AA DIB 27/66

28 Ordinamento Veloce Meccanismo di partizionamento e accodamento 1 a cd b a..c < d..b 2 a e f c f..c < a..e 3 f gh c f..g < h..c Top dello stack h.. c a.. e a.. e Array di servizio d.. b d.. b d.. b Prof.ssa Lanza - AA DIB 28/66

29 Ordinamento Veloce Quando si raggiunge una partizione di dimensione 1 si ricomincia il processo di partizionamento sulla partizione più recentemente memorizzata Limiti della partizione rimossi dalla cima della pila Quando tutte le partizioni sono state ridotte a dimensione 1 Pila vuota Terminazione del processo di partizionamento Prof.ssa Lanza - AA DIB 29/66

30 Ordinamento Veloce Algoritmo iterativo Definire l array a[1..n] da ordinare Inizializzare a 2 il puntatore al top dello stack Impostare i limiti sup e inf dell array nello stack a 1..n (si parte con 1 sola partizione coincidente con l intero array di partenza) Mentre lo stack non è vuoto esegui Estrai dal top dello stack la prossima partizione (limiti sup e inf del segmento di array corrispondente) Mentre il corrente segmento non è ridotto a dimensione 1 esegui Scegli l elemento mediano del segmento di array Partiziona il segmento in 2 rispetto al suo valore mediano Salva nello stack i limiti della partizione più grande Segmento corrente partizione più piccola Prof.ssa Lanza - AA DIB 30/66

31 Ordinamento Veloce Programma Pascal begin top := 2; stack[1] := 1; stack[2] := n; while top > 0 do begin right := stack[top]; left := stack[top 1]; top := top 2; while left > right do begin medio := (left + right) DIV 2; mediano := a[medio]; partiziona(a,left,right,mediano,pos); if pos < medio then begin stack[top+1] := pos+1; top := top + 2; stack[top] := right; right := pos end else begin stack[top+1] := left; top := top + 2; stack[top] := pos; left := pos+1 end end end end. Prof.ssa Lanza - AA DIB 31/66

32 Ordinamento veloce Versione Ricorsiva Algoritmo per natura ricorsivo Implementazione ricorsiva molto semplice Strategia divide et impera (applicazione dello stesso processo ad istanze del problema via via più piccole) Divide: l insieme di dati è ripartito in 2 partizioni in modo tale che tutti gli elementi della partizione sinistra (prime pos posizioni) siano di tutti gli elementi della parte destra (posizioni da pos+1 fino ad n) Impera: ordina le 2 partizioni riapplicando lo stesso meccanismo di partizionamento a[1..pos] e a[pos+1..n] fino ad ottenere segmenti di dimensione 1 Ricombina: Non è richiesto alcuno sforzo per ricombinare le 2 partizioni» A questo punto l intero array a[1..n] sarà ordinato Prof.ssa Lanza - AA DIB 32/66

33 Quicksort (v. ricorsiva) se card(a) = 1 allora A è ordinato /* passo base */ altrimenti -scegli un elemento pivot in A e ripartisci gli elementi di A in due sottoinsiemi, disponendo nella parte bassa gli elementi di A < del pivot e nella parte alta gli elementi di A > del pivot. -riapplica l algoritmo ai due sottoinsiemi /* due chiamate ricorsive */ fine_se Prof.ssa Lanza - AA DIB 33/66

34 Quicksort (v. ricorsiva) Situazione iniziale: Dati originali inf = 1 sup = n Dopo il primo partizionamento: partizione sinistra partizione destra inf pos sup Passi fondamentali dell algoritmo ricorsivo Se nell insieme corrente c è più di 1 elemento Partiziona i dati in partizione sinistra e destra Riapplica il partizionamento alla partizione sinistra Riapplica il partizionamento alla partizione destra Prof.ssa Lanza - AA DIB 34/66

35 Quicksort (v. ricorsiva) Indicatori di indice necessari: inf pos sup partition(a, inf, sup, mediano, pos) Ricorsione quicksort2(a, inf, pos) quicksort2(a, pos+1, sup) Terminazione della ricorsione Chiamata ad un segmento di 1 elemento Test: se inf < sup allora continua Nota: il modulo di partizionamento del quicksort può fare a meno del parametro mediano Prof.ssa Lanza - AA DIB 35/66

36 Quicksort Algoritmo Ricorsivo Se il segmento corrente da ordinare contiene più di 1 elemento allora Partizionalo in 2 segmenti più piccoli tali che tutti gli elementi del segmento di sinistra siano di tutti gli elementi del segmento di destra Se il segmento di sinistra è più piccolo del segmento di destra allora Altrimenti Quicksort il segmento di sinistra Quicksort il segmento di destra Quicksort il segmento di destra Quicksort il segmento di sinistra Prof.ssa Lanza - AA DIB 36/66

37 Quicksort Una implementazione C void quicksort2 (int a[max], int inizio, int fine) int q; if (inizio<fine) { partition (a, inizio, fine, q); quicksort2 (a, inizio, q); quicksort2 (a, q+1, fine); } } (Versione che non ottimizza la scelta della partizione) La libreria standard del C fornisce una implementazione efficiente del QuickSort denominata qsort( ) Prof.ssa Lanza - AA DIB 37/66

38 QuickSort versione per EUCIP (C++) void QuickSort (int *vettore, int IndiceSinistro, int IndiceDestro) { if (IndiceSinistro < IndiceDestro) { int Pivot = vettore[indicesinistro]; /*scelta del primo come pivot*/ int IS = IndiceSinistro; int ID = IndiceDestro +1; do { do IS++; while (vettore[is] < Pivot; do ID++; while (vettore[id] < Pivot; if (IS< ID) Scambia (vettore[is], vettore[ ID]); } while (IS < ID); Scambia (vettore[is], vettore [ID]); QuickSort (vettore, IndiceSinistro, ID-1); QuickSort (vettore, ID+1, IndiceDestro); } } // QuickSort Prof.ssa Lanza - AA DIB 38/66

39 Ordinamento Veloce Programma Pascal procedure quicksort2(var a: tipo_array; inf, sup: integer); var pos : integer; begin if inf < sup then begin medio := (inf + sup) DIV 2; mediano := a[medio]; partition(a, inf, sup, mediano, pos); if (pos inf) < (sup pos+1) then begin quicksort2(a, inf, pos); quicksort2(a, pos+1, sup) end else begin quicksort2(a, pos+1, sup); quicksort2(a, inf, pos) end end end; Prof.ssa Lanza - AA DIB 39/66

40 Ordinamento Veloce Considerazioni Il tempo di esecuzione dipende dal bilanciamento delle partizioni effettuate dall algoritmo di partizionamento (scelta del pivot) caso migliore: partizioni perfettamente bilanciate, entrambe di dimensione n/2 caso peggiore: una partizione è sempre di dimensione 1 (l altra sarà di dimensione n-1) Suddivisione successiva della sequenza in sottosequenze Rappresentazione tramite un albero binario Complessità: n log 2 n (tempo asintotico medio) Algoritmo ottimo! Prof.ssa Lanza - AA DIB 40/66

41 Ordinamento Veloce Considerazioni n n/2 n/2 n/4 n/4 n/4 n/4 n/8 n/8 n/8 n/8 n/8 n/8 n/8 n/8 sino ad ottenere n log 2 n Prof.ssa Lanza - AA DIB 41/66

42 Fusione (Merge) Fondere due array, già ordinati secondo il medesimo criterio, in un unico array ordinato secondo sempre lo stesso criterio a: b: c: Numero di elementi dell array c risultante pari alla somma degli elementi dei due array, m +n Necessità di esaminare tutti gli elementi dei due array dati Prof.ssa Lanza - AA DIB 42/66

43 Fusione I due array possono considerarsi come costituiti da sottosequenze da concatenare opportunamente nell array finale Suddividere ciascuno dei due array dati in una parte già fusa e una ancora da fondere In ogni istante, esaminare il primo elemento della parte da fondere dei due array Inserire il minore nella prima posizione dell array fuso Avanzare al prossimo elemento dell array da cui è stato preso Prof.ssa Lanza - AA DIB 43/66

44 Fusione Uno dei due array finirà per primo Copiare fino ad esaurimento gli elementi restanti nell array finale Individuabile dall inizio confrontando gli ultimi elementi dei due array Caso particolare: se l ultimo elemento di un array è minore del primo elemento dell altro, la fusione si riduce alla copiatura degli elementi dell uno seguita dalla copiatura degli elementi dell altro Prof.ssa Lanza - AA DIB 44/66

45 Fusione Esempio a: i=2 b: j=3 c: k=4 Prof.ssa Lanza - AA DIB 45/66

46 Fusione Algoritmo ingenuo Mentre ci sono elementi da considerare nei due array (i<m) e (j <n) Confronta i loro primi elementi non fusi e metti il più piccolo nell array finale Aggiorna l indice dell array appropriato Se è finito il primo array, allora Copia il resto del secondo nell array finale Altrimenti Copia il resto del primo nell array finale Prof.ssa Lanza - AA DIB 46/66

47 Fusione Una implementazione C void merge( int a[ ], int b[ ], int c[ ], int m, int n) { int i = 0, j= 0, k = 0; while ((i < m)&& (j < n)) if (a[i] < b[j]) {c[k] = a[i]; i=i+1; k=k+1}; else {c[k] = b[ j]; j=j+1; k=k+1}; while (i < m) c[k++] = a[ i++]; while (j < n) c[k++] = b[ j++]; } Prof.ssa Lanza - AA DIB 47/66

48 Fusione Modularizzazione Procedura merge Decide quale array finisce prima, quindi esegue la fusione di conseguenza Procedura mergecopy Distingue il caso di accodamento dalla fusione classica e fonde l array che finisce prima con l altro Procedura shortmerge Fonde le parti degli array ricadenti nello stesso intervallo Procedura copy Copia nell array risultato gli elementi di un array dalla posizione attuale fino alla fine La procedura da chiamare nel main è merge Prof.ssa Lanza - AA DIB 48/66

49 Fusione Procedura merge Definire gli array a[1..m] e b[1..n] Se l ultimo elemento di a è dell ultimo elemento di b allora Fondi tutto a con b mergecopy( a, b, c, m, n) Copia il resto di b copy Altrimenti Fondi tutto b con a mergecopy(b, a, c, n, m) Copia il resto di a copy Fornire il risultato c[1..n+m] Prof.ssa Lanza - AA DIB 49/66

50 Fusione Procedura mergecopy Definire gli array a[1..m] e b[1..n] con a[m] b[n] Se l ultimo elemento di a è al primo elemento di b allora (vengono evitati tutti i confronti) Copia tutto a nei primi m elementi di c copy Copia tutto b in c, partendo dalla posizione m+1 copy Altrimenti Fondi in c tutto a con b shortmerge Copia il resto di b in c partendo dalla posizione in cui è finita la fusione copy Prof.ssa Lanza - AA DIB 50/66

51 Fusione Procedura shortmerge Definire gli array a[1..m] e b[1..n] con a[m] b[n] Mentre tutto a non è ancora fuso esegui Se il corrente di a del corrente di b allora Copia il corrente di a nella corrente posizione di c Avanza l indice di a Altrimenti Copia il corrente di b nella corrente posizione di c Avanza l indice di b Avanza l indice di c Prof.ssa Lanza - AA DIB 51/66

52 Fusione Procedura shortmerge a: b: da fondere c: Situazione della fusione dopo che l array a si è esaurito Prof.ssa Lanza - AA DIB 52/66

53 Fusione Procedura copy Definire gli array b[1..n] e c[1..n+m] e definire da dove cominciare la copia da b (al corrente j) e in c (al corrente k) Mentre non è ancora finito b esegui Copia l elemento dalla corrente posizione in b nella corrente posizione in c Avanza l indice di b (ossia j) Avanza l indice di c (ossia k) Prof.ssa Lanza - AA DIB 53/66

54 Fusione Considerazioni L algoritmo non è adatto per fondere due insiemi di dati di cui non si conosca la cardinalità È una situazione frequente Occorre apportare modifiche Prof.ssa Lanza - AA DIB 54/66

55 Ordinamento per Fusioni Successive Algoritmo di MergeSort L idea di base è che l ordinamento di una lista di n elementi può essere ottenuto Dividendo la lista in due sequenze di n/2 elementi ciascuna Dimensione inferiore (esattamente dimezzata) Ordinando singolarmente ogni sequenza Problema di ordine inferiore Risolubile secondo la stessa tecnica» Procedura ricorsiva Fondendo le due metà ordinate in un unica sequenza Lista risultante ordinata Strategia fondata sul principio del divide et impera Prof.ssa Lanza - AA DIB 55/66

56 Ordinamento per Fusione Esempio Insieme iniziale Suddivisione in 2 sottoinsiemi Ordinamento di ogni singolo sottoinsieme Fusione dei sottoinsiemi ordinati Prof.ssa Lanza - AA DIB 56/66

57 MergeSort (sulla Ricorsione) Se l array da ordinare contiene n= 1 elemento, allora (per definizione) l array è già ordinato: è l assioma (anche se n=0 l array è ordinato) contiene n>1 elementi, si suddivide a metà l array iniziale, si ordinano le due metà e si fondono. Si arriva a suddividere l array iniziale in n sottoinsiemi costituiti da 1 elemento ciascuno, si riaggregano i sottoinsiemi fondendoli ordinatamente sino a ricostruire una unica sequenza ordinata. Prof.ssa Lanza - AA DIB 57/66

58 MergeSort (Implementazione C) void MergeSort(int a[ ]; int primo, ultimo) { int mid; if primo < ultimo /* a ha almeno 2 elementi */ { mid = (primo + ultimo) / 2; MergeSort(a, primo, mid); /* prima chiamata ricorsiva */ MergeSort(a, mid + 1, ultimo); /* seconda chiamata ricorsiva */ merge(a, primo, mid, ultimo); /* Att.ne: procedura iterativa diversa da quella definita in precedenza */ } } Prof.ssa Lanza - AA DIB 58/66

59 Ordinamento per Fusioni Successive (Pascal) procedure MergeSort(var a: nelements; primo, ultimo: integer); var q: integer; begin if primo < ultimo then begin q := (primo + ultimo) DIV 2; MergeSort(a, primo, q); MergeSort(a, q + 1, ultimo); merge(a, primo, q, ultimo) end end; Prof.ssa Lanza - AA DIB 59/66

60 Procedura Merge per MergeSort La procedura di fusione deve lavorare su segmenti diversi di uno stesso vettore Non può essere la stessa già definita per la fusione di due vettori distinti Occorre definire una nuova procedura che fonde due sottosequenze contigue di uno stesso vettore void merge(int a[ ]; int primo, mezzo, ultimo) Occorrono: un array di appoggio b per il risultato della fusione (alla fine b viene copiato in a) variabili locali usate come indici Prof.ssa Lanza - AA DIB 60/66

61 Merge per MergeSort (pseudo-codice) Merge( a, primo, mid, ultimo) inizio Sia i= primo e j = mid + 1 /* fondere a(primo..mid) con a(mid+1..ultimo)*/ k = primo mentre (i <= mid) e (j <= ultimo) esegui se a i < a j allora b k = a i ; i = i + 1; altrimenti b k = a j ; j = j + 1; fine_se k = k + 1 fine_mentre se i <= mid allora copia (a i a mid ) altrimenti copia (a j a ultimo ) fine_se copia l array b nell array a fine Merge Prof.ssa Lanza - AA DIB 61/66

62 Merge per il MergeSort (Pascal) begin i:= primo; k := primo; j := mezzo + 1; while (i <= mezzo) and (j <= ultimo) do begin if a[i] < a[j] then begin b[k] := a[i]; i := i + 1 end else begin b[k] := a[j]; j := j + 1 end; k := k + 1 end; if i <= mezzo then begin j := ultimo k; for h := j downto 0 do a[k+h] := a[i+h] for j := primo to k-1 do a[j] := b[j] end; end; Prof.ssa Lanza - AA DIB 62/66

63 Ordinamento per Fusioni Successive (Pascal) procedure ordina_per_fusioni(var a: nelements; n: integer); var b: nelements; procedure mergesort(var a,b: nelements; primo, ultimo: integer); var q: integer; procedure merge(var a,b: nelements; primo, ultimo, mezzo: integer); var i, j, k, h: integer; begin {merge} end; {merge} begin {mergesort} end {mergesort} begin {chiamante} mergesort(a, b, 1, n) end {chiamante} Prof.ssa Lanza - AA DIB 63/66

64 MergeSort Considerazioni Durante il processo di suddivisione, l insieme non viene in alcun modo modificato, i suoi elementi non sono né confrontati, né spostati. Viene operata una suddivisione dicotomica ricorsiva della sequenza iniziale da ordinare sino ad ottenere n sequenze di dimensione 1. Quando la procedura ricorsiva MergeSort viene chiamata per una sottosequenza di lunghezza 1, sarà primo=ultimo e la procedura termina senza compiere alcuna operazione. Il punto di forza dell algoritmo sta nel backtracking della ricorsione. Prof.ssa Lanza - AA DIB 64/66

65 MergeSort Considerazioni Durante il backtracking vengono fusi a due a due i sottoinsiemi ottenuti con la suddivisione ricorsiva. Durante la fusione gli elementi vengono posizionati in modo da ottenere una unica sottosequenza ordinata da 2 sottosequenze ordinate Si inizia la fusione con sequenze costituite da 1 solo elemento e, perciò, ordinate. La complessità computazionale è O(nlog 2 n) Non esistono casi più favorevoli di altri l algoritmo si comporta nello stesso modo a prescindere dalla disposizione iniziale degli elementi nella sequenza da ordinare. Prof.ssa Lanza - AA DIB 65/66

66 MergeSort Esempio n = 8 = 2 3 da ordinare: {3,15,6,2,7,4,12,8} {3,15,6,2} {7,4,12,8} {3,15} {6,2} {7,4} {12,8} {3} {15} {6} {2} {7} {4} {12} {8} {3, 15} {2, 6} lungh. 2 {4, 7} {8, 12} ordinato: {2, 3, 6, 15} lungh. 4 {4, 7, 8, 12} {2, 3, 4, 6, 7, 8, 12, 15} lungh.8 Le sottosequenze ordinate hanno lunghezza fissa: da 2 0 sino a 2 log 2 n (log 2 n = log = 3) Prof.ssa Lanza - AA DIB 66/66