Nevezetes algoritmusok

1. Nevezetes algoritmusok Beszúrás Van egy n-1 elemű rendezett tömbünk. Be akarunk szúrni egy n-edik elemet. Egyik lehetőség, hogy végigszaladunk a tömbön, és betesszük a beszúrandó elemet az elé az elem elé, ami már nem előzi meg. Általában n/2, de a legrosszabb esetben n összehasonlításra van szükség. Másik lehetőség, hogy a kérdéses elemet a középső elemmel hasonlítjuk össze. Ha pl. az új elem megelőzi a középsőt, akkor a tömb első felében keressük a helyét a továbbiakban. Stb. A lépésszám log2n, vagy az erre következő első egész szám, azaz [log2n], ha n nem 2 hatványa.

2. Beszúrásos rendezés A rendezés során sorrendbeli hibát keresünk. A kialakult sorrendtől eltérő helyet megjegyezzük, az ott lévő elemet elmentjük, majd addig keresünk attól visszafelé, amíg nála nagyobbat nem találunk, az elé kell majd beszúrnunk. Amikor a helyet megtaláltuk, akkor a közbeeső elemeket feljebb tolva, az imént kiemelt elemet a felszabaduló helyre illesztjük.

3. sort(r, lo, up) arraytosort r; int lo, up; {int i, j; arrayentry tmpr; for (i=up-1; i>=lo; i--) { tmpr= r[i]; for (j=i+1; j<=up&& (tmpr.k> r[j].k; j++) r[j-1]=r[j]; r[j-1]=tmpr; } };

4. Összefésülés Van két n hosszúságú listánk: (a1, ... , an) és (b1, ... ,bn). Ezeket kell egyesíteni. Hasonlítsuk össze az b1 elemet rendre az a1, a2, ... elemekkel. Beszúrjuk b1-et az elé az ai elé, amelyet közvetlenül megelőz. Ettől az ai-től folytatjuk tovább b2-re. Stb. Legfeljebb 2n-1 összehasonlításra van szükség.

5. function merge(a, b: list):list; var first, last, tmp:list; begin first:=nil; while b<>nildo if a=nilthen begin a:=b; b:=nilend elsebegin if b.k > a.k then begin tmp:=a; a:=a.next end else begin tmp:=b; b:=b.next end; temp.next:=nil; tailins(tmp, first, last) end; tailins(a, first, last); merge:=first end; end;

6. Minimum elven alapuló rendezés Egy adott intervallumban (kezdetben a teljes lista) megkeressük a legkisebb elemet és ezt tesszük az első helyre. A következő lépésben a második elemtől kezdve vizsgáljuk és ismét a legkisebb elemet visszük előre. Stb. A mindenkori legkisebb elem keresése lineáris kereséssel történik.

7. Buborékrendezés A lista elejéről indulva rendre összehasonlítjuk a szomszédos elemeket, s ha a kisebb van hátrább, megcseréljük őket. Az eljárást mindaddig folytatjuk, amíg a rendezettség ki nem alakul. Módosított buborékrendezés Az alapelv hasonló, de a pásztázás többirányú és váltakozó.

8. procedure sort(var r:arraytosort; lo, up:integer); var i,j:integer; tmpr:arraytype; begin while up>lo dobegin j:=lo; for i:=lo to up-1 do if r[i].k>r[i+1].k thenbegin tmpr:=r[i]; r[i]:=r[i+1]; r[i+1]:=tmpr; j:=i end; up:=j end end;

9. sort(r, lo, up) arraytosort r; int lo, up; {int i, j; while (up>lo) { j=lo; for (i=lo; i<up; i++) if r[i].k>r[i+1].k) { exchange(r, i, i+1); j=i;} up=j; for (i=up; i>lo; i--) if r[i].k<r[i-1].k) { exchange(r, i, i-1); j=i;} lo=j; } };

10. Shell rendezés A beszúrásos módszer lépésenként finomított változata. A listának csak minden d-edik elemét vizsgáljuk, azaz d lépésközzel végezzük el a beszúrásos rendezést. Ezután csökkentjük a lépésközt, és úgy végezzük el a rendezést. A folyamat addig tart, amíg a lépésköz 1 nem lesz.

11. sort(r, lo, up) arraytosort r; int lo, up; {int d, i, j; arrayentry tmpr; for (d=up-lo+1; d>1; ) { if (d<5) d=1; else d=(5*d-1)/11; for (i=up-d; i>=lo; i--) { tmpr= r[i]; for (j=i+d; j<=up&& (tmpr.k>r[j].k; j+=d) r[j-d]=r[j]; r[j-d]=tmpr; } } };

12. Gyorsrendezés (quick-sort) Kiválasztjuk a lista tetszőleges elemét. Ezt nevezzük alapelemnek, mert ehhez viszonyítjuk a többit. Először balról lépegetünk addig, amíg ennél az alapelemnél csupa kisebbet találunk. Ha egy nagyobb vagy egyenlő elemhez érünk, jobbról vizsgálódunk, és keressük az alapelemnél nem nagyobb elemet. Ha megtaláltuk, kicseréljük a kettőt és a következő eggyel nagyobb, illetve kisebb elemtől kezdjük a keresést és a cserét.

13. procedure sort(var r:arraytosort; lo, up:integer); var i, j:integer; tmpr:arraytype; begin while up>lo dobegin i:=lo; j:=up; tmpr:=r[lo]; while i<j do begin while r[j].k>tmpr.k do j:=j-1; r[i]:=r[j]; while (i<j) and (r[i].k<=tmpr.k) do i:=i+1; r[j]:=r[i]; end; r[i]:=tmpr; sort(r, lo, i-1); lo:=i+1 end end;

14. Lineáris keresés A legalapvetőbb keresési algoritmus. Adott elemet keresünk egy listában úgy, hogy minden elemet végignézünk. function search(n:integer;key:keyt;var r dataarray):integer; var i:integer; begin i:=1; while (i<n) and (key<>r[i].k) do i:=i+1; if r[i].k=key then search:=i else search:=-1; end;

15. Bináris keresés Rendezett listában keresünk. A keresett elemet a táblázat középső eleméhez hasonlítjuk. Ha egyezik, akkor megtaláltuk, ha nem, akkor a listának abban a felében folytatjuk a keresést, amelyet a keresett érték kijelöl: ha a keresett érték kisebb, mint a középső elem, akkor a lista első felében, egyébként a másodikban. Az eljárást ilyen módon folytatjuk tovább.

16. function search(n:integer;key:keyt;var r dataarray): integer; var high, j, low: integer; begin low:=0; high:=n; while high-low>1 do begin j:=(high+low) div 2; if key <= r[j].k then high:=j else low:=j end; if r[high].k=key then search:=high else search:=-1; end;