Rendezési algoritmusok belső rendezés külső rendezés



Hasonló dokumentumok
Párhuzamos programozás

Kupac adatszerkezet. A[i] bal fia A[2i] A[i] jobb fia A[2i + 1]

Szakdolgozat. Miskolci Egyetem. Rendezési algoritmusok szemléltetése. Készítette: Fekete Enikő Programtervező informatikus szak

Érettségi feladatok Algoritmusok egydimenziós tömbökkel (vektorokkal) 1/6. Alapműveletek

end function Az A vektorban elõforduló legnagyobb és legkisebb értékek indexeinek különbségét.. (1.5 pont) Ha üres a vektor, akkor 0-t..

1. ábra. Egy rekurzív preorder bejárás. Egy másik rekurzív preorder bejárás

2. Milyen értéket határoz meg az alábbi algoritmus, ha A egy vektor?. (2 pont)

Kupac adatszerkezet. 1. ábra.

Algoritmuselmélet. Keresés, rendezés, buborék, beszúrásos, összefésüléses, kupacos, láda, radix. Katona Gyula Y.

Algoritmusok vektorokkal keresések 1

Programozási módszertan. Dinamikus programozás: Nyomtatási feladat A leghosszabb közös részsorozat

XIII. Bolyai Konferencia Bodnár József Eötvös József Collegium, ELTE TTK, III. matematikus. A véletlen nyomában

Összetett programozási tételek Rendezések Keresések PT egymásra építése. 10. előadás. Programozás-elmélet. Programozás-elmélet 10.

Analízis elo adások. Vajda István október 3. Neumann János Informatika Kar Óbudai Egyetem. Vajda István (Óbudai Egyetem)

Érdekes informatika feladatok

Edényrendezés. Futási idő: Tegyük fel, hogy m = n, ekkor: legjobb eset Θ(n), legrosszabb eset Θ(n 2 ), átlagos eset Θ(n).

Egyszerű programozási tételek

Számjegyes vagy radix rendezés

REKURZIÓ. Rekurzív: önmagát ismétlő valami (tevékenység, adatszerkezet stb.) Rekurzív függvény: függvény, amely meghívja saját magát.

1. ábra. Számláló rendezés

8. Mohó algoritmusok Egy esemény-kiválasztási probléma. Az esemény-kiválasztási probléma optimális részproblémák szerkezete

14. Mediánok és rendezett minták

2015, Diszkrét matematika

Gyakorló feladatok ZH-ra

Mesterséges intelligencia 1 előadások

Számláló rendezés. Példa

Algoritmuselmélet. Király Zoltán ELTE Matematikai Intézet február 18. Legfrissebb, on-line verzió:

Kriptográfiai algoritmus implementációk időalapú támadása Endrődi Csilla, Csorba Kristóf BME MIT

I. Elemi algoritmusok

Azonosító jel: Matematika emelt szint

értékel függvény: rátermettségi függvény (tness function)

Programozás I. Metódusok C#-ban Egyszerű programozási tételek. Sergyán Szabolcs

Dinamikus programozás vagy Oszd meg, és uralkodj!

S z á m í t ó g é p e s a l a p i s m e r e t e k

Programozási módszertan. Mohó algoritmusok

Analízis elo adások. Vajda István szeptember 24. Neumann János Informatika Kar Óbudai Egyetem. Vajda István (Óbudai Egyetem)

Permutáció n = 3 esetében: Eredmény: permutációk száma: P n = n! romámul: permutări, angolul: permutation

Bevezetés a programozásba. 12. Előadás: 8 királynő

A kurzus teljesítésének feltételei. Az I404 kódú kurzus teljesítéséhez meg kell oldani egy otthoni feladatot, határidő április 30.

Táblázatok fontosabb műveletei 1

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.

Programozás I gyakorlat. 5. Struktúrák

23. Fa adatszerkezetek, piros-fekete fa adatszerkezet (forgatások, új elem felvétele, törlés)(shagreen)

Specifikáció. B logikai formula, a bemeneti feltétel, K logikai formula, a kimeneti feltétel, A az algoritmus, amelyre az állítás vonatkozik.

Pásztor Attila. Algoritmizálás és programozás tankönyv az emeltszintű érettségihez

Lineáris algebra gyakorlat

Megoldott feladatok. Informatika

Specifikáció. B logikai formula, a bemeneti feltétel, K logikai formula, a kimeneti feltétel, A az algoritmus, amelyre az állítás vonatkozik.

Dr. Schuster György február 21. Real-time operációs rendszerek RTOS

Jelek tanulmányozása

PONTSZÁMÍTÁSI KÉRELEM felsőfokú végzettség alapján (alap- és osztatlan képzésre jelentkezőknek)

A Hozzárendelési feladat megoldása Magyar-módszerrel

Elemi adatszerkezetek

I. ALAPALGORITMUSOK. I. Pszeudokódban beolvas n prim igaz minden i 2,gyök(n) végezd el ha n % i = 0 akkor prim hamis

BASH script programozás II. Vezérlési szerkezetek

BOLYAI MATEMATIKA CSAPATVERSENY FŐVÁROSI DÖNTŐ SZÓBELI (2005. NOVEMBER 26.) 5. osztály

Erdélyi Magyar TudományEgyetem (EMTE

Haladó rendezések. PPT 2007/2008 tavasz.

A digitális számítás elmélete

Dr. Schuster György február / 32

Többfelhasználós adatbázis környezetek, tranzakciók, internetes megoldások

Véletlenszám generátorok. 5. előadás


A félév során előkerülő témakörök

ÖNJAVÍTÓ AGGREGÁLÁS SZENZORHÁLÓZATOKBAN ÉS AGGREGÁTOR NODE VÁLASZTÁS. Schaffer Péter. Tézisfüzet. Konzulens: Buttyán Levente, Ph.D.

1. Írja fel prímszámok szorzataként a 420-at! 2. Bontsa fel a et két részre úgy, hogy a részek aránya 5 : 4 legyen!

Programozási alapismeretek :: beadandó feladat. Felhasználói dokumentáció. Molnár Tamás MOTIABT.ELTE

Programozási tételek

Matematikai alapok. Dr. Iványi Péter

1. Alapfogalmak Algoritmus Számítási probléma Specifikáció Algoritmusok futási ideje

Szirmay-Kalos László. L(x, ω)=l e (x,ω)+ L(h(x,-ω),ω) f r (ω,x, ω) cos θ dω A jobb oldali radiancia:

angolul: greedy algorithms, románul: algoritmi greedy

ELVÉ NO LIMIT 120 GOKART LIGA Ahol a súly nem számít

Kombinatorika. 9. előadás. Farkas István. DE ATC Gazdaságelemzési és Statisztikai Tanszék. Kombinatorika p. 1/

Adatszerkezetek 7a. Dr. IványiPéter

15. tétel. Adatszerkezetek és algoritmusok vizsga Frissült: január 30.

Rendezések. Összehasonlító rendezések

MBLK12: Relációk és műveletek (levelező) (előadásvázlat) Maróti Miklós, Kátai-Urbán Kamilla

PROGRAMOZÁSI NYELVEK (GYAKORLAT)

VHDL szimuláció. Tervezés. Labor II. Dr. Hidvégi Timót

Dr. Kulcsár Gyula. Virtuális vállalat félév. Projektütemezés. Virtuális vállalat félév 5. gyakorlat Dr.

A döntő feladatai. valós számok!

G Szabályfelismerés feladatcsomag

3. Gyakorlat Ismerkedés a Java nyelvvel

Pál László. Sapientia EMTE, Csíkszereda, 2014/2015

Algoritmusok bonyolultsága

A PROGRAMOZÁS ALAPJAI 3. Készítette: Vénné Meskó Katalin

A hasznos élettartamot befolyásoló egyes tényezők elemzése a Tedej Zrt. holstein-fríz állományánál

Algoritmizálás. Horváth Gyula Szegedi Tudományegyetem Természettudományi és Informatikai Kar

GAZDASÁGMATEMATIKA KÖZÉPHALADÓ SZINTEN

Játékok (domináns stratégia, alkalmazása

Algoritmusok bonyolultsága

Csoportosított adatok megjelenítése sorhalmaz függvények használatával

1. Nyomásmérővel mérjük egy gőzvezeték nyomását. A hőmérő méréstartománya 0,00 250,00 kpa,

értékel függvény: rátermettségi függvény (tness function)

Programozás alapjai C nyelv 5. gyakorlat. Írjunk ki fordítva! Írjunk ki fordítva! (3)

Szkriptnyelvek. 1. UNIX shell

Neumann János Tehetséggondozó Program Gráfalgoritmusok II.

Körkörös listák. fej. utolsó. utolsó. fej

Gépi forgácsoló Gépi forgácsoló

Átírás:

Rendezési algoritmusok belső rendezés külső rendezés belső rendezési algoritmusok buborékrendezés (Bubble sort) kiválasztó rendezés (Selection sort) számláló rendezés (Counting sort) beszúró rendezés (Insertion sort) Shell-rendezés (Shell sort) összefésülő rendezés (Merge sort) kupacrendezés (Heapsort) gyorsrendezés (Quicksort) edényrendezés (Bucket sort) számjegyes rendezés (Radix sort) 1

Buborékrendezés (Bubble sort) Buborékrendezés-1(A) 1. n := hossz[a] 2. repeat 3. ind := 0 4. for i := 1 to n 1 5. do if A i > A i+1 6. then A i A i+1 7. ind := 1 8. until ind = 0 9. return A repeat... until ind = 0 helyett C-ben: do... while ind! = 0 Legrosszabb esetben az összehasonlítások száma: (n 1) + (n 2) +... + 1 = (n 1)n 2 = Θ(n 2 ). 2

Buborékrendezés-2(A) 1. ind := hossz[a] 2. repeat 3. k := ind 1 4. ind := 0 5. for i := 1 to k 6. do if A i > A i+1 7. then A i A i+1 8. ind := i 9. until ind = 0 10. return A Legrosszabb esetben az összehasonlítások száma szintén: (n 1)n (n 1) + (n 2) +... + 1 = = Θ(n 2 ). 2 Átlagérték: n2 4 = Θ(n2 ) Példa 3

Kiválasztó rendezés (Selection sort) Kiválasztjuk a legkisebb elemet, és az első helyre tesszük, majd úgyanígy folytatjuk a maradék sorozattal. Kiválasztó-rendezés(A) 1. n := hossz[a] 2. for i := 1 to n 1 3. do min := i 4. for j := i + 1 to n 5. do if A min > A j 6. then min := j 7. A i A min 10. return A Bonyolultság szintén Θ(n 2 ). Példa 4

Számláló rendezés (Counting sort) Különböző elemek esetében minden elemre megszámoljuk a kisebb elemeket. Ha k 1 kisebb egy elemnél, akkor ő a k-adik helyre kerül. Számláló-rendezés-1(A) 1. n := hossz[a] 2. for i := 1 to n 3. do k := 1 4. for j := 1 to n 5. do if A i > A j 6. then k := k + 1 7. B k := A i 8. return B Bonyolultság szintén Θ(n 2 ). Ha az elemek 0 és n közötti egész számok, akkor meg lehet valósítani Θ(n) időben. 5

Ha az elemek nem mind különbözőek, akkor helyet keresünk az illető elemnek. Számláló-rendezés-2(A) 1. n := hossz[a] 2. for i := 1 to n 3. do B i := 0 4. for i := 1 to n 5. do k := 1 6. for j := 1 to n 7. do if A i > A j 8. then k := k + 1 9. while B k 0 10. do k := k + 1 11. B k := A i 12. return B Bonyolultság szintén Θ(n 2 ). 6

Beszúró rendezés (Insertion sort) Beszúró-rendezés(A) 1. n := hossz[a] 2. for i := 2 to n 3. do k := A i 4. j := i 1 5. while (j > 0) és (A j > k) 6. do A j+1 := A j 7. j := j 1 8. A j+1 := k 9. return A Bonyolultság legrosszabb esetben szintén Θ(n 2 ). Példa 7

Shell-rendezés (Shell sort) h t > h t 1 >... > h 2 > h 1 = 1 növekmények Shell-rendezés(A, h) 1. n := hossz[a] 2. t := hossz[h] 3. for s := t downto 1 4. do h := h s 5. for i := h + 1 to n 6. do k := A i 7. j := i h 7. while (j > 0) és (A j > k) 8. do A j+h := A j 9. i := i h 10. A j+h := k 11. return A Bonyolultság legrosszabb esetben Θ(n 2 ), átlagesetben sokkal jobb. Példa 8

Összefésülő rendezés (Merge sort) Neumann János, 1945 Mergesort(A, b, j) 1. if b < j b bal index, j jobb index b + j 2. then k := 2 3. Mergesort(A, b, k) 4. Mergesort(A, k + 1, j) 5. Összefésül(A, b, k, j) 7. return A 9

Összefésül(A, b, k, j) 1. n 1 := k b + 1 2. n 2 := j k 3. for p := 1 to n 1 4. do L p := A b+p 1 5. for r := 1 to n 2 6. do R r := A k+r 7. L n1 +1 := strázsa 8. R n2 +1 := strázsa 9. p := 1 10. r := 1 11. for i := b to j 12. do if L p R r 13. then A i := L p 14. p := p + 1 15. else A i := R r 16. r := r + 1 Az eljárás hívása: Mergesort(A, 1, n), ha A = (A 1, A 2,..., A n ). Bonyolultság: Θ(n log n). Példa 10

Kupacrendezés (Heapsort) Kupacot használunk és a Kupacot_épít valamint a Kupacol eljárást. A bemeneti A 1, A 2,..., A n sorozatra meghívjuk a Kupacot_épít eljárást, amely kupactulajdonságúvá változtatja a kupacot. Kupacol(A, i) 1. b := Bal(i) 2. j := Jobb(i) 3. if (b kupacméret[a]) és (A b > A i ) 4. then max := b 5. else max := i 6. if (j kupacméret[a]) és (A j > A max ) 7. then max := j 8. if max i 9. then A i A max 10. Kupacol(A, max) Kupacot-épít(A) 1. kupacméret[a] := hossz[a] 2. for i := hossz[a] downto 1 2 3. do Kupacol(A, i) 11

A kupacrenzedés a gyökérelemet (amely a legnagyobb) az utolsó helyre teszi (felcseréléssel), kiveszi azt a kupacból, a többi elemre helyreállítja a kupactulajdonságot, és ugyanúgy folytatja. Kupacrendezés(A) 0. Kupacot-épít(A) 1. kupacméret[a] := hossz[a] 2. for i := n downto 2 3. do A 1 A i 4. kupacméret[a] := kupacméret[a] 1 5. Kupacol(A,1) 6. return A Bonyolultság: Θ(n log n). Példa 12

Gyorsrendezés (Quicksort) Gyorsrendezés(A, b, j) 1. if b < j 2. then k := Feloszt(A, b, j) 3. Gyorsrendezés(A, b, k 1) 4. Gyorsrendezés(A, k + 1, j) 5. else return A Feloszt(A, b, j) 1. x := A j 2. i := b 1 3. for k := b to j 1 4. do if A k x 5. then i := i + 1 6. A i A k 7. A i+1 A j 8. return i + 1 Az eljárás hívása: Gyorsrendezés(A, 1, n) 13

14

C. A. Hoare felosztó algoritmusa: Feloszt2(A, b, j) 1. x := A b 2. i := b 1 3. j := j + 1 4. while igaz 5. repeat j := j 1 6. until A j x 7. repeat i := i + 1 8. until A i x 9. if i < j 10. then A i A j 11. else return j 15

Nem rekurzív változat Az A b,..., A j résztömbök indexeit egy veremben őrizzük [b, j] formában, kezdetben a verem üres. push([b, j]) beteszük a verembe, pop([b, j]) kiveszzük a veremből Nemrekurzív-Gyorsrendezés(A) 1. n := hossz[a] 2. push([1, n]) 3. while a verem nem üres 4. do pop([b, j]) 5. while b < j 6. do k := Feloszt(A, b, j) 7. push([k + 1, j]) 8. j := k 1 9. return A Példa Bonyolultság legrosszabb esetben: Θ(n 2 ), átlagesetben Θ(n log n). 16

Edényrendezés (Bucket sort) Az elemeket egyenletes elosztásúaknak tekintjük. Lineáris bonyolultságú. Példa 17

Számjegyes rendezés (Radix sort) A legkisebb helyértékű számjeggyel kezdjük a csoportosítást, majd haladunk balra. Lineáris bonyolultságú. Példa 40325 50231 37005 38123 42025 50231 } {{ } 1 37005 } {{ } 0 38123 } {{ } 3 37005 42025 } {{ } 0 50231 40325 } {{ } 0 37005 38123 } {{ } 3 40325 } 37005 {{ 42025} 5 38123 } 40325 {{ 42025} 2 38123 } {{ } 1 42025 } {{ } 2 50231 } {{ } 2 37005 } {{ } 7 42025 40325 } {{ } 4 50231 } {{ } 3 40325 } {{ } 3 38123 } {{ } 8 50231 } {{ } 5 18

algoritmus átlag legrosszabb buborékrendezés (Bubble sort) Θ(n 2 ) Θ(n 2 ) kiválasztó rendezés (Selection sort) Θ(n 2 ) Θ(n 2 ) számláló rendezés (Counting sort) Θ(n 2 ) Θ(n 2 ) beszúró rendezés (Insertion sort) Θ(n 2 ) Θ(n 2 ) Shell-rendezés (Shell sort) Θ(n 2 ) gyorsrendezés (Quicksort) Θ(n log n) Θ(n 2 ) összefésülő rendezés (Merge sort) Θ(n log n) Θ(n log n) kupacrendezés (Heapsort) Θ(n log n) Θ(n log n) 19

Topologikus rendezés mélységi bejárás alkalmazása 20

21

Külső rendezés (Knuth, 3. kötet) két lépésből áll: futamok előállítása (angolul run) futamok összefésülése két módszer: 1) többfázisú öszefésülés 2) kaszkád összefésülés Többfázisú öszefésülés 3 szalagot használunk: T 1, T 2, T 3 1. Osszuk szét a kezdeti futamokat felváltva T 1 -en és T 2 -n. 2. A T 1 és T 2 szalagokról fésüljük össze a futamokat T 3 -ra. Ha T 3 egyetlen futamot tartalmaz, álljunk meg. 3. Másoljuk a T 3 -on levő futamokat felváltva T 1 -re és T 2 -re, majd folytassuk a 2. lépéssel 1. fázis 1 8 1 5 2. fázis 1 3 2 5 3. fázis 3 3 2 2 4. fázis 5 2 3 1 5. fázis 5 1 8 1 6. fázis 13 1 k n jelentése: n darab k hosszúságú futam (k hosszúság: az eredeti futam k-szorosa) 22

Kaszkád összefésülés 23

http://www.youtube.com/watch?v=ns4tptc8whw http://www.youtube.com/watch?v=roalu379l3u http://www.youtube.com/watch?v=cmpa7ze8mx0 http://www.youtube.com/watch?v=lyzqpjut5b4 http://www.youtube.com/watch?v=xaqr3g_nvoo 24