Rendezések. A rendezési probléma: Bemenet: Kimenet: n számot tartalmazó (a 1,a 2,,a n ) sorozat

Átírás

1 9. Előadás

2 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

3 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

4 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

5 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

6 Rendezések Például: Személy= Név x Magasság x Születési_év Abigél Janka Zsuzsi Dávid Dorka Akármelyiket választhatjuk kulcsnak mindegyiken van értelmezve rendezés. 6

7 Rendezések Ha a név a kulcs: Abigél Dávid Dorka Janka Zsuzsi

8 Rendezések Ha a születési év a kulcs: Abigél Janka Dávid Zsuzsi Dorka

9 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

10 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

11 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

12 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

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 = 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 = O(n), hiszen k = 300; c = 101-re teljesülnek a feltételek, 100n n, ha n

14 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 = (n), hiszen n 300; c = 99-re teljesülnek a feltételek. 14

15 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 = (n) 15

16 16

17 17

18 18

19 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

20 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

21 Buborék rendezés

22 Buborék rendezés

23 Buborék rendezés

24 Buborék rendezés

25 Buborék rendezés

26 Buborék rendezés

27 Buborék rendezés

28 Buborék rendezés

29 Buborék rendezés

30 Buborék rendezés

31 Buborék rendezés

32 Buborék rendezés

33 Buborék rendezés

34 Buborék rendezés

35 Buborék rendezés

36 Buborék rendezés

37 Buborék rendezés

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

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

40 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

41 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

42 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

43 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

44 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

45 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

46 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

47 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

48 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

49 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

50 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

51 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

52 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

53 Maximum kiválasztásos rendezés max: 12 ind:

54 Maximum kiválasztásos rendezés

55 Maximum kiválasztásos rendezés max: 11 ind:

56 Maximum kiválasztásos rendezés

57 Maximum kiválasztásos rendezés max: 10 ind:

58 Maximum kiválasztásos rendezés És így tovább

59 Maxkiv_Rend j n j 2 Maxkiv(A[1..j], ind, max) Csere(A[ind], A[j]) j j

60 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

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 61

62 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

63 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 64

65 Beszúró rendezés

66 Beszúró rendezés

67 Beszúró rendezés

68 Beszúró rendezés

69 Beszúró rendezés

70 Beszúró rendezés

71 Beszúró rendezés

72 Beszúró rendezés

73 Beszúró rendezés

74 Beszúró rendezés

75 Beszúró rendezés És így tovább

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

77 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

78 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