Leszámláló rendezés. 1. Végigmegyünk az A-n, és ha egy elem értéke i, akkor megnöveljük C[i] értékét eggyel.

Átírás

1 13. előadás

2 Leszámláló rendezés Tegyük fel, hogy van n db bemeneti elem, s ezek mindegyike 1 és k közötti egész szám. Az alapötlet: meghatározzuk minden egyes x bemeneti elemre azoknak az elemeknek a számát, amelyek kisebbek, mint az x. Ezután x-et közvetlenül a saját pozíciójára tudom helyezni. Legyen a bemenet az A[1..n] tömb, a kimenet a B[1..n] tömb. Mindkettő hossza: hossz[a]=hossz[b]=n Szükség van még egy C[1..k] tömbre átmeneti munkaterületként.

3 Leszámláló rendezés 1. Végigmegyünk az A-n, és ha egy elem értéke i, akkor megnöveljük C[i] értékét eggyel. 2. Minden i-re 1..k között meghatározzuk, hogy hány olyan bemeneti elem van, amelyiknek az értéke i (összegzés C-n) 3. Minden j-re n..1 között A[j]-t betesszük B megfelelő pozíciójába - ezt a C-ből állapítjuk meg. Ha betettük, akkor a C[A[j]] értékét csökkentjük, így a következő vele egyenlő elem már elé kerül, vagyis így stabil lesz a rendezés, az egyenlő elemeknél megtartja az eredeti sorrendet.

4 Leszámláló rendezés A tömb C tömb C-ben az i-vel = elemek száma 1. Végigmegyünk az A-n, és ha egy elem értéke i, akkor megnöveljük C[i] értékét eggyel.

5 Leszámláló rendezés A tömb C tömb C-ben az i-nél elemek száma 2. Minden i-re 1...k között meghatározzuk, hogy hány olyan bemeneti elem van, amelyiknek az értéke i (összegzés C-n)

6 Leszámláló rendezés A tömb C tömb B tömb 3. Minden j-re n...1 között A[j]-t betesszük B megfelelő pozíciójába - ezt a C-ből állapítjuk meg.

7 Leszámláló rendezés A tömb C tömb 1 B tömb

8 Leszámláló rendezés A tömb C tömb 1 B tömb

9 Leszámláló rendezés A tömb C tömb 1 3 B tömb

10 Leszámláló rendezés A tömb a végén: B tömb

11 Leszámláló rendezés Az algoritmus pszeudokódja: for i 1 to k do C[i] 0 for j 1 to hossz(a) do C[A[j]] C[A[j]] + 1 for i 2 to k do C[i] C [i] + C[i-1] for j hossz(a) downto 1 do B[C[A[j]]] A[j] C[A[j]] C[A[j]] - 1 C-ben az i-vel = elemek száma C-ben az i-nél elemek száma

12 Leszámláló rendezés Futási idő: 1. for ciklus: (k) 2. for ciklus: (n) 3. for ciklus: (k). for ciklus: (n) Így a teljes időigény: (k+n). Ha k = (n), akkor a rendezés futási ideje (n)! Ez ui. nem összehasonlító rendezés. A helyigénye viszont nagyobb

13 Batcher-féle rendezés Batcher-féle páros-páratlan összefésüléses rendezés Jelentősége: ez a MergeSort olyan változata, amelyben a lépések jelentős része párhuzamosan végezhető el. Ha párhuzamos processzorokon hajtanánk végre, akkor azt tapasztalnánk, hogy ((log 2 n) 2 ) idő alatt futna le, szemben a MergeSort (n * log 2 n) idejével.

14 Összefuttatásos rendezés MergeSort(S) S hossza 1? Szétvág(S, S1,S2) SKIP MergeSort(S1) MergeSort(S2) Összefuttat(S1, S2, S)

15 Összefuttatásos rendezés tömbre külső hívás: MergeSort(A,1,n) MergeSort(A, k, v) k v? h (k+v)/2 SKIP MergeSort(A, k, h) MergeSort(A, h+1, v) Összefuttat(A[k..h], A[h+1..v], A[k..v]) kell egy segédtömb is itt

16 Mergesort Hatékonyságelemzés: Műveletigény: ha n a két sorozat együttes hossza: MÖ összefuttat (n)= n-1 MÖMS(n) (n-1)* log 2 n = (n log 2 n)

17 Mergesort A[1..k] B[1..m] C[1..k+m]

18 Mergesort A= a 1 < a 2 < < a k B = b 1 < b 2 < < b m C = c 1 < c 2 < < c m+k

19 Batcher-féle Ez lesz a PP_Merge. Egy tömb(részlet) két rendezett feléből összefésüléssel előállítja a tömb(részlet) rendezett tartalmát. Ez is rekurzív eljárás, csak kicsit másképp.

20 Batcher-féle rendezés az új összefésülés: 1. A páratlan és B páros elemeit fésüli össze U-ba 2. A páros és B páratlan elemeit fésüli össze V-be A= a 1 < a 3 < a 5 <. B = b 2 < b < b 6 <. U = u 1 < u 2 < u 3 < A= a 2 < a < a 6 <. B = b 1 < b 3 < b 5 <. V = v 1 < v 2 < v 3 <. Tegyük fel, hogy k = m vagy k = m+1

21 Batcher-féle rendezés 3. Az U és V sorozatokat nem kell összefésülni, hanem elég csak az egymás alatti u i,v i párokat 1-1 összehasonlítással a helyes sorrendbe rakni, és így {u 1,v 1 }, {u 2,v 2 }, { u 3,v 3 },..-ból kialakul a helyes sorrend. (Ez be fogjuk látni.) Párhuzamosítás: 1. és 2. párhuzamosan végezhető.

22 Batcher-féle rendezés példa A: B: csapat - A páratlan, B páros: A: B: U:

23 Batcher-féle rendezés A: B: csapat - A páros, B páratlan: A: B: V:

24 Batcher-féle rendezés {u 1,v 1 }, {u 2,v 2 }, { u 3,v 3 } párosítás:

25 Batcher-féle rendezés Rekurzió: A 2-2 rövidebb sorozat összefésülését ugyanezzel az eljárással végezzük. Ez rekurzív hívással valósul meg. Ehhez meg kell adni a legkisebb k és m értéket, amelyre már nem hívja az eljárás önmagát: Egy 2 hosszú tömböt még szétvágunk két 1 hosszú részre és azokra meghívjuk az összefésülőt, ekkor k=1 és m=1. Egy 1 hosszú tömböt azonban már nem fésülünk össze, hanem felismerjük, hogy az már rendezett, így nulla (0) összehasonlítást igényel, ekkor k=1, m=0.

26 Batcher-féle rendezés Állítás: A PP_Merge eljárás helyes. Belátjuk, hogy a leírt eljárás azt a helyes rendezett sorozatot eredményezi, amelyet C = c 1 < c 2 < < c m+k -val jelöltünk Esetszétválasztással gondoljuk meg: c 1 = min{u 1,v 1 }, c 2 = max{u 1,v 1 } Általában, ha 1 i (k+m)/2 : c 2i-1 = min{u i,v i }, c 2i = max{u i,v i }

27 Batcher-féle rendezés Vegyük figyelembe a kiegyensúlyozott szétvágást is, azaz azt, hogy k=m vagy k=m+1 esetén (k+m)/2 =m. Ha k+m páratlan, akkor még azt is be kell látni, hogy c k+m is helyesen képződik, hiszen erre akkor a képlet nem vonatkozik. Bizonyítás: I. Belátjuk, hogy a C sorozatban bármely páros indexű tagig elmenve c 1, c 2k között ugyanannyi u i szerepel, mint v j vagyis az U és a V sorozat szinte cipzár - szerűen építi a C-t.

28 Batcher-féle rendezés A C sorozat a rendezett A és B sorozatok összefésülésével adódik. Tegyük fel, hogy A-ból az a 1, a s elemek, B-ből a b 1, b 2k-s elemek jönnek összefésüléssel a C sorozat első 2k elemébe: {c 1, c 2k } = {a 1, a s } { b 1, b 2k-s }

29 Batcher-féle rendezés {c 1, c 2k } = {a 1, a s } { b 1, b 2k-s } U-ba kerülnek a páratlan indexű elemek, ezek száma: s/2 V-be kerülnek a páros indexű elemek, ezek száma: s/2 U-ba kerülnek a páros indexű elemek, ezek száma: (2ks)/2 V-be kerülnek a páratlan indexű elemek, ezek száma: (2k-s)/2

30 Batcher-féle rendezés Az állítás ekkor egyenértékű azzal, hogy: s/2 + (2k-s)/2 = s/2 + (2k-s)/2? Ez nyilván igaz, ha s páros, hiszen ekkor minden tag egész. ha s páratlan, akkor a kérdés: (s+1)/2 +(2k-(s+1))/2 = (s-1) /2 + (2k-(s-1))/2 egyenlősége, és ez tényleg igaz.

31 Batcher-féle rendezés II. Eszerint: {c 1, c 2i } = {u 1, u i } { v 1, v i } {c 1, c 2(i-1) } = {u 1, u i-1 } { v 1, v i-1 } A két halmaz kivonásával: {c 2i-1, c 2i }={u i, v i } Így, mivel c 2i-1 < c 2i, tehát az eredeti állítás fennáll. U és V már egy párhuzamos lépésben összefésülhető.

32 Batcher-féle rendezés Hatékonyságelemzés: Párhuzamos költséget számolunk, ez azt jelenti, hogy akárhány összehasonlítás is csak 1-nek számít, ha párhuzamosan végezzük! 1. A PP_Merge rekurzív eljárást egy n méretű, két (közel) egyenlő méretű, rendezett két félből álló tömbre hajtjuk végre. n A B n/2 n/2

33 Batcher-féle rendezés A két félből párhuzamosan lehet képezni az U és V sorozatokat, itt tehát n/2 -t vesszük alapul. Mivel ugyanezt az eljárást használjuk az U és V előállítására is, ez a költségszámítás képletében is rekurziót ad. Továbbá, az U és V tömbökből egyetlen párhuzamos összehasonlítással kapjuk a C eredményt. Így az egyenlet: MÖ PP_M (n) MÖ PP_M ( n/2 ) +1 Itt egyébként elegendő MÖ helyett Ö-t írni, mert ez az eljárás fix összehasonlítás számmal dolgozik. Szokásos jelölés még: T (n) T( n/2 ) +1, T(1) = 0

34 Batcher-féle rendezés Ennek megoldása úgy történik általánosan is, ahogy egy konkrét értékre: például n = 21-re: T(21) T(11) + 1 T(6) T(3) T(2) T(1) = = = 5 = log 2 21 T(21) log 2 21 Ha v olyan egész, amire 2 v < n 2 v+1, akkor a rekurzív egyenletet éppen v +1-szer alkalmazzuk, mire eljutunk T(1)-ig. Így v +1 db egyest adunk össze, vagyis T(n) log 2 n Ez tehát a párhuzamos összefésülés költsége.

35 Batcher-féle rendezés 2. A párhuzamos rendező eljárás szerkezete pontosan az, ami a bevezetőben felidézett MergeSort-é, csak más összefuttatást alkalmaz.

36 Batcher-féle rendezés - tömbökre külső hívás: BatcherSort(S,1,n) BatcherSort(S, p, q) p q? r (p+q)/2 SKIP BatcherSort(S, p, r) BatcherSort(S, r+1, q) PP_Merge(S[p..r], S[r+1..q], S[p..q])

37 Batcher-féle rendezés 2. A párhuzamos összehasonlítás számra az egyenlet: Ö Batcher (n) Ö Batcher ( n/2 ) + log 2 n Egyszerűbb jelöléssel: T(n) T( n/2 ) + log 2 n Ha ezt is kifejtjük, akkor az előzőhöz hasonlóan azt kapjuk, hogy log 2 n számú tag lesz; ezek a tagok azonban csökkennek: T(n) T( n/2 ) + log 2 n T( n/2 2 ) + log 2 ( n/2 ) + log 2 n T(1) ( log 2 n -1) + log 2 n = (( log 2 n +1) * log 2 n )/2 (log 2 n) 2 /2 = ((log 2 n) 2 )

38 Batcher-féle rendezés Az előzőekben felhasználtuk, hogy log 2 ( n/2 ) = log 2 n -1, ezt be is látjuk: Ha n= 2 p, akkor igaz. Ha 2 p < n 2 p+1, akkor 2 p-1 < n/2 2 p, 2 p-1 < n/2 2 p p-1 < log 2 n/2 p, így log 2 ( n/2 ) = log 2 n -1

39 Külső rendezések Az eddig látott rendezéseknél feltettük, hogy az adatok a központi memóriában vannak. Ennek megfelelt, hogy a hatékonyságot az összehasonlítások számában mértük. Ha az adatok háttértárban vannak, akkor a futási idő döntő részét az I/O utasítások teszik ki. (Az I/O egysége az 1 blokk, ami k x 512 byte valamely kis k- val, pl. 102 v. 208 byte. Ezt lapnak is nevezik.) A háttértár lehet szalag v. lemez (ennek különféle változatai). A hatékonyságot a szükséges blokk I/O-k számában mérjük. Külső rendezésre igazából csak az összefésüléses rendezés (MergeSort) alkalmas.

40 Külső rendezések Az összefésüléses rendezés külső tárakon Adott egy S szekvenciális input fájl, amely n blokkból áll, minden blokkban adott számú rekorddal. ( Pl. 1 blokk = 102 byte és ezen 3 rekord foglal helyet.) A blokkok tartalma rendezetlen. Az összefésülést iteratív módon végezzük, úgy, hogy az egyes menetek végén egyre nagyobb darabok, vagyis egyre több szomszédos blokk lesz rendezett. Az összefésülést menetenként váltakozva az A, B, illetve a C,D fájlokba végezzük, végül a teljesen rendezett eredményt S-be írjuk. A közbülső menetekben azért lesz 2 output fájl, mert az összefuttatás eredményét az egyet ide, egyet oda elv alapján írjuk ki.

41 Külső rendezések 1.menet: beolvassuk S rendezetlen blokkjait, valamilyen belső rendezővel rendezzük, majd kiírjuk felváltva A-ba, illetve B-be. Itt még nem volt összefésülés.

42 Külső rendezések S: rendezetlen blokkok b1 b2 b3 b b5 b6 b7 b8 b9 Rendezés központi memória A b1 B rendezett blokkok

43 Külső rendezések S: rendezetlen blokkok b1 b2 b3 b b5 b6 b7 b8 b9 Rendezés központi memória A B b1 b2 rendezett blokkok

44 Külső rendezések S: rendezetlen blokkok b1 b2 b3 b b5 b6 b7 b8 b9 Rendezés központi memória A B b1 b3 b5 b7 b9 b2 b b6 b8 rendezett blokkok

45 Külső rendezések 2.menet: Sorban beolvassuk A és B 1-1 blokkját. Ezek rendezettek. Összefésüljük őket és a rendezett két blokkot felváltva C-be, illetve D-be írjuk. Az A utolsó blokkjának nincs párja, így azt kiírjuk C- be. A C és D fájlban a rendezett részek hossza 2 blokk, illetve a maradék esetében 1 blokk.

46 A Külső rendezések rendezett: 1 blokk B b1 b3 b5 b7 b9 b2 b b6 b8 összefuttatás központi memória C D b1- -b2 rendezett: 2 blokk

47 A Külső rendezések rendezett: 1 blokk B b1 b3 b5 b7 b9 b2 b b6 b8 összefuttatás központi memória C D b3- b1- -b2 -b rendezett: 2 blokk

48 A Külső rendezések rendezett: 1 blokk B b1 b3 b5 b7 b9 b2 b b6 b8 összefuttatás központi memória C D b5- b1- -b2 b3- -b6 b9 b7- -b -b8 rendezett: 2 blokk

49 3. menet: C-ből és D-ből olvasunk 2-2 rendezett blokkot, összefésüljük őket és felváltva A-ba és B-be írjuk a rendezett blokkot. A C-beli utolsó töredék blokk változatlanul A végére kerül.

50 A Külső rendezések rendezett: blokk B b2- b1- b3- -b összefuttatás központi memória C D b5- b1- -b2 b3- -b6 b9 b7- -b -b8 rendezett: 2 blokk

51 A Külső rendezések rendezett: blokk B b2- b1- b3- b5- -b b6- b7- -b8 összefuttatás központi memória C D b5- b1- -b2 b3- -b6 b9 b7- -b -b8 rendezett: 2 blokk

52 A Külső rendezések rendezett: blokk B b2- b1- b3- b5- -b b9 b6- b7- -b8 összefuttatás központi memória C D b5- b1- -b2 b3- -b6 b9 b7- -b -b8 rendezett: 2 blokk

53 Külső rendezések. menet: C-be kerül A és B - rendezett blokkja összefésülésének a 8 blokk hosszú rendezett eredménye, D-be pedig a maradék egy blokk.

54 A Külső rendezések rendezett: blokk B b2- b1- b3- b5- -b -b9 b6- b7- -b8 összefuttatás központi memória C D b2- b1- b3- b- b5- b6- b7- -b8 b9 rendezett: 8

55 Külső rendezések 5. menet: C 8 blokkját és D 1 blokkját összefésüljük S- be. Elnevezés: egy k blokkból álló összefüggő rendezett részt k hosszú futam nak nevezünk.

56 Külső rendezések S rendezett b2- b1- b3- b- b5- b6- b7- b8- -b9 összefuttatás központi memória C D b2- b1- b3- b- b5- b6- b7- -b8 b9 rendezett: 8 blokk

57 Külső rendezések Két kiegészítő megjegyzés: 1. Ebben a példában az S 9. blokkja csaknem végig nem került kapcsolatba más rendezett részekkel, csak az utolsó menetben került összefésülésre. Ha végrehajtjuk a fenti eljárást n=15-re, akkor a páratlan töredék maradék rész mérete így alakul: 1, 3, 7, vagyis a fenti jelenség nem törvényszerű. 2. Ha a központi memória mérete korlátozott és nem képes befogadni az egyre növekvő méretű rendezett részeket (futamokat), akkor ezek összefésülését lehet pufferelve, akár blokkonként végezni. Ez azért lehetséges, mert az összefuttatás egysége a rekord.

58 Külső rendezések Általában: 1. menet eredménye: 2. menet eredménye: 3. menet eredménye:. 1 hosszú futamok 2 hosszú futamok hosszú futamok (k-1). menet eredménye: 2 (k-2) hosszú futamok k. (utolsó) menet eredménye: 2 (k-1) hosszú egyetlen futam = S (előtte maradék mindig lehet)

59 Külső rendezések Az utolsó előtti (k-1). menetben még volt 2 futam: 2 (k-2) < n A k. (utolsó) menetben már előáll a teljes rendezett fájl: n 2 (k-1) Áttérve logaritmusra: k-2 < log 2 n k-1 k-1 = log 2 n A menetek k száma: k = log 2 n +1 Az összes blokk-i/o száma: 2*n*( log 2 n + 1) (minden menetben beolvastuk és kiírtuk mind az n blokkot)

60 Külső rendezések Gyorsítási lehetőségek: Nagyobb kezdő futamok létrehozása ha a központi memória lehetővé teszi, akkor az 1. menetben megtehetjük, hogy S-ből m >1 blokkot olvasunk be, ezt rendezzük és az így keletkezett m hosszú kezdőfutamokat írjuk ki A-ba és B-be. Ezután úgy megy tovább, hogy először két m hosszú futamot fésülünk össze, majd két 2m hosszút, stb.

61 Külső rendezések 1. menet eredménye: m hosszú futamok 2. menet eredménye: 2*m hosszú futamok 3. menet eredménye: *m hosszú futamok. (k-1). menet eredménye: 2 (k-2) *m hosszú futamok k. (utolsó) menet eredménye: 2 (k-1) *m hosszú egyetlen futam = S Innen: 2 (k-2) *m < n 2 (k-1) *m A menetek k száma: k = log 2 (n/m) +1 Az összes blokk-i/o száma: 2*n*( log 2 (n/m) + 1)

62 Külső rendezések Több, mint kétfelé fésülünk: Ha az S fájl mellett nem 2 x 2, hanem általában 2 x m fájllal dolgozunk, akkor ezzel a ráfordítással hatékonyabb eljárás nyerhető. Legyen pl. m= 3, n=13 és térjünk vissza az 1 hosszú kezdő futamokhoz: Ekkor az 1. menetben felváltva A, B, C-be írjuk ki a rendezett kezdőfutamokat. Ezután mindig három futamot fésülünk össze (a maradékoktól eltekintve) és az új futamokat felváltva A, B, C-be ill. D, E, F-be írjuk ki. Az utolsó menetben S-be írjuk az eredményt.

63 Külső rendezések S-ben n= 13 A B C D E F S 1. menet 1,1,1,1,1 1,1,1,1 1,1,1,1 2. menet 3,3, 3,1, 3 3.menet 9. menet 13

64 Külső rendezések A számolás: 1. menet eredménye: 1 hosszú futamok 2. menet eredménye: m hosszú futamok.. (k-1)-edik menet eredménye: k-adik utolsó menet eredménye: Innen: m k-2 < n m k-1 n m k-2 hosszú futamok m k-1 hosszú egyetlen futam=s k= log m n + 1= log 2 n/ log 2 m +1 Az összes blokk I/O művelet: 2n * ( log 2 n/ log 2 m +1)

65 Külső rendezések Három fájlos külső rendező Érdekes algoritmushoz jutunk, ha az m-felé fésülésnél nem 2m db fájl-t használunk, hanem csak m+1 db-t. Ezt m=2 esetére nézzük meg, ami az eredeti eset. Ekkor tehát 3 fájl-t használunk, mondjuk A, B, C-t. Az 1. menetben szétosztjuk S immár rendezett blokkjait A- ba és B-be. A második menetben elkezdjük A és B blokkjainak az összefésülését, de most csak 1 fájl tudja fogadni az eredményt, a C fájl. Ezért C-be fésülünk össze egészen addig, amíg A és B egyike ki nem ürül. Ekkor új menetet kezdünk a két nem üres fájllal s.i.t.

66 Külső rendezések Példa: S n=13 blokk A táblázatban az első szám a futamok számát jelenti, zárójelben pedig a futamok hossza áll A 7(1) 1(1) 0 1(5) 0 1(9) 0 1(13)=S B 6(1) 0 1(3) 0 1(7) 0 1(11) 0 C 6(2) 5(2) (2) 3(2) 2(2) 1(2) 0 Látjuk, hogy a második menet végén képződött 6 db 2 hosszú futam csak egyesével tud elfogyni érezhetően sok lépésben. Ennek oka az, hogy az 1. menet végi két futamszámnak 1 a különbsége: 7-6=1

67 Külső rendezések Eszünkbe jut a Fibonacci sorozat: 0,1,1,2,3,5,8,13,. Ahol két szomszédos elem különbsége az első néhány tag kivételével 1-től különböző. Innen jön a gondolat, hogy az első menetben írjunk annyi futamot A-ba és B-be, mint a Fibonacci sorozat két (alkalmas) szomszédos eleme, és lépkedjünk visszafelé a sorozaton az egyes menetekben A 8(1) 3(1) 0 2(5) 1(5) 0 B 5(1) 0 3(3) 1(3) 0 1(13)=S C 5(2) 2(2) 0 1(8) 0

68 Külső rendezések Belátható, hogy a 3 fájlos rendező éppen akkor fut le leggyorsabban, ha így járunk el, azaz A-ban és B-ben két szomszédos Fibonacci számnak megfelelő számú kezdő futamot hozunk létre. Ha N nem Fibonacci szám, akkor vagy levágjuk és félretesszük a felesleget, és a végén még összefésüljük a kialakult eredménnyel, vagy pedig éppen fordítva: (virtuális) kiegészítéssel alkalmasan megnöveljük az input állomány méretét.

69 Külső rendezések Nézzük meg, hány lépésben érjük el F k és F k-1 -ből az 1, 0 számokat úgy, hogy minden menetben egy újabb számot tudunk lefelé lépni: (k-1). k. S F k+1 F k F k F k-1 F k Látható, hogy a menetek száma ekkor k, hiszen F k -től F 1 -ig vezet az út a táblázatban. Ki kell fejezni n-et F k+1 -gyel, ami az input fájl (közelítő) mérete blokkokban. Jelöljük N:=F k+1

70 Külső rendezések N:=F k+1 F 0 = 0, F 1 = 1, (F 2 = 1, F 3 = 2, F = 3, ) F k+1 = F k + F k-1 (k 1) F k = 1/ 5 * [((1+ 5)/2) k ((1-5)/2) k ] F k 1/ 5 * ((1+ 5)/2) k 1,6180-0,6180 Az A= (1+ 5)/2 az aranymetszés aránya, amely kielégíti az A 2 -A-1=0 egyenletet. Ezt átrendezve: A 2 =A+1, amiből teljes indukcióval megmutatható, hogy k 2 esetén: A k-2 F k A k-1 Ha N=F k+1, akkor A k-1 N, k-1 log A N = log 2 N/ log 2 A 1, * log 2 N k 1, * log 2 N +1