Az előadás letöltése folymat van. Kérjük, várjon

Az előadás letöltése folymat van. Kérjük, várjon

(Bináris) Kupac (heap) adattípus Bináris fa, amelyben minden csomópont értéke nagyobb mindegyik leszármazottjáénál  kupactulajdonság (alaptípus, típusinvariáns)

Hasonló előadás


Az előadások a következő témára: "(Bináris) Kupac (heap) adattípus Bináris fa, amelyben minden csomópont értéke nagyobb mindegyik leszármazottjáénál  kupactulajdonság (alaptípus, típusinvariáns)"— Előadás másolata:

1

2 (Bináris) Kupac (heap) adattípus Bináris fa, amelyben minden csomópont értéke nagyobb mindegyik leszármazottjáénál  kupactulajdonság (alaptípus, típusinvariáns) Magasság: a csúcsból a levélig vezető leghosszabb út Kiegyenlített: csak az utolsó réteg lehet nem teljes Ábrázolás: vektorban, rétegenként Minden réteg mérete=korábbi rétegek+1. Minden réteg első elemindexe=2 h Szülő: i/2 Balfa: 2*i Jobbfa: 2*i + 1

3 Adattípus definíció Kupac: csak a rendezésekre koncentrál Elsőbbségi sor: adatbeszúrás, törlés stb. Használatuk: az integer tömb csak az adatok „kulcsát” (a rendezés kulcsát) jelzik, ehhez a gyakorlatban még járulékos adatok is tartoznak Pl: operációs rendszerekben a párhuzamosan futó feladatok listájának kezelésére használják

4 Kupac helyreállító eljárás egy elemre kupacol(int i) – Feltételezzük, hogy i-re (a csomópont és gyerekei között) nem teljesül a kupactulajdonság, de feljebb igen private void kupacol(int i) { int bal = balkupac(i); int jobb = jobbkupac(i); int legnagyobb; if (bal tomb[i]) legnagyobb = bal; else legnagyobb = i; if (jobb tomb[legnagyobb]) legnagyobb = jobb; if (legnagyobb!=i) { int csere = tomb[i]; tomb[i] = tomb[legnagyobb]; tomb[legnagyobb] = csere; kupacol(legnagyobb); } } Jobbrekurzió. Hogyan lehetne ciklussá átalakítani? Ha megtalálta a helyét, akkor már nem mozgatjuk/ keresünk tovább lefelé.

5 Kupacolás működés közben Hatékonyság: Θ(magasság)  Θ(log(n)) Egyetlen elemet görget lefelé addig, amíg a saját helyét el nem éri

6 Kupacolás teljes fára Kupacolás: a rossz helyen levő elemeket lefelé görgeti, mindig a nagyobb gyerek felé Vagyis: levélelemekre nem lehet kupacolni Teljes fára: minden egyes elemére, a levelek feletti elemtől kezdve a gyökérig (bottom- up) public void epit() { for (int i=(meret-1)/2; i>0; i--) kupacol(i); }

7 Kupacépítés hatékonysága Hatékonyság(1): O(n log n) ??? Hatékonyság(2): - kupacol futási ideje a csúcs magasságának lineáris függvénye O(h) Bármely h magasságú (levéltől számítva) csúcsok száma legfeljebb <= n/(2 h+1 ) -- ha a fa teljes lenne, akkor „=„ „Épít” futásideje „h” szerint összegezve h=0 Σ lg(n) (n/2 h+1 ) * O(h) = O(n* h=0 Σ lg(n) (h/2 h )) 0 Σ ∞ …= 0+1/2+2/4+3/8… = KONSTANS  hatékonyság = O(n)  a kupaccá alakítás lineáris idő alatt fut le

8 A kupacrendezés algoritmusa (Növekvő sorrendbe rendezünk…) - a legnagyobb elem a gyökér, az legyen a legutolsó  az utolsót és az elsőt cseréljük - eggyel rövidebb vektort kupacoljuk. (csak az új első elem sértheti a kupactulajdonságot) public void rendez() { epit(); for (int i=hossz-1; i>0; i--) { int csere = tomb[i]; tomb[i]=tomb[0]; tomb[0] = csere; hossz--; kupacol(0); } Hatékonysága: O(n logn)

9 Kupacrendezés (példa) ,14,10,8,7,9,3,2,4,1 14,8,10,4,7,9,3,2,1| ,8,10,4,7,9,3,2|14,16 1,14,10,8,7,9,3,2,4|16 2,8,9,4,7,1,3|10,14, ,8,3,4,7,1,2|10,14,16 2,8,3,4,7,1|9,10,14, ,7,3,4,2,1|9,10,14,16 1,7,3,4,2|8,9,10,14,16 Stb. stb. stb….

10 Elsőbbségi sorok Maximális elem visszaadása: public class elsobbSor extends kupac { public integer max() { return (tomb(0)); } Maximális elem kivétele és törlése: public integer kiveszMax() { int maxi = max(); tomb[0] = tomb[meret--]; kupacol(0); return(maxi);}

11 Elsőbbségi sorok (tovább) Elem beszúrása: public void beszur(int x) { tomb[++meret]=x; int i=meret-1; while (i>0 && tomb[szulo(i)]

12 Rendezések Időszükséglet (legrosszabb, átlagos) Helyszükséglet (helyben rendező) Legelterjedtebb fajtái: –Buborékrendezés: (O(n 2 )) –Beszúró rendezés: (Θ(n 2 )) –Összefésülő rendezés: (Θ(n*log(n))) –Kupacrendezés: (O(n*log(n))) –Gyorsrendezés: (Θ(n 2 )) - legrosszabb esetre, átlagosan csak Θ(n*log(n)) kicsi a konstans szorzó helyben rendez Virtuális memóriabeli környezetben is jól használható

13 Gyorsrendezés (Hoare, 1962) Alapelve: (oszd meg és uralkodj) –1. felosztjuk az A[p..r]  A1[p..q] és A2[q+1..r] szakaszokra úgy, hogy A1<=A2 (DE!! NINCSenek rendezve!!) –2. Az A1 és A2 résztömböket rendezzük –3. Nincs szükség összefésülésre Az algoritmus sarokpontja: az 1. felosztó lépés. Ennek megvalósítása többféle is lehet public void gyorsrendez(int also, int felso) { if (also

14 Gyorsrendezés felosztó algoritmusa A tomb(also,felso) résztömböt helycserék útján felosztjuk úgy, hogy tomb(also,kozep)

15 (rész)-Példa 5, 3, 2, 6, 4, 1, 3, 7őr=5 5, 3, 2 | 6, 4, 1, 3 | 7csere 6  3 5, 3, 2, 3, 4, 1| 6, 7felosztva 1-6 között, tovább bal fél 5, 3, 2, 3, 4, 1őr=5, pont a legnagyobb elem, alulról elindulva elérjük a lista utolsó elemét: csere 1  5 1, 3, 2, 3, 4 | 5felosztva 4-5 között, tovább bal fél 1, 3, 2, 3, 4őr=1 1 | 3, 2, 3, 4felosztva 1-3 között, tovább jobb fél 3, 2, 3, 4őr=3 3, 2 | 3, 4felosztva 2-3 között, tovább bal fél 3, 2őr=3 legnagyobb elem. Csere 3  2 3, 4őr=3 legnagyobb elem: Csere 6  4

16 Hatékonyság: Legrosszabb felosztás Legrosszabb eset, ha 1—n-l tömbökre osztunk fel Rekurziós fa: Felosztás: Θ(n), ezt n-szer kell megtenni: T(n)=T(n-1)+Θ(n) T(n)= i=1 Σ n Θ(i)= Θ( i=1 Σ n i)= Θ(n 2 ) Maximálisan kiegyensúlyozatlan a felosztás n n-1 n-2 n

17 Hatékonyság: Kiegyensúlyozott felosztás n Hatékonyság: Θ (n*lg(n)) hasonlóan pl. a kupacrendezéshez n/2 n/ *n 2*n/2 4*n/4 lg(n) n*lg(n)

18 Mitől függ a hatékonyság? Mikor lesz 1..n-l felosztás? 1 | 4, 6, 7, 3, 2  az első a legkisebb/legnagyobb elem 6, 2, 5, 4, 3, 1  csere 6-1  1, 2, 5, 4, 3 | 6 Pl. a már sorbarendezett lista: extrém rossz Javaslat1: véletlen keverés O(n) időben Javaslat2: véletlen felosztás: –Őrkifejezés a lista véletlen eleme legyen –Az első elemet egy véletlen elemmel kicseréljük Veremmélység: a közölt rekurzív algoritmusra: Θ(log(n)) A rekurzió azonban kiküszöbölhető!!

19 Összehasonlító rendezések A bemenő tömb rendezettségét az elemei közötti összehasonlítási reláción keresztül értelmezzük, és ezt végezzük el az elemek között… Döntési fa: csomópontjai a döntések, levelei az egyes lehetséges bemenő sorok. Rendezés: fabejárás gyökértől levélig (közben mozgatás) Leveleken: bemenő sorról teljes információ (permutáció) a1?a2 a2?a3a1?a3 a2?a3 1,2,3 1,3,22,3,1 2,1,3 3,1,23,2,1 <= > > > >

20 Lépések (összehasonlítások) száma: a fa magassága Tétel: n elemet rendező döntési fa Ω(n*log(n)) magas (legalább) Biz: tfh. n elemű sort rendező h magas fa. Levelek (permutációk) száma legalább n!. Fa leveleinek száma: =lg(n!) Viszont (Stirling formula): n!>(n/e) n  h>lg(n/e) n  h> n*(lg(n)- lg(e)) = Ω(n*log(n)) Következmény: az nlog(n) rendezések (kupac- és összefésüléses rendezés) aszimptotikusan optimális rendezések Összehasonlító rendezések

21 Lineáris időben lefutó rendezések Leszámláló rendezés Feltétel: 1

22 Leszámláló rendezés példa BE: 3, 6, 4, 1, 3, 4, 1, 40

23 Leszámláló rendezés programkód private int leszamlalMax = 30; public int[] leszamlal(int[] tomb,int meret) { int gy[] = new int[leszamlalMax]; int ki[] = new int[meret]; for(int i=1;i 1;i--) { ki[gy[tomb[i]]--]=tomb[i]; } return ki; } Egyes értékek előfordulási gyakoriságai Összegzett gyakoriságok. Hányan vannak előttem

24 Számjegyes rendezés Több helyiértékkel/több dimenzióval rendelkező mennyiség rendezése esetén, ha egy helyiérték csak véges felsorolás lehet (pl számjegyek) Helyigény: átpakoljuk az elemeket n db. vektorba Megoldás: a legkisebb helyiérték szerint rendezzük először, azután haladunk az egyre nagyobb helyiértékek felé Közben nem cserélhetünk fel egyes elemeket!!!

25 Számjegyes rendezés példa ÓRAÓRALAPÁGY LAPTEALÁBFÜL TEALÁBTEAGÉP GÉPINGGÉPING INGFÜLKÉSKÉS SZÓSZÓÁGYLAP FÜLLAPINGLÁB ORRGÉPSORORR LÁBORRORRÓRA SORSORÓRASOR KÉSKÉSFÜLSZÓ ÁGYÁGYSZÓTEA

26 Edényrendezés Feltételezés: kulcsok egyenletesen oszlanak el az 0..1 intervallumban, a tömb n elemet tartalmaz Felosztjuk az intervallumot n egyenlő részre  ezek lesznek az edények Hely: edénytároló n hosszú vektor Az egyes edényekben láncolt listákat kezelünk (ezek nem túl hosszúak), és ezeket valami egyszerű eljárással rendezzük Algoritmus: 1. Beszúrjuk az elemet a megfelelő edénybe 2. Az egyes edényeket rendezzük 3. Sorban összefűzzük az egyes edényeket

27 Edényrendezés - példa.78,.17,.39,.26,.72,.94,.21,.12,.23,.68.94|*.72|.78|*.68|*.39|*.21|.23|.26|*.12|.17|* Hatékonyság: lineáris O(n) Miért? Az elemek egyenletes eloszlása miatt. Vagyis kevés a listában a luk, és a láncok pedig rövidek…


Letölteni ppt "(Bináris) Kupac (heap) adattípus Bináris fa, amelyben minden csomópont értéke nagyobb mindegyik leszármazottjáénál  kupactulajdonság (alaptípus, típusinvariáns)"

Hasonló előadás


Google Hirdetések