nevezetes algoritmusok n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Nevezetes algoritmusok PowerPoint Presentation
Download Presentation
Nevezetes algoritmusok

Loading in 2 Seconds...

play fullscreen
1 / 16

Nevezetes algoritmusok - PowerPoint PPT Presentation


  • 78 Views
  • Uploaded on

Nevezetes algoritmusok. Beszúrás

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Nevezetes algoritmusok' - abril


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
nevezetes algoritmusok
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.

slide2
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.

slide3
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;

}

};

slide4
Ö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.

slide5
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;

slide6
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.

slide7
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ó.

slide8
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;

slide9
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;

}

};

slide10
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.

slide11
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;

}

}

};

slide12
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.

slide13
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;

slide14
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;

slide15
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.

slide16
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;