Algoritmi di ordinamento per confronto di chiavi

Transcript

1 Algoritmi di ordiameto per cofroto di chiavi 1 Ua limitazioe iferiore sul umero di cofroti Si immagii di rappresetare tutte le permutazioi co u albero biario i cui ogi odo itero ha due figli (quidi il umero dei odi iteri è il umero delle foglie meo uo), le foglie soo i corrispodeza uo a uo co le permutazioi e i odi iteri corrispodoo ad ua relazioe d ordie fra due chiavi i e j per cui i tutte le permutazioi discedeti del figlio siistro i precede j e i tutte quelle discedeti del figlio destro i segue j. Ioltre la permutazioe corrispodete ad ua foglia è l uica coerete co l ordie stabilito dai odi iteri che si trovao sul cammio dalla radice alla foglia. Ad esempio alle sei permutazioi di tre chiavi può essere associato il seguete albero biario (l albero o è uico e o ecessariamete si fao gli stessi cofroti su odi del medesimo livello). I ogi caso, comuque vega costruito l albero, il umero di odi iteri, cioè di cofroti, è! 1. U algoritmo che per determiare u ordiameto si basi su cofroti, esegue, a secoda dell istaza, i cofroti corrispodeti al cammio dalla radice alla permutazioe dell ordiameto. Il caso peggiore, i termii di umero di cofroti, è quidi dato dal cammio più lugo, ovvero dalla profodità d dell albero. Si è visto che vale la relazioe d log (N + 1) 1 co N umero dei odi dell albero. Siccome N =! 1 si ha d log (!) 1 = log! 1

2 Siccome! > (/) /, che si ottiee da si ha (!) = k ( k + 1) = k ( k + 1) > d > log ( )/ = log max {k, k + 1} > Ω( log ) ( ) = La dimostrazioe che / log(/) Ω( log ) si può fare el seguete modo: si deve dimostrare che esistoo ua costate K > 0 ad u valore tali che ovvero che Prediamo ad esempio il valore K = 1/4. Allora cioè da cui = 4. log K log, log K log, log 4 log, 4 log, = log, Quidi qualsiasi algoritmo di ordiameto che si basi sul cofroto di chiavi o potrà mai avere complessità iferiore a O( log ) e gli algoritmi co tale complessità possoo essere cosiderati ottimali. Questo o sigifica che o possoo esistere algoritmi di ordiameto co complessità iferiori, ad esempio lieari. Vi soo ifatti algoritmi che o si basao sul cofroto di chiavi e che operao co complessità O() se alcue ipotesi sulle chiavi soo soddisfatte. Li esamieremo più avati. Isertio sort Le chiavi soo disposte i u vettore K. Ad ua geerica iterazioe j dell algoritmo le chiavi k 1,..., k j 1 soo ordiate, la chiave k j viee cofrotata co la chiave k j 1 ; se k j k j 1 allora le chiavi k 1,..., k j soo ordiate e si può procedere co l iterazioe successiva, altrimeti si cofrota k j co k j i, i :=, 3,... fio a trovare ua chiave p tale che k j k p, altrimeti, se tale chiave o esiste si poe p = 0; poi si spostao le chiavi da p + a j 1 di ua posizioe (cioè k i := k i 1 co i := j 1, j,..., p + ) e si sposta la chiave k j i posizioe p + 1 (cioè k p+1 := k j ). Dopo l ultima iterazioe tutte le chiavi soo ordiate. procedure isertiosort(k) { := K ; for j := to do { stop:=false; i := j 1; while stop i 1 do { stop:=k[j] > K[i];

3 i := i 1; } ; if stop the p := i + else p = 1; temp:=k[j]; for i := j 1 dowto p do K[i + 1] := K[i]; K[p]=temp } Nel caso peggiore soo richiesti j 1 cofroti all iterazioe j e globalmete si hao quidi = ( 1) O( ) cofroti Per aalizzare il caso medio si può ragioare che al mometo di cofrotare la chiave j co quelle precedeti, sarao richiesti mediamete circa j/ cofroti e quidi globalmete il umero di cofroti sarà la somma di ( )/ O( ). 3 Bubblesort procedure bubblesort(k) { b := while b > 1 do { a := 1; for i := to b do if K[i] > K[i 1]; the{ K[0] := K[i 1]; K[i 1] := K[i]; K[i] = K[0]; a := i } ; b := a 1; } Si eseguoo diverse scasioi del vettore delle chiavi scambiado di posto fra loro due chiavi adiaceti se soo ell ordie sbagliato. Coviee mateere i memoria l idice dell ultimo scambio effettuato. Alla fie della scasioe tutti gli elemeti dall idice dell ultimo scambio fio alla fie soo ecessariamete ordiati: l ultimo elemeto scambiato è più grade di tutti quelli che lo precedoo metre è più piccolo del successivo (altrimeti sarebbe stato scambiato) che a sua volta è più piccolo del successivo e così via. La scasioe viee ripetuta fio all idice dell ultimo scambio, fiché il vettore risulta ordiato. Il caso peggiore si ha quado i dati soo ordiati i ordie iverso. È immediato valutare O( ) cofroti di chiavi. Il caso migliore si ha co le chiavi già ordiate che richiede solo 1 cofroti. L aalisi del caso medio coduce ad ua complessità quadratica. 3

4 4 Quicksort L idea di quicksort è di dividere i dati i due isiemi tali che tutti gli elemeti di u isieme soo miori o uguali a tutti gli elemeti dell altro isieme. Questa divisioe viee realizzata scegliedo u elemeto a caso, detto pivot e poedo i u isieme gli elemeti miori o uguali al pivot e ell altro gli elemeti maggiori del pivot. Poi si ordiao i due isiemi ricorsivamete usado la stessa tecica. L isieme fiale ordiato si ottiee semplicemete elecado prima il primo isieme, poi il pivot e poi il secodo isieme. Nell algoritmo qui idicato il pivot è scelto come il primo elemeto del vettore da ordiare. procedure quicksort(k) { := K ; if = 0 = 1 the retur(k) else { (K 1, pivot, K )=partitio(k) retur(quicksort(k 1 ),pivot,quicksort(k )); } procedure partitio(k) { := K ; pivot:=k[1]; p 1 := 1;p := 1; for i := to do if K[i] < pivot the K 1 [p 1 ] := K[i]; p 1 := p else K [p ] := K[i]; p := p + 1; retur(k 1,pivot,K ); Se vi soo dati uguali è sez altro più rapido, aziché ripartire i due isiemi ed u elemeto, ripartire ivece i tre isiemi, il primo di elemeti tutti miori del pivot, il secodo di elemeti uguali al pivot e il terzo di elemeti maggiori del pivot. Ad esempio el caso estremo di tutti dati uguali, basta u iterazioe co questa variazioe, altrimeti si ricade el caso peggiore, aalizzato qui sotto. Aalisi del caso peggiore: Le operazioi da cosiderare ella valutazioe della complessità soo essezialmete i cofroti da effettuare el mometo della partizioe. La restituzioe del vettore ordiato da parte della procedura quicksort (elle sue varie chiamate) è liearmete correlata co gli ordiameti. Il umero di cofroti ella prima applicazioe di quicksort è 1. Dopo avere ripartito l isieme i due isiemi di 1 e elemeti, i cofroti da effettuare soo se 1 1 e 1, e se 1 = 0 oppure = 0 (etrambi ulli o possoo essere perché per = 1 l isieme o viee più suddiviso). Siccome 1 + = 1, il umero di cofroti di questa secoda fase è 3 oppure. Proseguedo gli isiemi verrao a loro volta suddivisi, 1 i due isiemi 11 e 1 e i due isiemi 1 e e il umero di cofroti, se i valori ij soo o ulli, è = = 4

5 = = 1 4 = 7 Quidi il umero di cofroti, el caso migliore, cala ad ogi iterazioe di u fattore espoeziale ovvero (se ad esempio > 3) fio ad arrivare a Nel caso migliore, el quale ad ogi iterazioe vegoo prodotti due isiemi che differiscoo, per cardialità, al più per u elemeto, ell iterazioe k-ma si eseguoo ( k 1) cofroti. Quidi il umero m di iterazioi è il massimo valore di k per cui ( k 1) 0, ovvero log ( + 1) k, da cui m = log ( + 1). Quidi il umero globale di cofroti è dato da log (+1) + 1 k = ( + 1) log ( + 1) log (+1) +1 + Θ( log ) = Θ( log ) Se ivece i dati soo già ordiati (e il pivot viee scelto come primo elemeto) o i geerale, se la scelta casuale del pivot è l elemeto miimo (o massimo), i due sottoisiemi soo sbilaciati co 1 = 0 e = 1. Proseguedo, il primo isieme è vuoto e quidi o viee suddiviso, e il secodo isieme viee suddiviso i due isiemi acora sbilaciati 1 = 0 e = 1 =. I questo caso il umero cofroti è = = ( 1) Θ( ) Il caso peggiore porta quidi a cosiderare ua complessità quadratica. Siccome il caso migliore ha ua complessità Θ( log ) è iteressate valutare il caso medio. Aalisi del caso medio: Iizialmete bisoga valutare la probabilità co cui u isieme di dati viee suddiviso i due isiemi di 1 e dati. Possiamo, per semplicità, assumere che la probabilità che due dati siao uguali sia ulla. Comuque va sottolieato che la preseza di dati uguali dimiuisce il umero di cofroti (purché vega adottata la variazioe idicata precedetemete), per cui l aalisi di caso medio che viee ora fatta è pessimistica rispetto al caso co dati o ecessariamete diversi. Sotto l ipotesi di dati diversi Pr { 1 = k} = 1/, per cui, se idichiamo co A() il valore medio di cofroti per dati, si ricava l espressioe ricorsiva A() = A(k) + A( 1 k) = A(k) 1 A() = ( 1) + A(k) = ( 1) A( 1) = ( 1) ( ) + A(k) sottraedo A() ( 1) A( 1) = ( 1) + A( 1) = A() = ( + 1) A( 1) + ( 1) dividedo per ( + 1) A() A( 1) ( 1) = ( + 1) 5

6 B() := A()/( + 1) siccome B(0) = 0 B() = B( 1) + ( 1) ( + 1) + B() = k= (k 1) k (k + 1) = k + k = 4 + k = 4 k + 1 = k +1 k + k= 4 k = = H() dove H = 1/k soo i umeri armoici, visti precedetemete. Dalla relazioe asitotica H l γ si ha B() = A() ( + 1) ( l + 1 k l ) = l + l + 4 Θ( log ) BST sort Per ordiare i dati si può pesare di costruire u BST (secodo u ordie qualsiasi delle chiavi) e poi operare ua visita i-order del BST. Si è già visto che la visita i-order ha complessità O(). Tuttavia la costruzioe del BST ha complessità O( d) co d profodità del BST. Se si riesce a mateere bilaciato il BST durate la sua costruzioe si ha a disposizioe u algoritmo di ordiameto di complessità O( log ). No presetiamo qui le operazioi di bilaciameto per u BST e eppure presetiamo uo speciale tipo di albero biario, i cosiddetti red-black trees, che soo per defiizioe bilaciati e per i quali le operazioi di iserzioe ed elimiazioe soo simili a quelle di bilaciameto di u BST. I base all aalisi fatta precedetemete la complessità media i u BST sort è O( log ). 6 Mergesort Nell algoritmo quicksort il fattore chiave per otteere ua buoa complessità computazioale era la possibilità di suddividere i modo bilaciato u isieme. Per sfruttare quest idea i modo sistematico si può pesare di suddividere l isieme i due isiemi arbitrari ma di uguale cardialità, di ordiarli e poi foderli assieme i u uico isieme ordiato. Si può sfruttare il fatto che, dati due isiemi già ordiati, si ottiee velocemete u uico isieme ordiato. L ordiameto dei due sottoisiemi viee eseguito secodo la stessa tecica i maiera ricorsiva. procedure mergesort(k) 6

7 { := K ; m = / ; for i := 1 to m do A[i] := K[i] for i := m + 1 to do B[i m] := K[i] C = mergesort(a) D = mergesort(b) retur(merge(c, D)) procedure merge(a, B) { a := A ; b := B ; p a := 1; p b := 1; p c := 1; while p a a p b b do { if A[p a ] < B[p b ] the C[p c ] := A[p a ]; p a := p a + 1 else C[p c ] := B[p b ]; p b := p b + 1; p c := p c + 1; } ; if p a > a the for i := 0 to b p b do C[p c + i] := B[p b + i] else for i := 0 to a p a do C[p c + i] := A[p a + i]; retur(c); Aalisi del caso peggiore: La procedura merge richiede u umero lieare di operazioi. Pertato, se idichiamo co T () il umero di operazioi richiesto per ordiare u isieme di elemeti, possiamo stabilire la seguete equazioe ricorsiva. Per risolverla si operi la sostituzioe = m per cui (1) diveta T () = T ( ) + (1) T ( m ) = T ( m 1 ) + m () e si defiisca f(m) := T ( m ) per cui () diveta f(m) = f(m 1) + m = (f(m 1) + m 1 ) (3) Per risolvere la ricorsioe (3) calcoliamo i primi termii i fuzioe di f(0): f(1) = f(0) + ; f() = f(1) + = ( f(0) + ) + = f(0) + f(3) = f() + 3 = ( f(0) + ) + 3 = 3 f(0) Si iduce l espressioe geerale (che può essere facilmete dimostrata per iduzioe) f(m) = m f(0) + m m Siccome f(0) = T (1) = 0 si ha f(m) = m m ovvero T () = log. 7

8 7 Heapsort Uo heap è ua struttura dati che permette di determiare i tempo costate il miimo di u isieme ed i tempo logaritmico la rimozioe del miimo o i geerale l aggiorameto di ua qualsiasi chiave. Uo heap è u albero biario bilaciato (co le foglie del livello massimo tutte a siistra) co le regola che la chiave di u odo è o peggiore delle chiavi dei figli (se preseti) L isieme dei dati sia ad esempio: K = {6, 10, 8, 3, 7, 11, 0, 1, 9, 7, 5, 15} Ua possibile iserzioe di K i uo heap è rappresetata i figura. Uo heap viee ormalmete implemetato come u vettore elecado le chiavi livello per livello (i questo caso abbiamo bisogo ache di putatori che, ota la posizioe ello heap della chiave, foriscao la posizioe della chiave i K e viceversa). Alterativamete lo heap può essere costituito direttamete da putatori a K. Questa secoda opzioe fa risparmiare u vettore ed è preferibile. Useremo questa secoda opzioe ache se elle figure, uicamete per semplicità didattica, le chiavi appaioo resideti ello heap. I etrambi i casi è idispesabile avere dei putatori che da K idirizzao allo heap. Ad esempio, per lo heap i figura la sua implemetazioe può essere il vettore (co chiavi ello heap) H = {3, 5, 7, 11, 6, 8, 9, 0, 1, 7, 15, 10} oppure il vettore di putatori H = {4, 11, 5, 6, 1, 3, 9, 7, 8, 10, 1, } I etrambi i casi è richiesto ache il vettore iverso di putatori H = {5, 1, 6, 1, 3, 4, 8, 9, 7, 10,, 11} Si oti che i figli dell elemeto K[H[i]] soo gli elemeti K[H[ i]] e K[H[ i+1]] (purché ovviamete i H e i + 1 H ). Viceversa l elemeto padre di u elemeto K[H[i]] è l elemeto K[H[ i/ ]]. Quidi i figli 8

9 di K[j] soo K[H[ H [j]]] e K[H[ H [j] + 1]] (purché H [j] H e H [j] + 1 H ). Esamiiamo i dettaglio le operazioi eseguibili su uo heap. Lettura e prelevameto del miimo Per leggere il miimo elemeto di K basta ovviamete leggere H[1] co complessità O(1). Se, oltre a leggere il miimo si vuole elimiarlo da K, bisoga aggiorare lo heap. Siccome la struttura deve avere u elemeto i meo, l ultima posizioe dello heap o può essere occupata. Quidi si può pesare di spostare la chiave presete ell ultima posizioe e spostarla ella prima, rimasta vacate dopo la rimozioe dell elemeto miimo (prima delle figure qui sotto). Questa azioe però può violare la proprietà dello heap che ogi odo deve essere o peggiore dei suoi figli. Per ripristiare la proprietà si cofroti la chiave i posizioe 1 co i suoi due figli. Se il migliore dei due figli è migliore del padre si deve operare uo scambio fra questi (secoda figura). L operazioe va ripetuta ricorsivamete fiché la proprietà dello heap è ripristiata (altre due figure). Il umero di cofroti ecessario i questa fase è limitato dalla profodità dello heap e quidi la complessità globale dell operazioe è O(log ) La discesa verso il basso delle chiavi può essere realizzata dalla seguete procedura che data ua posizioe ello heap i cui la chiave è evetualmete mal posta perché peggiore di uo dei figli, sposta verso il basso le chiavi fio a ripristiare la codizioe. Nelle successive procedure K è il vettore degli elemeti da cofrotare, H è lo heap di putatori a K, è il umero di elemeti (attivi) ello heap, H è il vettore di putatori da K i H. K, H e H soo vettori di dimesioe sufficietemete ampia da memorizzare u elevato di dati. Il sottoisieme di K di cui si valuta il miimo (sottoisieme attivo) corrispode ai putatori preseti i H fio alla posizioe. Gli elemeti di H successivi alla posizioe soo seza sigificato. Gli elemeti di H o corrispodeti ad elemeti attivi soo seza sigificato. fuctio checkdow(k) { if k 9

10 the firstso:=k[h[ k]] else firstso:= ; if k + 1 the secodso:=k[h[ k + 1]] else secodso:= ; if firsto < secodso the bestso:= firstso; h :=, k else bestso:= secodso; h :=, k + 1 if bestso < K[H[k]] the retur(true,h) else retur(false,il) procedure switch(i, j) { H [H[i]] := j; H [H[j]] := i; temp:=h[i]; H[i] := H[j]; H[j] :=temp; procedure movedow(k) { (misplaced,h):=checkdow[k] while misplaced do { switch[k, h]; k := h (misplaced,h):=checkdow[k] } procedure getdelmi(k) { retur(k[h[1]]); switch(1,); := 1; movedow(1) Ecco descritta la diamica di H e H durate l iterazioe. Scambio di 1 e = 1 (i corsivo gli elemeti seza sigificato) H = {, 11, 5, 6, 1, 3, 9, 7, 8, 10, 1, 4 } H = {5, 1, 6, 1, 3, 4, 8, 9, 7, 10,, 11} Scambio di 1 e H = {11,, 5, 6, 1, 3, 9, 7, 8, 10, 1, 4 } H = {5,, 6, 1, 3, 4, 8, 9, 7, 10, 1, 11} Scambio di e 5 H = {11, 1, 5, 6,, 3, 9, 7, 8, 10, 1, 4 } H = {, 5, 6, 1, 3, 4, 8, 9, 7, 10, 1, 11} 10

11 Scambio di 5 e 10 H = {11, 1, 5, 6, 10, 3, 9, 7, 8,, 1, 4 } H = {, 10, 6, 1, 3, 4, 8, 9, 7, 5, 1, 11} K = {6, 10, 8, 3, 7, 11, 0, 1, 9, 7, 5, 15} Ordiameto dei dati Basta eseguire volte l operazioe di prelevare il miimo. u operazioe di complessità O(log ), la complessità dell ordiameto è O( log ). Siccome si tratta di eseguire volte Si può otare che all avazare dell algoritmo il umero di dati attivi ello heap dimiuisce per cui la complessità potrebbe dimiuire. U aalisi più accurata che faremo più avati, porta comuque al valore O( log ). procedure heapsort(k) { m := ; for k := 1 to m do S[k] :=getdelmi(k) ; retur(s) Iserimeto di u dato Per iserire u dato i uo heap, l osi posizioa dapprima ell ultima posizioe possibile e poi si verifica se la proprietà dello heap è verificata. I questo caso la proprietà va verificata rispetto al odo padre e ci possoo essere scambi di odi verso l alto fio alla radice. La complessità è ovviamete O(log ). La procedura di iserire u dato potrebbe essere usata ache per costruire uo heap iseredo i dati uo alla volta a partire dal primo. I questo modo uo heap co dati potrebbe essere costruito co complessità O( log ). Vedremo tuttavia più avati che per costruire uo heap è più coveiete usare ua tecica diversa che preseterà complessità O(). Nella procedura qui sotto idicata si assume che K cotiee dati tutti iseriti ello heap e che il uovo dato viee aggiuto al vettore K. fuctio checkup(k) { h := k/ ; if K[H[k]] < K[H[h]] the retur(true,h) else retur(false,il) procedure moveup(k) { (misplaced,h):=checkup[k] while misplaced do { switch[k, h]; k := h (misplaced,h):=checkup[k] } procedure isertkey(a) { := + 1; K[] := a; H[] := ; 11

12 H [] := ; moveup() Variazioe di u dato Se i dati vegoo variati la loro posizioe ello heap può cambiare. I particolare se u dato viee dimiuito la sua posizioe ello heap si sposterà verso l alto e se ivece viee aumetato la posizioe si sposterà verso il basso. Le operazioi hao complessità O(log ). Nelle procedure qui sotto delieate si assume che il dato k-mo di K è stato modificato. procedure decreasekey(k) { h := H [k]; moveup(h) procedure icreasekey(k) { h := H [k]; movedow(h) Costruzioe di uo heap Per costruire uo heap, aziché iserire i dati ad uo ad uo e ripristiado lo heap ad ogi iserimeto co uo spostameto verso l alto delle chiavi, coviee iserire dapprima tutti i dati i modo disordiato e poi verificare dato per dato la proprietà a partire dal fodo dello heap co degli spostameti verso il basso. Il vataggio deriva dal fatto che la maggior parte delle chiavi si trova a livelli bassi dello heap e per questi soo richiesti pochi spostameti verso il basso. Aalizziamo ora i dettaglio la complessità computazioale della costruzioe di uo heap. Richiamiamo dapprima alcui risultati prelimiari sulle sommatorie ak e k ak. La prima somma è equivalete alla seguete espressioe a k = a+1 1 a 1 che si verifica immediatamete da (a 1) a k = a k+1 +1 a k = a k a k = a +1 1 Quidi se a < 1 e Per la secoda sommatoria si ha k 0 a k = 1 1 a k a k = a k a k 1 = a d da a k = a d a +1 1 = da a 1 a ( + 1) a (a 1) (a +1 1) a (a 1) = (a 1) ( a (a 1) a + 1) (4) 1

13 Come sempre defiiamo livello 0 quello della radice dello heap. Quidi la chiave i posizioe j dello heap si trova al livello log j. Se gli elemeti soo il livello massimo dello heap è log. I uo spostameto verso il basso dalla chiave j il umero massimo di scambi è il massimo valore k tale k j, quidi è log (/j). I uo spostameto verso l alto il umero di scambi è al più log j. Allora per costruire uo heap il umero di scambi globale è al più T () := / j=1 log j (5) Possiamo trovare ua limitazioe superiore a T () i due modi alterativi. 1 L espressioe log (/j) è uguale al valore costate k per tutti i valori j tali che k j < k+1 = j k < j k+1 = j k j k+1 1 ovvero + 1 k+1 j k Sia Quidi si ha { J k := j : + 1 } k+1 j k = k T () = / j=1 log log = k J k j + 1 k Sia p p+1 1. Quidi p := log. Siao ( 0, 1,..., p ) le cifre biarie di (co p = 1), ovvero = p p = p i i i=0 Allora Siccome J k = k p i i k + i=k + 1 k+1 k 1 i=0 i i k + 1 = k 1 i=0 i i k = 0 ; p i=0 i i p i=k+1 k p i=0 i i + 1 k = k i i k 1 i=0 i i = k+1 k i=0 i i + 1 = 1 k+1 si ha p p p p J k = i i k i i k 1 = k + i ( i k i k 1 ) = k + i i k 1 i=k i=k+1 i=k+1 i=k+1 e allora / j=1 log log = k J k = j ( p k k + p i=k+1 i i k 1 ) = 13

14 p p k k + p p p [i k + 1] k i i k 1 = k k + i=1 i i=1 p [i k + 1] k i k 1 = p k k + p i=1 i 1 i k i k 1 = p k k + Siccome, applicado (4), i 1 k k = (1 i+1 (i 1) i ) p k k + p i=1 i 1 i i 1 p i i (1 i+1 (i 1) i ) = i=1 ( p p k k + i i i=1 p i i i+1 i=1 k k = ) p i i (i 1) i = i=1 p k k + 0 p p i i (i 1) = i=1 i=1 Quidi 0 p p p i + (k k + 1) k = i=1 i=0 p T () = i 1 i=0 i L espressioe / j=1 log j è equivalete all area sotto la fuzioe a scalii (qui esemplificata per = 111), che può essere maggiorata dall itegrale / 1 [ log x dx = x log e + x log x ] / log e + log log e log 1 + log e = 14

15 Aalisi dell ordiameto: Il umero di scambi globale (dovuto alle successive rimozioi della radice) è al più S() := log j j=1 L espressioe log j è uguale al valore costate k per tutti i valori j tali che k j k+1 1, quidi S() = log (+1) 1 k k + ( log (+1) + 1) Sia p = log ( + 1) 1, quidi p S() = k k + ( p+1 + 1) e applicado (4) S() = (p p p + 1) + ( p+1 + 1) = p p+1 p p = 1 = 1 = + 1 p = log ( + 1) 1 log ( + 1) 1 = log ( + 1) log = log + 1 S() log O( log ) log 15