1 / 16

Nevezetes algoritmusok

Nevezetes algoritmusok. Beszúrás

abril
Télécharger la présentation

Nevezetes algoritmusok

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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;

More Related