Algoritmusok és adatszerkezetek I. 2. előadásalg1.elte.hu/downloads/eloadas/Eloadas2.pdf · 2020. 6. 10. · 2/47 Sorozattípusok Verem (szekvenciális ábrázolás) Verem (láncolt

Algoritmusok és adatszerkezetek I.

2. előadás

2/53

Sorozattípusok

Verem (szekvenciális ábrázolás)

Verem (láncolt ábrázolás)

Verem alkalmazások

Sor (szekvenciális ábrázolás)

Sor (láncolt ábrázolás)

Sor alkalmazások

Kétvégű sor

Kétvégű sor alkalmazás

2021. 02. 17. 9:27Szlávi Péter, Zsakó László: Adatszerkezetek I.

http://ikportal.inf.elte.hu:8080/ELTEInformatikaiKar/elte_ik_2.html

3/53

Verem

Verem= speciális sorozattípus

Műveletei: Üres, üres?, Verembe, Veremből, tető

Üres: Verem

üres?(Verem): Logikai

tető(Verem): Elem {NemDef}

Verembe(Verem,Elem): Verem {NemDef}

Veremből(Verem,Elem): (Verem Elem) {NemDef}



4/53

Verem

A műveletek specifikációja

Üres(V): ef: ─, uf: V=()

üres?(V): ef: ─, uf: üres?=V=()

Verembe(V,e): ef: V=W, uf: V=(W,e)

Veremből(V,e): ef: V=(W,f), uf: V=W és e=f

Megjegyzés: ef nem üres?(V)

tető(V): ef: V=(W,f), uf: tető=f

Megjegyzés: ef nem üres?(V)



5/53

Verem

A műveletek tulajdonságai

Üres veremre a verembe rakás és az üresség vizsgálat

kivételével minden művelet értelmetlen.

A veremből kivétel a verembe utoljára tett elemet veszi ki,

azaz a verem alkalmas egy sorozat megfordítására.

A tetőn mindig a verembe utoljára betett (legfelül levő) elem

látszik.



6/53

Verem

Megvalósítás folytonos, szekvenciális ábrázolással

Verem(Típus TElem):

Konstans MaxMélység: Egész(???)

Típus VeremElem=TElem

Változó t: Tömb(1..MaxMélység: VeremElem)

teteje: 0..MaxMélység

Tárolni kell a verem elemszámát (teteje), valamint egy tömbben

a verem elemeit (1-től indexelve).

Probléma: MaxMélység=????

Ha nem ismerjük → dinamikus tömb!2021. 02. 17. 9:27Szlávi Péter, Zsakó László: Adatszerkezetek I.


7/53

Verem

Eljárás Üres(V):

V.teteje:=0

Eljárás vége.

Függvény üres?(V):

üres?:=V.teteje=0

Függvény vége.

Függvény tető(V):

tető:=V.t(V.teteje)

Függvény vége.



8/53

Verem

Eljárás Verembe(V,e):

V.teteje:=V.teteje+1

V.t(V.teteje):=e

Eljárás vége.

Eljárás Veremből(V,e):

e:=V.t(V.teteje)

V.teteje:=V.teteje-1

Eljárás vége.

Meggondolandó: hibakezelés hol és mikor kell?



9/53

Verem

Megvalósítás dinamikus láncolással


Típus VeremElem=Rekord(érték: TElem

alatta: Mutató(VeremElem)

Változó teteje: Mutató(VeremElem)

Magyarázat: a láncolásnak nincs szerepe a hatékonyság

szempontjából (nincs beszúrás vagy törlés középen), csak a

memória lefoglalási lehetőséget használjuk ki.

A verem eléréséhez ismerni kell a

mindenkori legfelső elem címét!2021. 02. 17. 9:27Szlávi Péter, Zsakó László: Adatszerkezetek I.


10/53

Verem

Eljárás Üres(V):

V.teteje:=Sehova

Eljárás vége.


üres?:=V.teteje=Sehova

Függvény vége.


tető:=tartalom(V.teteje).érték

Függvény vége.

Emlékeztető:Eljárás Üres(V):

V.teteje:=0

Eljárás vége.


üres?:=V.teteje=0

Függvény vége.


tető:=V.t(V.teteje).érték

Függvény vége.



11/53

Verem


Lefoglal(w,(e,V.teteje))

V.teteje:=w

Eljárás vége.


e:=tartalom(V.teteje).érték; w:=V.teteje

V.teteje:=tartalom(V.teteje).alatta

Felszabadít(w)

Eljárás vége.A lefoglalás másképpen:

Lefoglal(w)

tartalom(w).érték:=e

tartalom(w).alatta:=V.teteje


V.teteje:=V.teteje+1

V.t(V.teteje):=e

Eljárás vége.


e:=V.t(V.teteje)

V.teteje:=V.teteje-1

Eljárás vége.



12/53

Verem

Megvalósítás dinamikus láncolással (hibakezeléssel)


Típus VeremElem=Rekord(érték: TElem

alatta: Mutató(VeremElem))

Változó teteje: Mutató(VeremElem)

hiba: Logikai



13/53

Verem

Eljárás Üres(V):

V.teteje:=Sehova; V.hiba:=hamis

Eljárás vége.



Ha w=sehova akkor V.hiba:=igaz

különben V.teteje:=w

Eljárás vége.



14/53

Verem


Ha v.teteje=sehova akkor V.hiba:=igaz

különben tető:=tartalom(V.teteje).érték

Függvény vége.


Ha v.teteje=sehova akkor V.hiba:=igaz

különben e:=tartalom(V.teteje).érték

w:=V.teteje

V.teteje:=tartalom(V.teteje).alatta

Felszabadít(w)

Eljárás vége.



15/53

Verem

Speciális verem műveletek a FORTH nyelvből

swap(V): a két felső elem cseréje

ef: V=(W,e,f), uf: V=(W,f,e)

dup(V): a felső elem duplikálása

ef: V=(W,e), uf: V=(W,e,e)

over(V): a felső alatti elem duplikálása a verem tetején

ef: V=(W,e,f), uf: V=(W,e,f,e)

rot(V): a felső három elem ciklikus léptetése

ef: V=(W,e,f,g), uf: V=(W,f,g,e)



16/53

Verem

Eljárás swap(V):

e:=tartalom(V.teteje).érték

w:=tartalom(V.teteje).alatta

tartalom(V.teteje).érték:=tartalom(w).érték

tartalom(w).érték:=e

Eljárás vége.



17/53

Verem

Eljárás dup(V):

e:=tartalom(V.teteje).érték


V.teteje:=w

Eljárás vége.



18/53

Verem

Eljárás over(V):


e:=tartalom(w).érték


V.teteje:=w

Eljárás vége.



19/53

Verem

Eljárás rot(V):


x:=tartalom(w).alatta

e:=tartalom(x).érték

tartalom(x).érték:=tartalom(w).érték

tartalom(w).érték:=tartalom(V.teteje).érték

tartalom(V.teteje).érték:=e

Eljárás vége.



20/53

Verem alkalmazás

Egy kifejezés (,) és [,] zárójelpárokat tartalmaz.

Ellenőrizzük a helyességét!Hibás esetek:

x([y)] – hibás párosítás

x(a - nyitó zárójelnek nincs csukó párja

x)a( - csukó zárójelnek nincs nyitó párja



21/53

Verem alkalmazás

Függvény helyes(K):

i:=1; h:=igaz; Üres(V)

Ciklus amíg i≤hossz(K) és h

Ha K(i)=’(’ vagy K(i)=’[’ akkor Verembe(V,K(i))

különben ha K(i)=’)’ vagy K(i)=’]’ akkor

Veremből(V,s)

h:= K(i)=’)’ és s=’(’ vagy

K(i)=’]’ és s=’[’

i:=i+1

Ciklus vége

helyes:=h és nem V.hiba és üres?(V)

Függvény vége.



22/53

Verem alkalmazás

Egy számsorozat minden eleméhez add meg az őt megelőzők

közül a hozzá legközelebb álló, nála kisebb elem indexét! Ha

nincs ilyen, akkor -1-et!

2021. 02. 17. 9:27Zsakó László: Adatszerkezetek I.


23/53

Verem alkalmazás

Legközelebbiek(X,Y):

Y(1):=-1

Ciklus i=2-től N-ig

j:=i-1

Ciklus amíg j>0 és X(j)≥X(i)

j:=j-1

Ciklus vége

Ha j=0 akkor Y(i):=-1 különben Y(i):=j

Ciklus vége

Eljárás vége.

A két ciklus miatt a futási idő az elemszám négyzetével arányos.



24/53

Verem alkalmazás

Egy számsorozat minden eleméhez add meg az őt megelőzők

közül a hozzá legközelebb álló, nála kisebb elem indexét! Ha

nincs ilyen, akkor -1-et!

Megoldási ötlet: tároljuk veremben azokat az elemeket, amelyek

még bekerülhetnek az eredménybe!

Invariáns tulajdonság: a veremben az elemek szigorúan monoton

növekvően vannak, a tetején az i-edik elemmel.

Példa: 3, 6, 4, 9, 8, 5

Verem állapotok: (), (3), (3,6), (3,4), (3,4,9), (3,4,8), (3,4,5)



25/53

Verem alkalmazás

Legközelebbiek(X,Y):

Y(1):=-1; Üres(V); Verembe(V,1)


Ciklus amíg nem üres?(V) és X(tető(V))≥X(i)

Veremből(V,t)

Ciklus vége

Ha üres?(V) akkor Y(i):=-1

különben Y(i):=tető(V)

Verembe(V,i)

Ciklus vége

Eljárás vége.


Példa: 3, 6, 4, 9, 8, 5

Verem állapotok:

(), (3), (3,6), (3,4), (3,4,9), (3,4,8), (3,4,5)


26/53

Sor

Sor= speciális sorozattípus

Műveletei: Üres, üres?, Sorba, Sorból, első

Üres: Sor

üres?(Sor): Logikai

első(Sor): Elem {NemDef}

Sorba(Sor,Elem): Sor {NemDef}

Sorból(Sor,Elem): (Sor Elem) {NemDef}



27/53

Sor


Üres(S): ef: ─, uf: S=()

üres?(S): ef: ─, uf: üres?=S=()

Sorba(S,e): ef: S=W, uf: S=(W,e)

Sorból(S,e): ef: S=(f,W), uf: S=W és e=f

Megjegyzés: ef nem üres?(S)

első(S): ef: S=(f,W), uf: első=f

Megjegyzés: ef nem üres?(S)



28/53

Sor

A műveletek tulajdonságai

Üres sorra a sorba rakás és az üresség vizsgálat kivételével

minden művelet értelmetlen.

A sorból kivétel a sorba legrégebben tett elemet veszi ki, azaz

a sor alkalmas egy sorozat feldolgozására, ha a keletkezés és a

feldolgozás üteme eltér egymástól.

A sor elején mindig a sorba legrégebben betett (legelöl levő)

elem látszik.



29/53

Sor

Megvalósítás folytonos, szekvenciális ábrázolással

Sor(Típus TElem):

Konstans MaxHossz: Egész(???)

Típus SorElem=TElem

Változó t: Tömb(1..MaxHossz: SorElem)első,utolsó,db: 0..MaxHossz

A tömböt ciklikusan kezeljük: ha a végére értünk és az elején már

szabadult fel hely, ott folytatjuk a kitöltést. A sorban az első és

az utolsó tömbindexű hely között db darab elem van.

Probléma: MaxHossz=????



30/53

Sor

Eljárás Üres(S):

S.első:=1; S.utolsó:=0; S.db:=0

Eljárás vége.

Függvény üres?(S):

Üres?:=S.db=0

Függvény vége.

Függvény első(S):

első:=S.t(S.első)

Függvény vége.



31/53

Sor

Eljárás Sorba(S,e):

Ha S.utolsó=Maxhossz akkor S.utolsó:=1

különben S.utolsó:=S.utolsó+1

S.db:=S.db+1; S.t(S.utolsó):=e

Eljárás vége.

Eljárás Sorból(S,e):

e:=S.t(S.első); S.db:=S.db-1

Ha S.első=Maxhossz akkor S.első:=1

különben S.első:=S.első+1

Eljárás vége.


S.utolsó S.első


32/53

Sor

Megvalósítás dinamikus láncolással

Sor(Típus TElem):

Típus SorElem=Rekord(érték: TElem

köv: Mutató(SorElem))

Változó eleje,vége: Mutató(SorElem)

Megjegyzés: Itt sem használunk középre beszúrást, középről

törlést, azaz a láncolást csak a tömbméret korlát elhagyása miatt

használjuk.

A megoldáshoz az első és az utolsó elem

címét kell tudnunk.2021. 02. 17. 9:27Szlávi Péter, Zsakó László: Adatszerkezetek I.


33/53

Sor

Eljárás Üres(S):

S.eleje:=sehova; S.vége:=sehova

Eljárás vége.


Üres?:=S.eleje=sehova

Függvény vége.


első:=tartalom(S.eleje).érték

Függvény vége.

Emlékeztető:Eljárás Üres(S):

S.első:=1; S.utolsó:=0

S.db:=0

Eljárás vége.


Üres?:=S.db=0

Függvény vége.


első:=S.t(S.első)

Függvény vége.



34/53

Sor


Lefoglal(újvége,(e,sehova))

Ha S.vége=sehova akkor S.eleje:=újvége

különben tartalom(S.vége).köv:=újvége

S.vége:=újvége

Eljárás vége.



35/53

Sor


e:=tartalom(S.eleje).érték

újeleje:=tartalom(S.eleje).köv

Felszabadít(S.eleje)

S.eleje:=újeleje

Ha S.eleje=sehova akkor S.vége:=sehova

Eljárás vége.



36/53

Sor

Megvalósítás dinamikus láncolással (hibakezeléssel)

Sor(Típus TElem):

Típus SorElem=Rekord(érték: TElem

köv: Mutató(SorElem))

Változó eleje,vége: Mutató(SorElem)

hiba: Logikai



37/53

Sor

Eljárás Üres(S):

S.eleje:=sehova; S.vége:=sehova; S.hiba:=hamis

Eljárás vége.


Ha S.eleje=sehova akkor S.hiba:=igaz

különben első:=tartalom(S.eleje).érték

Függvény vége.



38/53

Sor


Lefoglal(új,(e,sehova))

Ha S.vége=sehova akkor S.eleje:=új

különben tartalom(S.vége).köv:=új

S.vége:=új

Eljárás vége.



39/53

Sor


Ha S.eleje=sehova akkor S.hiba:=igaz

különben e:=tartalom(S.eleje).érték

újeleje:=tartalom(S.eleje).köv

Felszabadít(S.eleje)

S.eleje:=újeleje

Ha S.eleje=sehova akkor S.vége:=sehova

Eljárás vége.



40/53

Sor alkalmazás

Példa:Egy vasútvonal két állomásán egy nap feljegyeztük, az összes egyik irányba

áthaladó vonat indulási, illetve érkezési idejét (idő szerinti sorrendben).

Adjuk meg az áthaladt vonatok menetidőit a két állomás között! (Nincs

előzés.)

Ötlet: A korábban érkező adatot egy sorban várakoztatjuk addig, amíg a

párja meg nem érkezik.



41/53

Sor alkalmazás

Forgalom:

Üres(S)

Ciklus amíg jön vonat

Olvas(adat)

Ha adat.állomás=1

akkor Sorba(S,adat.idő)

különben Sorból(S,előző)

Ír(adat.idő-előző)

Ciklus vége

Eljárás vége.



42/53

Sor alkalmazás

Példa:Egy egyirányú utcában két jelzőlámpánál figyelik az áthaladó autókat:

mikor haladt át a lámpánál. Az adatok megfigyelési idő szerinti sorrendben

érkeznek. N db autót figyeltek meg. Csoportosítsuk az adatokat, hogy az

első lámpánál történt megfigyelések – időbeli sorrendjüket megtartva –

előzzék meg a második lámpánál megfigyelt adatokat! (Az utcában előzés

nincs.)

Ötlet: Az 1-es lámpa adatai azonnal írhatók az eredménybe, a 2-es lámpa

adatait egy átmeneti sorban tároljuk, s a végén írjuk az eredménybe. A sor

– ha a mérete indokolja – persze lehet háttértáron is.



43/53

Sor alkalmazás

Ötlet: Az 1-es lámpa adatai azonnal írhatók az eredménybe, a 2-

es lámpa adatait egy átmeneti sorban tároljuk, s a végén írjuk az

eredménybe. A sor – ha a mérete indokolja – persze lehet

háttértáron is.

A bemenet és a kimenet is forgalom típusú adatok fájlja, és a

sorban is ilyeneket tárolunk:

Forgalom=Rekord(lámpa: {1,2}, idő: Egész)

Változó S: Sor(Forgalom)



44/53

Sor alkalmazás

Forgalom:

Üres(S)

Ciklus amíg jön autó

Olvas(adat)

Ha adat.lámpa=1 akkor Ír(adat)

különben Sorba(S,adat)

Ciklus vége

Ciklus amíg nem üres?(S)

Sorból(S,adat); Ír(adat)

Ciklus vége

Eljárás vége.



45/53

Sor alkalmazás

Példa:Egy vasútállomáson a fő vágányról kitérő vágányt építettek, mindegyiken

csak jobbról balra lehet haladni. A kitérőn akárhány kocsit elhelyezhetünk,

a fő vágányon azonban nem állhat meg kocsi. Egy szerelvény érkezik

jobbról, sorszámozott, összekevert kocsikkal. A kocsikat 1 és K közötti

különböző sorszámokkal azonosítjuk.

Készíts programot, amely megadja, hogy maximum hány kocsit tudunk

sorba rendezni a kitérő segítségével és elküldeni balra úgy, hogy a kitérőn

végül nem marad kocsi!


Példa: 4, 5, 2, 6, 3, 1

Sor: (4), (4,5), 2 át, (4,5,6), 3 át, sorból mind át


46/53

Sor alkalmazás

Vasútállomás:ut:=0; jó:=igaz; i:=1; Üres(S)Ciklus amíg i≤k és v[i]≥utHa üres?(S) akkor Sorba(S,v[i])különben ha v[i]>utolsó(S) akkor Sorba(S,v[i])különben Ciklus amíg v[i]>első(S)

Sorból(S,x)Ciklus végeut:=v[i]

Elágazások végei:=i+1Ciklus végeered:=i-1

Eljárás vége.


Ötlet: Sorba tesszük a kitérőre

kerülő kocsikat, tároljuk a balra

kilépő utolsó kocsi azonosítóját.

Új művelet a sor utolsójának

vizsgálata.

Példa: 4, 5, 2, 6, 3, 1

Sor: (4), (4,5), 2 át, (4,5,6), 3 át, sorból mind át


47/53

Kétvégű sor

Kétvégű sor= speciális sorozattípus

Műveletei: Üres, üres?, Sorelejére, Sorvégére, első,

Sorelejéről, Sorvégéről

Üres: Sor

Sorelejére(Sor,Elem): Sor {NemDef}

Sorvégére(Sor,Elem): Sor {NemDef}

Sorelejéről(Sor,Elem): (Sor Elem) {NemDef}

Sorvégéről(Sor,Elem): (Sor Elem) {NemDef}

üres?(Sor): Logikai

első(Sor): Elem {NemDef}

utolsó(Sor): Elem {NemDef}2021. 02. 17. 9:27Szlávi Péter, Zsakó László: Adatszerkezetek I.


48/53

Kétvégű sor


Üres(S): ef: ─, uf: S=()

üres?(S): ef: ─, uf: üres?=S=()

Sorelejére(S,e): ef: S=W, uf: S=(e,W)

Sorvégére(S,e): ef: S=W, uf: S=(W,e)

Sorelejéről(S,e): ef: S=(f,W), uf: S=W és e=f

Sorvégéről(S,e): ef: S=(W,f), uf: S=W és e=f

első(S): ef: S=(f,W), uf: első=f

utolsó(S): ef: S=(W,f), uf: utolsó=f



49/53


Egy számsorozat minden eleméhez add meg a vele végződő M hosszú

részsorozat minimumát! Az első M elemnél minden i-re a vele végződő i

hosszú részsorozat minimumát kell megadni!

Megoldási ötlet: sok minimumkiválasztás

Példa: 5, 3, 6, 4, 7, 9, 2, 6, 4 A 3 hosszú részek minimumát keressük

Sor állapotok: (5), (3), (3,6), (3,4), (4,7), (4,7,9), (2), (2,6), (2,4)



50/53


Minimumok(X,Y):

Y(1):=1


min:=i

Ciklus j=max(1,i-M+1)-től i-1-ig

Ha X(j)<X(min) akkor min:=j

Ciklus vége

Y(i):=min

Ciklus vége

Eljárás vége.


Példa: 5, 3, 6, 4, 7, 9, 2, 6, 4

A 3 hosszú részek minimumát keressük


51/53


Egy számsorozat minden eleméhez add meg a vele végződő M hosszú

részsorozat minimumát! Az első M elemnél minden i-re a vele végződő i

hosszú részsorozat minimumát kell megadni!

Megoldási ötlet: tároljuk kétvégű sorban azokat az elemeket, amelyek még

bekerülhetnek az eredménybe!

Invariáns tulajdonság: a sorban az elemek szigorúan monoton növekvően

vannak. Az elejéről kikerülnek azok, amelyek M-nél régebbiek. A végéről

kerülnek ki azok, akik a monotonitási feltételt nem teljesítik.

Példa: 5, 3, 6, 4, 7, 9, 2, 6, 4 A 3 hosszú részek minimumát keressük

Sor állapotok: (5), (3), (3,6), (3,4), (4,7), (4,7,9), (2), (2,6), (2,4)



52/53


Minimumok(X,Y):

Y(1):=1; Üres(S); Sorvégére(S,1)


Ha i-első(S)=M akkor Sorelejéről(S,t)

Ciklus amíg nem üres?(S) és X(i)≤X(utolsó(S))

Sorvégéről(S,t)

Ciklus vége

Sorvégére(S,i); Y(i):=első(S)

Ciklus vége

Eljárás vége.


Példa: 5, 3, 6, 4, 7, 9, 2, 6, 4

A 3 hosszú részek minimumát keressük

Sor állapotok:

(5), (3), (3,6), (3,4), (4,7), (4,7,9), (2), (2,6), (2,4)


53/53

Sorozattípusok

Verem (szekvenciális ábrázolás)

Verem (láncolt ábrázolás)

Verem alkalmazások

Sor (szekvenciális ábrázolás)

Sor (láncolt ábrázolás)

Sor alkalmazások

Kétvégű sor




Documents

Algoritmusok és adatszerkezetek I. 2. előadásalg1.elte.hu/downloads/eloadas/Eloadas2.pdf · 2020. 6. 10. · 2/47 Sorozattípusok Verem (szekvenciális ábrázolás) Verem (láncolt