Kupacrendezés. Az s sorban lévő elemeket rendezzük a k kupac segítségével! k.empty. not s.isempty. e:=s.out k.insert(e) not k.

Átírás

1 10. Előadás

2 Beszúró rendezés Használjuk a kupacokat rendezésre! Szúrd be az elemeket egy kupacba! Amíg a sor ki nem ürül, vedd ki a kupacból a maximális elemet, és tedd az eredmény (rendezett) sorba! 2

3 Kupacrendezés Az s sorban lévő elemeket rendezzük a k kupac segítségével! k.empty not s.isempty e:=s.out k.insert(e) not k.isempty e:=k.delmax s.in(e) 3

4 Kupacrendezés A kupacok hatékony rendezőt adnak: Szúrjunk be minden elemet a kupacba n elem, ezekhez kell O(log 2 n) O(n log n) sorrendben távolítsuk el az elemeket n elem, ezekhez kell O(log 2 n) O(n log n) Összesen O(n log n) ignorálva a 2-es konstanst, stb. Nézzünk meg egy animációt a kupacrendezésre! 4

5 Gyorsrendezés (Quicksort) hatékony rendezési algoritmus C.A.R. Hoare készítette, Az Oszd meg és Uralkodj algoritmus egy példája Két fázis Partíciós fázis Oszd a munkát két részre! Rendezési fázis Uralkodj a részeken!

6 Gyorsrendezés (Quicksort) Partíció Válassz egy strázsát (pivot)! Válaszd a strázsa pozícióját olyanra, hogy minden elem tőle jobbra nagyobb legyen! minden elem tőle balra kisebb legyen! < strázsa strázsa > strázsa

7 Gyorsrendezés (Quicksort) Uralkodj Alkalmazd ugyanezt az algoritmust mindkét félre! < strázsa > strázsa < p p > p strázsa < p p > p

8 Gyorsrendezés (Quicksort) Implementáció quicksort( void *a, int also, int felso ) { int pivot; /* Terminálási feltétel! */ if ( felso > also ) { pivot = feloszt( a, also, felso ); } quicksort( a, also, pivot-1 ); quicksort( a, pivot+1, felso ); } Oszd meg Uralkodj

9 Quicksort - Megosztás Ez a példa int-eket használ az egyszerűség kedvéért! Bármelyik elem jó strázsának, válaszd a bal szélsőt! also felso

10 Quicksort - Megosztás állítsd be a bal és jobb végét bal jobb also str_elem: 23 felso

11 Quicksort - Megosztás mozgasd a jelzéseket, míg szembetalálkoznak! bal jobb also str_elem: 23 felso

12 Quicksort - Megosztás mozgasd a bal jelzőt, míg a str_elem-nél elemekre mutat! mozgasd a jobb jelzőt hasonlóan bal jobb also str_elem: 23 felso

13 Quicksort - Megosztás Cseréld ki a str_elem két oldalán rossz sorrendben lévő elemeket! bal jobb also str_elem: 23 felso

14 Quicksort - Megosztás A bal és a jobb szembetalálkoztak, így állj le! bal jobb also str_elem: 23 felso

15 Quicksort - Megosztás Végül cseréld ki a str_elem -et és a bal -nál lévőt bal jobb also str_elem: 23 felso

16 Quicksort - Megosztás add vissza az str_elem pozícióját! bal also str_elem: 23 felso

17 Quicksort Uralkodj! rekurzívan rendezi a bal felét rekurzívan rendezi a jobb felét str_elem: 23

18 Gyorsrendezés algoritmusa Gyorsrendezés (A, also, felso) also < felso q := Feloszt(A, also, felso) Gyorsrendezés (A, also, q-1) Gyorsrendezés (A, q+1, felso) SKIP (A vektorban, also és felso indexek között)

19 Feloszt(A, also, felso) str_elem:=a[also]; bal:=also; jobb:=felso; bal < jobb A[bal]<= str_elem and bal <felso bal:= bal+1 A[jobb]>= str_elem and jobb >also jobb:= jobb-1 bal < jobb Csere(A[bal], A[jobb]) SKIP A[also]:=A[bal]; A[bal]:= str_elem; return bal;

20 Quicksort - Analízis Felosztás vizsgálj meg minden elemet egyszer O(n) Uralkodás az adatok kétfelé osztása O(log 2 n) összesen szorzat O(n log n) ugyanaz, mint a Heapsort a quicksort általában gyorsabb kevesebb összehasonlítás De van egy gond

21 Quicksort az igazság! Mi történik, ha az adatok már rendezettek, vagy majdnem rendezettek? Azt várnánk, hogy akkor gyorsabb lesz!

22 Quicksort az igazság! Rendezett adatok pivot? < pivot > pivot

23 Quicksort az igazság! Rendezett adatok Minden partíció létrehoz egy 0 méretű feladatot és egy n-1 méretűt! A partíciók száma? pivot > pivot pivot > pivot

24 Quicksort az igazság! Rendezett adatok Minden partíció létrehoz egy 0 méretű feladatot és egy n-1 méretűt! A partíciók száma? minden n időigénye O(n) összesen n O(n) pivot pivot > pivot > pivot vagyis O(n 2 ) A Quicksort olyan rossz, mint a buborék vagy a beszúrásos rendezés?

25 Quicksort az igazság! A Quicksort O(n log n) viselkedése a majdnem egyforma partíciókon múlik O( log n ) van Átlagosan is majdnem ez a helyzet és a Quicksort általában O(n log n) Mit lehet tenni? Általában semmit De javíthatjuk az esélyeinket!

26 Quicksort A pivot választása Bármelyik strázsa megteszi Válasszunk egy másikat pivot < pivot > pivot amikor a partíciók egyformák akkor O(n log n) időre lesz szükség

27 Quicksort 3-ból a középső pivot Végy 3 pozíciót, és válaszd a középsőt Pl. első, középső, utolsó a középső 5 ez a rendezett adatok legjobb felosztása! O(n log n) idő Mivel a rendezett (vagy majdnem rendezett) adatok elég gyakoriak, ez egy jó stratégia különösen, ha azt várjuk, hogy az adataink rendezettek lesznek!

28 Quicksort Véletlen pivot Válassz egy strázsát véletlenszerűen Minden felosztásnál másik pozíciót Átlagosan a rendezett adatokat jól osztja szét O(n log n) idő Kulcs követelmény: A pivot kiválasztása O(1) idő kell legyen

29 Quicksort - Garantált O(n log n)? Soha! A tetszőleges pivot választási stratégia vezethet O(n 2 ) időhöz Itt a 3-ból a középső kiválasztja a 2-t egy partícióba 1 elem kerül, a másikba 7 következőnek kiválasztja a 4-t egy partícióba 1 elem kerül, a másikba

30 Rendezés Buborék, Beszúrásos, Maximumkiválasztásos O(n 2 ) rendezések egyszerű kód kis n-re gyors lehet (rendszer függő) Quick Sort Oszd meg és uralkodj O(n log n)

31 Quicksort O(n log n) de. Lehet O(n 2 ) is A pivot kiválasztásától függ 3-ból a középső véletlen pivot Jobb, de nem garantált

32 Quicksort használjuk inkább a Heapsort-ot? A Quicksort általában gyorsabb kevesebb összehasonlítás és csere néhány empirikus adat: Quick Heap Beszúró Hasonl Csere Hasonl Csere Hasonl Csere

33 Quicksort Heap Sort Quicksort általában gyorsabb néha O(n 2 ) jobb pivot választás csökkenti a valószínűségét ha átlagosan jó végrehajtási időt akarunk, használjuk ezt üzleti alkalmazások, információs rendszerek Heap Sort általában lassúbb Garantált O(n log n) lehet rá építeni, ezt a tervezésben felhasználni! használjuk például real-time rendszerekhez Az idő egy megszorítás