9. Előadás
Rendezések A rendezési probléma: Bemenet: n számot tartalmazó (a 1,a 2,,a n ) sorozat Kimenet: a bemenő sorozat olyan (a 1, a 2,,a n ) permutációja, hogy a 1 a 2 a n 2
Rendezések Általánosabban: Legyen K egy teljesen rendezett halmaz, a kulcsok halmaza Legyenek T i -k tetszőleges típusok i [1,m] m E := K x X T i i=1 E egy eleme: kulcs t 1 t m rekordmezők 3
Rendezések A cél: S Legyen n= S E * rendezése. S rendezett i [1, n-1]: S i.kulcs Előfeltétel: S = S E * S i+1.kulcs Utófeltétel: S rendezett és S Perm(S ) 4
Rendezési reláció Legyen U egy halmaz, és < egy kétváltozós reláció U-n. Ha a, b U és a < b, akkor azt mondjuk, hogy a kisebb, mint b. A < reláció egy rendezés, ha teljesülnek a következők: 1. a < a a U elemre (< irreflexív); 2. Ha a, b, c U, a < b, és b < c, akkor a < c (< tranzitív); 3. Tetszőleges a b U elemekre vagy a < b, vagy b < a fennáll (< teljes). Ha < egy rendezés U-n, akkor az (U; <) párt rendezett halmaznak nevezzük. Példa: Z az egész számok halmaza. A < rendezés a nagyság szerinti rendezés. C a karakterek halmaza, a rendezést a karakterek kódja adja. 5
Rendezések Például: Személy= Név x Magasság x Születési_év Abigél Janka Zsuzsi Dávid Dorka 132 128 92 104 70 1996 1998 2001 2000 2002 Akármelyiket választhatjuk kulcsnak mindegyiken van értelmezve rendezés. 6
Rendezések Ha a név a kulcs: Abigél Dávid Dorka Janka Zsuzsi 132 104 70 128 92 1996 2000 2002 1998 2001 7
Rendezések Ha a születési év a kulcs: Abigél Janka Dávid Zsuzsi Dorka 132 128 104 92 70 1996 1998 2000 2001 2002 8
Rendezések Osztályozás: 1. m = 0 skalár rendezők m 1 rekord rendezők 2. Belső rendezők: központi memória + indexelés Külső rendezők: háttértárolón 3. Összehasonlításos rendezők (kulcsok értékét hasonlítjuk) Edényrendezők (kulcsok értéke szerint szétrakjuk) 9
Rendezések 4. Helyben rendezők (segéd memória konstans) Nem helyben rendezők 5. Stabil rendezők (azonos kulcsú rekordok sorrendje nem változik) Nem stabil rendezők 6. Előrendezéshez illeszkedő és nem illeszkedő rendezők (kevesebbet dolgozik-e, ha a sorozat előrendezett) 10
Rendezések 7. Használt adatszerkezet szerint - lineáris adatszerkezet - fa 8. Módszer szerint: pl. összehasonlításos rendezőknél: - max. elemet kiválasztó - csererendezők - egy elemet helyre vivők - összefuttatásos rendezők 11
Rendezések Milyen hatékony egy algoritmus? Legtöbbször csak a lépésszám nagyságrendje érdekes. Hogyan függ a lépésszám az input méretétől? Az input méretét legtöbbször n-nel jelöljük. A lépésszám ennek egy f függvénye, azaz ha n méretű az input, akkor az algoritmus f(n) lépést végez. Igazából az f függvény az érdekes. 100n vagy 101n, általában mindegy n 2 vagy n 3 már sokszor nagy különbség, de néha mindegy n 2 vagy 2 n már mindig nagy különbség 12
Függvények nagyságrendje Definíció: Ha f(x) és g(x) az R + egy részhalmazán értelmezett valós értékeket felvevő függvények, akkor f = O(g) jelöli azt a tényt, hogy vannak olyan c, k > 0 állandók, hogy f(x) c * g(x) teljesül, ha x k. A g aszimptotikus felső korlátja f-nek. Például: 100n + 300 = O(n), hiszen k = 300; c = 101-re teljesülnek a feltételek, 100n + 300 101n, ha n 300 13
Függvények nagyságrendje Definíció: Ha f(x) és g(x) az R + egy részhalmazán értelmezett valós értékeket felvevő függvények, akkor f = (g) jelöli azt a tényt, hogy vannak olyan c, k > 0 állandók, hogy f(x) c * g(x) teljesül, ha x k. A g aszimptotikus alsó korlátja f-nek. Például: 100n - 300 = (n), hiszen n 300; c = 99-re teljesülnek a feltételek. 14
Függvények nagyságrendje Definíció: Ha f = O(g) és f = (g) is teljesül, akkor f= (g). A g aszimptotikus éles korlátja f-nek. Például: 100n - 300 = (n) 15
16
17
18
Buborék rendezés Feladat: Rendezzük az A[1..n] vektort! A vektor elemtípusa tetszőleges T típus, amire egy teljes rendezés értelmezhető. Buborék rendezés alapötlete: a vektor elejétől kezdve felbuborékoltatjuk a legnagyobb elemet. Utána ugyanezt tesszük az eggyel rövidebb vektorra, stb. Végül, utoljára még az első két elemre is végrehajtjuk a buborékoltatást. 19
Buborék rendezés Egy sorozat rendezett nincs az elemek között inverzió. Ez a rendezés az inverziók csökkentésével rendez. 12 5 7 9 11 10 20
Buborék rendezés 12 5 7 9 11 10 21
Buborék rendezés 5 12 7 9 11 10 22
Buborék rendezés 5 12 7 9 11 10 23
Buborék rendezés 5 7 12 9 11 10 24
Buborék rendezés 5 7 12 9 11 10 25
Buborék rendezés 5 7 9 12 11 10 26
Buborék rendezés 5 7 9 12 11 10 27
Buborék rendezés 5 7 9 11 12 10 28
Buborék rendezés 5 7 9 11 12 10 29
Buborék rendezés 5 7 9 11 10 12 30
Buborék rendezés 5 7 9 11 10 12 31
Buborék rendezés 5 7 9 11 10 12 32
Buborék rendezés 5 7 9 11 10 12 33
Buborék rendezés 5 7 9 11 10 12 34
Buborék rendezés 5 7 9 11 10 12 35
Buborék rendezés 5 7 9 10 11 12 36
Buborék rendezés 5 7 9 10 11 12 37
Buborék j n j 2 i 1 i j - 1 A[i] A[i+1]? skip Csere(A[i], A[i+1]) i i+1 j j - 1 38
Buborék j n j 2 i 1 i j - 1 A[i] A[i+1]? skip Csere(A[i], A[i+1]) i i+1 j j - 1 39
Buborék j n j 2 i 1 i j - 1 A[i] A[i+1]? skip Csere(A[i], A[i+1]) i i+1 j j - 1 40
Műveletek időigénye: Buborék c1 c2 c1 c2 c3 c4 c1 c1 skip j 2 i 1 j n i j - 1 A[i] A[i+1] Csere(A[i], A[i+1]) i i+1 j j - 1 41
Buborék rendezés T(A) időráfordítás: külső ciklus: n-1 szer fut le, előtte kezdőértékadás. A cf-t n-szer ellenőrzi, j-t n-1-szer csökkenti: c1 + n * c2 + (n-1)*c1 belső ciklus lefutásainak száma: n-1, n-2, 2,1 mindannyiszor 1 kezdőértékadás, a cf-t eggyel többször ellenőrzi, i-t növeljük (1+ + n-1)-szer: (n-1) *c1 + (2+ +n)*c2 + (1+ + n-1)*c1 42
Buborék rendezés A[i] és A[i+1] összehasonlításainak száma: (1+ + n-1)*c3 A cserék száma A-tól függ = A inverzióinak száma ez 0 és ( n 2) között van inv(a)*c4 43
Buborék rendezés T(A)= c1 + n * c2 + (n-1)*c1 +(n-1) *c1 + (2+ +n)*c2 + (1+ + n-1)*c1 + (1+ + n-1)*c3 + inv(a)*c4 = c1 + n*c2 + n*c1 - c1 + n*c1 - c1 + (n+2)*(n-1)/2*c2 + n*(n-1)/2*c1 + n*(n-1)/2*c3 + inv(a)*c4 = n 2 * (c1/2 + c2/2 + c3/2) + n*( 3*c1/2 + 3*c2/2 c3/2) (c1 +c2) + inv(a)*c4 44
Buborék rendezés Néhány egyszerűsítő feltételezés: 1. Feltételezés: c 1 << c 3 és c 2 << c 4 vagyis az elemek összehasonlítása és cseréje adja a költség javát. Ekkor T(A) n 2 * c 3 /2 - n* c 3 /2 + inv(a)*c 4 = n*(n-1)/2 *c 3 + inv(a)*c 4 45
Buborék rendezés 2. Feltételezés: c 3 és c 4 az egyes gépekre jellemző állandók. Ha történetesen c 3 c 4, akkor a végrehajtási időt jellemzi a domináns műveletek száma: T(A) n*(n-1)/2 + inv(a) T(A) helyett T(n)-t bevezetve, a szokásos írásmód: T(n) n*(n-1)/2 + inv(a) 46
Buborék rendezés 3. Feltételezés: általában külön-külön kérdezzük az egyes műveletek számát: Ö(n) n*(n-1)/2 Cs(n) inv(a) 47
Buborék rendezés 4. Feltételezés: ismerjük a lehetséges bejövő input adatokat, kiszámíthatjuk a legrosszabb ( M T(n) ) és a legjobb esetben ( m T(n) ezt nem szokták kérdezni) átlagos esetben (A T(n) ) 48
Buborék rendezés az összehasonlítások száma minden n hosszú vektorra ugyanannyi: M Ö(n) = m Ö(n) = A Ö(n) = n*(n-1)/2 a cserék száma: M Cs(n) = n*(n-1)/2 m Cs(n) = 0 A Cs(n) = n*(n-1)/4 = M Cs(n) /2 (bebizonyítható) 49
Buborék rendezés 5. Feltételezés: Gyakran a költség (műveletszám) nagyságrendje, aszimptotikus viselkedése érdekel. M Ö(n)= n*(n-1)/2 = (n 2 ) M Cs(n)= n*(n-1)/2 = (n 2 ) A Cs(n)= n*(n-1)/4 = (n 2 ) 50
Buborék rendezés Javított változat: Ha nincs már csere, leáll. Cserék száma nem változik. M Ö(n) nem változik. m Ö(n) = n-1 A Ö(n) =? (sejtés: n 2 ) 51
Maximum kiválasztásos rendezés Ötlet: feltételezzük, hogy az A[1..n] tömb jobb széle (j+1..n) már rendezve van, minden lépésben kiválasztjuk az A[1..j] résztömb maximális elemét, és kicseréljük a j. helyen lévővel, majd j-t csökkentjük. Kezdetben j értéke n. 12 5 7 6 11 10 52
Maximum kiválasztásos rendezés max: 12 ind: 1 12 5 7 6 11 10 53
Maximum kiválasztásos rendezés 10 5 7 6 11 12 54
Maximum kiválasztásos rendezés max: 11 ind: 5 10 5 7 6 11 12 55
Maximum kiválasztásos rendezés 10 5 7 6 11 12 56
Maximum kiválasztásos rendezés max: 10 ind: 1 10 5 7 6 11 12 57
Maximum kiválasztásos rendezés És így tovább 6 5 7 10 11 12 58
Maxkiv_Rend j n j 2 Maxkiv(A[1..j], ind, max) Csere(A[ind], A[j]) j j - 1 59
Maxkiv_Rend j n j 2 Maxkiv(A[1..j], ind, max) Csere(A[ind], A[j]) j j - 1 M Ö(n) (n-1) + (n-2) + +1 = (n 2 ) n elem közül a max kiválasztása legalább n-1 összehasonlítás 60
Maxkiv (A[1..j], ind, max) i 1; ind 1; max A[1] i < j A[i+1] > max? ind max i+1; A[i+1] i i+1 61
Maxkiv (A[1..j], ind, max) i 1; ind 1; max A[1] i < j A[i+1] > max? ind max i+1; A[i+1] i i+1 62
Beszúró rendezés Egyszerű beillesztéssel egy egy elemet a helyére viszünk megkeressük, hogy hová való a már rendezett sorozatban. Ha tömbben tároljuk, akkor a mozgatások száma is fontos. 63
64
Beszúró rendezés 12 5 7 6 11 10 65
Beszúró rendezés 5 12 5 7 6 11 10 66
Beszúró rendezés 5 12 5 7 6 11 10 67
Beszúró rendezés 5 12 7 6 11 10 68
Beszúró rendezés 7 5 12 7 6 11 10 69
Beszúró rendezés 7 5 12 7 6 11 10 70
Beszúró rendezés 5 7 12 6 11 10 71
Beszúró rendezés 6 5 7 12 6 11 10 72
Beszúró rendezés 6 5 7 12 6 11 10 73
Beszúró rendezés 6 5 7 12 6 11 10 74
Beszúró rendezés És így tovább 5 6 7 12 11 10 75
Beszúró j 1 j n-1 w A[j+1]; i j i 1 A[i] > w A[i+1] A[i] i i-1 A[i+1] w j j + 1 76
Beszúró j 1 j n-1 w A[j+1]; i j i 1 A[i] > w A[i+1] A[i] i i-1 A[i+1] w j j + 1 77
Beszúró rendezés Műveletigény: M Ö(n) = n*(n-1)/2 = (n 2 ) A Ö(n) M Ö(n) /2 = (n 2 ) m Ö(n) = n 1 M a mozgatás művelete: M M(n) = (n+2)*(n-1)/2= (n 2 ) A M(n) = n2/4 = (n 2 ) m M(n) = 2*(n-1) = (n) 78