Miskolci Egyetem Informatikai Intézet Általános Informatikai Tanszé k Pance Miklós Adatstruktúrák, algoritmusok előadásvázlat Miskolc, 2004 Technikai közreműködő:

Az előadások a következő témára: "Miskolci Egyetem Informatikai Intézet Általános Informatikai Tanszé k Pance Miklós Adatstruktúrák, algoritmusok előadásvázlat Miskolc, 2004 Technikai közreműködő:"— Előadás másolata:

1 Miskolci Egyetem Informatikai Intézet Általános Informatikai Tanszé k Pance Miklós Adatstruktúrák, algoritmusok előadásvázlat Miskolc, 2004 Technikai közreműködő: Imre Mihály, műszaki informatikus hallgató

2 Önrendező listák 1. Pl. a raktározási gyakorlatban a tételeket nem azonos gyakorisággal keressük (a tételek 15%-ára vonatkozik a keresések 85%-a). Tételezzük fel a következő hivatkozási gyakoriságot: Ekkor a keresés átlagos költsége: 2

3 Önrendező listák 2......... Az átlagos költség tehát: Szekvenciális listában az elemeket a keresési gyakoriságuk alapján csökkenő sorrendbe rendezzük. 3

4 Önrendező listák 3. MF: Move to Front: a hivatkozott elem előre megy T: Transpose: a hivatkozott elem a megelőzővel helyet cserél FC: Frequency Count: számol, rendez Sleator, Tarján: az MF módszer nem rosszabb bármely más módszer hatékonyságának kétszeresénél (a bizonyítás bonyolult). Ezért ezt nyugodtan használhatjuk. 4

5 Skip lista 1. L[1] L[2] L[3] L[4] L[5] L[6] L[7]L[8] L[9] 1. szint 2. szint 3. szint 4. szint A pointerek száma: Többszintű, kulcs szerint rendezett láncolt lista. 5

6 Skip lista 2. Keresés: a bináris kereséshez hasonló 1. az i. szinten összehasonlítás, ha = megvan: vége, ha > az adott elemnél, akkor folytatás 2. 2. az i. szintű láncon előre megyünk, míg nagyobbat nem találunk, ha a szint végére értünk, akkor nincs a listában: vége 3. vissza az i. szinten a megelőző elemre, lelépünk az (i-1)-edik szintre ezen a helyen 4. ugrás 1. Hatékonysága O(log N), mindig feleződik az intervallum. 6

7 Skip lista 3. Beszúrás: pozíció megkeresése O(log N), célszerű ellentétes láncolat is a legalsó szinten  3N pointer kell. Pointer állítás így O(1), beszúrás O(log N). Ezzel torzul a skip lista tökéletessége, mert felette már nem valódi felező, negyedelő, stb. pointerek lesznek. Tökéletes skip lista: ahol pontosan középen vannak a láncolat elemei. Véletlen skip lista: csak körülbelül teljesül a felezés, átlagosan az i-edik szinten N/2 i elemű a láncolat. 1 a valószínűsége, hogy egy elem az 1. szinten benne van a láncban 1/2 a valószínűsége, hogy egy elem a 2. szinten benne van a láncban 7

8 Skip lista 3. 1/2 i a valószínűsége, hogy egy elem az i. szinten benne van a láncban N elem esetén log(N) a szintek száma, így a beszúrás algoritmusa a következő: 1.keressük meg az új elem helyét a listában 2.határozzuk meg az új elem max. szintszámát, úgy, hogy az i. érték 1/2 i valószínűséggel kerüljön kiválasztásra. 1<= i <= log(N) (véletlenszám generálás) 3.fűzzük be az új elemet minden i-nél nem nagyobb szintű láncolatba 8

9 Rendezés A CPU idők ¼ -ét fordítják rendezésre. Kötetnyi irodalom foglalkozik vele. Feltételek: - a teljes lista beférjen a memóriába, - a kulcs egész, - a kiinduló sorrend az elemek egy permutációja, - csökkenő vagy növekvő sorrend, - a tételek átrendezését saját helyükön kell végrehajtani. Tömbök rendezése: belső rendezés. Soros fájlok rendezése: külső rendezés. 9

10 Rendezés Stabil rendezés: az azonos kulcsú tételek relatív sorrendje a rendezés után nem változik. A hatékonyság mérésére: - a kulcs-összehasonlítások száma (C), - a tételmozgatások száma (M). Közvetlen módszerek: egyszerű (kicsi program), több művelet, kis N-re valók. Kifinomultabb módszerek: bonyolultabb, kevesebb művelet, nagy N-re valók. 10

11 Kiválasztásos rendezés for i =1 to N-1 begin mine= L i ; minp= i; for j = i + 1 to N if L j < mine then begin mine= L j ; minp= j ; end; if minp i then begin L minp = L i ; L i =mine; end; end; Nem érzékeny az előrendezettségre, hatékonysága O(N 2 ). 11

12 Beszúró rendezés 1. A j-edik elemet beszúrjuk az 1.. j-1 rendezett listába. Átlagos hatékonysága O(N 2 ), érzékeny az előrendezettségre. for i=2 to N begin j = i – 1 ; k = L i while k 0 do begin L j+1 = L j ; j = j –1; end; L j+1 = k; end; 12

13 Beszúró rendezés 2. Beszúrás javítása: L 0 = L j ; A beszúrási pozíciót bináris kereséssel határozzuk meg: bináris rendezés. Az összehasonlítások száma (C) csökkent, de M nem. De egy rendezett tömb újrarendezése több időt venne igénybe, mint a soros kereséssel. 13

14 Buborék rendezés 1. Szomszédos elemek permutációja, hatékonyság: O(N 2 ) Elejétől a végéig: csere, ha a kisebb indexű elem értéke kisebb mint a nagyobb indexűé, így a legkisebb a végére kerül. Ezután a 2. legkisebb, és így tovább (a felső határt lehet lefelé tolni). N-1 pásztázás kell. 14

15 Buborék rendezés 2. Javítási lehetőségek: 1. minden menetben feljegyezzük, hogy volt-e csere, ha nem volt: vége. 2. melyik pozícióban volt utoljára csere. aszimmetrikus: egyetlen rossz helyen lévő elem a tömb nehezebbik feléről egyetlen menetben a helyére kerül, míg a könnyebbik részéről a rossz helyen álló elem menetenként csak egy pozícióval kerül a helye felé. 3. keverő rendezés: alulról – felülről (előről – hátulról) elemzése: a beszúró, kiválasztó jobb. Valójában a buborék rendezés alig ér egyebet hangulatos nevénél. Akkor hatásos csak, ha a tételek már majdnem rendezettek. 15

16 Shell rendezés 1. D. L. Shell (1959): Az elemeket nagyobb ugrásokkal próbálja meg végső helyükre tenni: 16 - vegyünk egy intervallum hosszúság sorozatot, melynek kezdőértéke N-nél kisebb és utolsó eleme 1, - minden intervallum hosszúságra vesszük összes képezhető részsorozatot, - minden részlistára elvégezzük a beszúró rendezést.

17 Shell rendezés 2. Kevesebb mozgatás kell: O(N log 2 N) Shell: N/2, N/4, N/8, …O(N 2 ) 2 k -1 : 1, 3, 7, 15,....:O(N 3/2 ) O(N 7/6 ) nem bizonyított 17

18 Quick (gyors) rendezés 1. C. A. R. Hoore (1962): Általában a leghatékonyabb, az oszd meg és uralkodj alapelv szerint működik: 1.felosztási fázis, két részre bontás, 2.részfeladatok megoldása, 3.egyesítési fázis. 18

19 Quick sort 2. 19 rekurzívan LbLb LjLj < PjPj PbPb L1L1 LnLn LkLk

20 Quick sort 3. - P b az első elemre mutat - P j az utolsó elemre mutat - L[P b ] <= L[k] ha igen, akkor P b += 1, ha nem megállunk - L[P j ] >= L[k] ha igen, akkor P j - = 1, ha nem megállunk - ha mindkettő megállt, felcseréljük őket, léptetés előre, vissza - mindaddig amíg a két pointer nem találkozik, így kialakul a két részintervallum - folytatás rekurzívan a részintervallumokon 20

21 Quick sort 4. A hatékonyság függ a két részintervallum relatív méretétől, ha egyformák, akkor feleződik és log N szint kell. Minden szinten minden elemet egyszer át kell nézni: O(N log N) átlagosan. Worst case: az egyik részbe csak 1 elem kerül: O(N 2 ). A határelem (pivot elem) választásán múlik minden, legjobb ha ez véletlenszerű, vagy 3 alapuló elemen középső érték: a = a b ; b = a (b+j) div 2 ; c = a j if a > b then csere(a,b) if a > c then csere(a,c) if b > c then csere(b,c) x = b; {középső} 21

22 Quick sort 5. Megjegyzések: - kis tömbökre ne alkalmazzuk: D. Knuth: 9. (eljárás hívás, programozási nyelvtől függ) beszúrásos módszerrel folytatni, mivel valószínűleg eléggé előrendezettek. - rekurzió helyett ciklus - pointer tömb (rekord….) - Quick opt (B. Breutmann) 22