Adatfeldolgozás 3. Szlávi Péter

Az előadások a következő témára: "Adatfeldolgozás 3. Szlávi Péter"— Előadás másolata:

1 Adatfeldolgozás 3. Szlávi Péter
ELTE Informatika Szakmódszertani Csoport Copyright, 1999 © Szlávi Péter

2 Tartalom 1. Adatfeldolgozás problémája, alapfogalmak
1.1 Adatfeldolgozás típusfeladatai 1.2 Elemenkénti feldolgozhatóság 1.3 A Z=F(X) tétel 1.4 Típusfinomítás, struktúramegfeleltetés 2. Struktúramegfeleltetés konfliktusai 2.1 Tagolási konfliktus 2.2 Összefonódási konfliktus 2.3 Rendezetlenségi konfliktus 3. Időszerűsítés 3.1 Megoldása a Z=F(x) tétel alapján 3.2 Megoldása összefuttatással Adatfedolgozás

3 Tartalom 4. Külső rendezések 4.1 Négy munkafájlos rendezés
4.2 Három munkafájlos rendezés 4.3 Prioritási soros rendezés Adatfedolgozás

4 3. Időszerűsítés A feladat: Időszerűsítés: Régi x Módosító  Új Régi=TBeElem1*, Módosító=TBeElem2 * Új=TKiElem* Időszerűsítési funkciók: adott elem törlése adott elem javítása adott elem beszúrása Adott mező: „kulcs” (-mező) TBeElem1  TBeElem2 TBeElem1  TBeElem2   TBeElem=TKiElem : közös mező Adatfedolgozás

5 Időszerűsítés (folytatás)
A ’Z=F(X)’ tétel alkalmazható? A „keresztbe kasul” hivatkozás miatt f: XxYZ : Adatfedolgozás

6 Időszerűsítés (folytatás)
Konfliktus: Összefonódási (elsősorban) a bemeneti olda- lon, X és Y elemei között, továbbá az Y és Z elemei között. Feloldása: 1. Szétválogatás(ok) – X-Y „párba illeszkedő” (azonos kulcsú v. üres) elemei. 2. Ef: kulcs-szerinti rendezettség párosítás (kulcs-szerint v. üres). Adatfedolgozás

7 Időszerűsítés (folytatás)
Algoritmus: 1. Z=F(X) tétel alapján; 2. Összefuttatás tétel alapján. Típus Adatok=File(Elem) Módosítók=File(MódElem) Finomítás Elem=Rekord MódElem=Rekord (kulcs:? (módTip:Módosítás egyéb:?) tart:Elem) Módosítás=(Törlés, Javítás,Beszúrás) Adatfedolgozás

8 3.1 Megoldása a „Z=F(X)” tétel alapján
A párosítás elvégezhető (az „Üres” elem bevezetésé-vel), ui. f: X×YZ : Az „Üres” elem bevezetése egy „gyenge” tagolási konfliktusra utal  virtuális típus mind a be-, mind a kimeneti oldalon. Ui. kell tudni X-Y-beli elempárt (esetleg üreset) olvasni, és kell tudni Z-belit (esetleg üreset) írni. X{Üres} × Y{Üres}  Z{Üres} Adatfedolgozás

9 3.1 Megoldása a „Z=F(X)” tétel alapján (folytatás)
A feldolgozás vázlata: (X,Y) Þ Olvas Þ elempár Þ Feldolgoz Þ kielem Þ Ír Þ (ZSehová) Típus Elempár=Rekord Kielem=Rekord (bem:Rekord (üres:Logikai (kész:Logikai tart:Elem) tart:Elem) mód:Rekord (kész:Logikai tart:MódElem)) Fel lett dolgozva az elem. Nincs output-elem. Fel lett dolgozva az elem. Adatfedolgozás

10 3.1 Megoldása a „Z=F(X)” tétel alapján (folytatás)
Implementáció: Eljárás Időszerűsítés (Változó X:Adatok,Y:Módosítók, Z:Adatok): Változó adpár:Elempár kiad:KiElem Nyitás(X,Y,...); Nyit(Z,...) Ciklus amíg nem Vége?(X,Y) Olvasás(X,Y,adpár) Feldolgoz(adpár,kiad) Írás(Z,kiad) Ciklus vége Zárás(X,Y); Zár(Z) Eljárás vége. Adatfedolgozás

11 3.1 Megoldása a „Z=F(X)” tétel alapján (folytatás)
A következők beolvashatók. Eljárás Nyitás( Változó X:Adatok,Y:Módosítók): Nyit(X,…); adpár.bem.kész:=Igaz Nyit(Y,…); adpár.mod.kész:=Igaz Eljárás vége. Eljárás Zárás( Változó X:Adatok,Y:Módosítók): Zár(X); Zár(Y) Adatfedolgozás

12 3.1 Megoldása a „Z=F(X)” tétel alapján (folytatás)
Eljárás Olvasás(Változó X:Adatok, Y:Módosítók, adpár:Elempár); Ha adpár.bem.kész akkor Ha nem Vége?(X) akkor Olvas(X,adpár.bem.tart) adpár.bem.kész:=Hamis [különben adpár.bem.kész:=Igaz] Elágazás vége Elágazás vége Ha adpár.mód.kész akkor Ha nem Vége?(Y) akkor Olvas(Y,adpár.mód.tart) adpár.mód.kész:=Hamis [különben adpár.mód.kész:=Igaz] Elágazás vége Elágazás vége Eljárás vége. X{Üres} × Y{Üres}  Z{Üres} X{Üres} × Y{Üres}  Z{Üres} Adatfedolgozás

13 3.1 Megoldása a „Z=F(X)” tétel alapján (folytatás)
Eljárás Írás(Változó Z:Adatok, Konstans kiad:KiElem): Ha nem kiad.üres akkor Ír(Z,kiad.tart) [különben Ír(Sehová,kiad.tart)] Eljárás vége. Eljárás Feldolgoz(Változó adpár:Elempár,kiad:KiElem): Elágazás adpár.bem.kész esetén kiad:=KiElem(Hamis,adpár.mód.tart.tart) adpár.mód.kész:=Igaz adpár.mód.kész esetén kiad:=KiElem(Hamis,adpár.bem.tart) adpár.bem.kész:=Igaz adpár.bem.tart.kulcs<adpár.mód.tart.tart.kulcs esetén kiad:=KiElem(Hamis,adpár.bem.tart) adpár.bem.kész:=Igaz … X{Üres} × Y{Üres}  Z{Üres} X vége utáni beszúrás. Y vége: módosítás nélküli másolás. Meggondolandó az esetleges hibalehetőségek érzékelése. Legyen egy HibaLista fájl, amelybe összegyűjtjük a hibásnak érzékelt elemeket, szituációkat (hibafajta, hibás fájl és elemsorszám). Nincs módosítás: másolás. Adatfedolgozás

14 3.1 Megoldása a „Z=F(X)” tétel alapján (folytatás)
… adpár.bem.tart.kulcs>adpár.mód.tart.tart.kulcs esetén kiad:=KiElem(Hamis,adpár.mód.tart.tart) adpár.mód.kész:=Igaz adpár.bem.tart.kulcs=adpár.mód.tart.tart.kulcs és adpár.mód.tart.módtip=Törlés esetén kiad:=KiElem(Igaz,akármi) adpár.mód.kész:=Igaz adpár.bem.kész:=Igaz adpár.bem.tart.kulcs=adpár.mód.tart.tart.kulcs és adpár.mód.tart.módtip=Javítás esetén kiad:=KiElem(Hamis,adpár.mód.tart.tart) adpár.mód.kész:=Igaz adpár.bem.kész:=Igaz Elágazás vége Eljárás vége. Beszúrás. Törlés. Meggondolandó az esetleges hibalehetőségek érzékelése. Legyen egy HibaLista fájl, amelybe összegyűjtjük a hibásnak érzékelt elemeket, szituációkat (hibafajta, hibás fájl és elemsorszám). Javítás. Ellenőrzések nincsenek! Adatfedolgozás

15 3.2 Megoldása az „Összefuttatás” tétel alapján
Analógiák: Adatfedolgozás

16 3.2 Megoldása az „Összefuttatás” tétel alapján (folytatás)
Ti. a bemeneti fájl kész-e? Ti. a módosító fájl kész-e? Típus Puffer=Rekord MódPuffer=Rekord (kész:Logikai (kész:Logikai tart:Elem) tart:MódElem) Eljárás Időszerűsítés(Változó X:Adatok, Y:Módosítók, Z:Adatok): Változó i:Puffer j:MódPuffer Nyit(X,...); ElőreOlvasX(X,i) Nyit(Y,...); ElőreOlvasY(Y,j) Nyit(Z,...) Csak módszertani okok miatt nem „ágyazzuk be” az előreolvasást a nyitásokba... A módszertani ok: a későbbiek során is fel-felbukkan az ElőreOlvasás, így jobb ha itt is látszik; mag azután most nem is egy „virtuális típus” bevezetéséről van szó. Adatfedolgozás

17 3.2 Megoldása az „Összefuttatás” tétel alapján (folytatás)
… Ciklus amíg nem i.kész és nem j.kész Elágazás i.tart.kulcs<j.tart.tart.kulcs esetén Ír(Z,i.tart); ElőreOlvasX(X,i) i.tart.kulcs=j.tart.tart.kulcs esetén Ha j.tart.módTip=Javítás akkor Ír(Z,j.tart.tart) Elágazás vége ElőreOlvasX(X,i) ElőreOlvasY(Y,j) i.tart.kulcs>j.tart.tart.kulcs esetén Ír(Z,j.tart.tart); ElőreOlvasY(Y,j) Elágazás vége Ciklus vége … Emlékeztető: Puffer=Rekord (kész:Logikai tart:Elem) Elem=Rekord (kulcs:?,egyéb:?) MódPuffer=Rekord (kész:Logikai tart:MódElem) MódElem=Rekord (módTip:Módosítás tart:Elem) Módosítás=(…) Adatfedolgozás

18 3.2 Megoldása az „Összefuttatás” tétel alapján (folytatás)
… Elágazás nem i.kész esetén Ciklus amíg nem i.kész Ír(Z,i.tart) ElőreOlvasX(X,i) Ciklus vége nem j.kész esetén Ciklus amíg nem j.kész Ír(Z,j.tart.tart) ElőreOlvasY(Y,j) Ciklus vége Elágazás vége Zár(X); Zár(Y); Zár(Z) Eljárás vége. Nyilván az elágazás gond nélkül elhagyható. Ismét a világosabb fogalmazás érdekében választjuk ezt az eggyel több vizsgálatot igénylő megoldást. Adatfedolgozás

19 3.2 Megoldása az „Összefuttatás” tétel alapján (folytatás)
Eljárás ElőreOlvasX(Változó X:Adatok, i:Puffer): Ha Vége?(X) akkor i.kész:=Igaz különben i.kész:=Hamis; Olvas(X,i.tart) Eljárás vége. Eljárás ElőreOlvasY(Változó Y:Módosítók, j:MódPuffer): Ha Vége?(Y) akkor j.kész:=Igaz különben j.kész:=Hamis Olvas(Y,j.tart.tart) Adatfedolgozás

20 4. Külső rendezések Probléma az adatsorozat 1. terjedelmessége (nem fér a memóriába), 2. szekvencialitása (nincs közvetlen hozzáférés). Miért nem erőltethetők a belső rendezések? Elvileg is gyakorlatilag is reménytelen. Megoldásvázlat: ad 1. A memóriába beférő darabot belső rendezéssel rendezni, így kapunk egy futamot. ad 2. Egy szekvenciális módszerrel fokozatosan nö-velni a futamok hosszát, amíg egyetlen rendezett so-rozattá nem lesz, ez a módszer lehet az összefésülés. A „Miért nem…?”–hez: A legoptimistább esetben, amelynél találnánk „elvileg” működő algoritmust, lesújtó „gyakorlati” problémába ütköznénk: N2 elemolvasással jellemezhető a hatékonyság! Adatfedolgozás

21 4.1 Négy munkafájlos rendezés
A lényeg: A rendezés (F): a bemenet futamokra szedése 2 munkafájlba (H), majd a fájlbeli futamok összefésülése (G). 1. A H megkonstruálása: Tagolási konfliktus  Virtuális típus: • futamonként egy-egy fájl (kivitelezhetetlen) • sok futam egy fájlban (virtuális fájlkezelés) F(X):=H•G(X) Típus [H-hoz] Bemenet=File(Elem) Kimenet=File(Futam) Elem=?  Futam=File(Elem) A Futam típushoz: persze mondhatnánk, hogy Tömb(1..??:Elem), hiszen úgyis a memóriában rendezzük, de mégsem, mert később a futamok hossza változni fog a fájlban. A futamonként egy fájlhoz: ez valójában a fájl méretétől függő számú fájlt jelent, ami alapfeltevésünknek (ti. a memóriaigény nem lehet arányos a fájl elemszámával) mondana ellent, hisz a fájlokhoz kisebb-nagyobb memóriatartomány szükségképpen tartozik. FutamFile Adatfedolgozás

22 4.1 Négy munkafájlos rendezés (folytatás)
G=összefésülés  (legalább) 2 fájl kell hozzá • 2 fájlban választjuk szét a futamokat. A futamok felváltva: hol egyikbe, hol másikba… 2. A G megkonstruálása: Tagolási + rendezetlenségi konfliktus Típus [H-hoz] Bemenet=File(Elem) Kimenet=File(Futam)× File(Futam) Elem=?  Futam=File(Elem) Típus [G-hez] Bemenet=File(Futam)× File(Futam) Kimenet=File(Elem) Futam=File(Elem)  Elem=? Adatfedolgozás

23 4.1 Négy munkafájlos rendezés (folytatás)
G mint futamokon értelmezett leképezés: Tehát 4 munkafájl szükséges a megvalósításhoz. X ,ha FutamSzám(X)=1  FutamSzám(Y)=0 G(X,Y):=  G(G1(X,Y)) ,egyébként (Öf(Xi,Yi),Üres),ha Xi,Yi páratlanadik futam G1:(Xi,Yi)  (Üres,Öf(Xi,Yi)),ha Xi,Yi párosadik futam Öf: összefésülés Típus [G1-hez] Bemenet=File(Futam)×File(Futam) Kimenet=File(Futam)×File(Futam) Futam=File(Elem)  {Üres} Elem=? Adatfedolgozás

24 4.1 Négy munkafájlos rendezés (folytatás)
Példa a részletezés elé: Legyen X=(x1, ..., xN) a rendezendő sorozat; M1, M2, M3 és M4 a munkafájlok; a memóriá- ba k db fér be. Kezdetben M1..4=( ). 0. lépés: M1..2 előállítása: M1=(x1,...,xk, x2k+1,...,x3k, ...) M2=(xk+1,...,x2k, x3k+1,...,x4k, ...) 1. lépés: M1..2 összefésülése: M3=(x1,...,x2k, x4k+1,...,x6k, ...) M4=(x2k+1,...,x4k, x6k+1,...,x8k, ...) 2..i. lépés: M1..2 M3..4 szerepcserés összefésülése. Az i. lépésben a futamhossz: 2ik  max(i)=n: 2nkN  nlog2(N/k) … és mivel egy fájlpár összefuttatása során mind az N elemet újra kell olvasni (és írni), ezért a szükséges fájl-műveletek száma N*log2(N/k). (Azaz a –z elvileg is aligha létrehozható– belső rendezésből kiinduló megoldásnál becsült N2-nél jobb!) Adatfedolgozás

25 4.1 Négy munkafájlos rendezés (folytatás)
Reprezentáció: Implementáció: Típus SFV=Tömb(1..4:SF) [SFV=Segédfájl-Vektor] SF=Rekord(fájl:Kimenet, db:Egész) [SF=Segédfájl] fájlbeli futamszám Eljárás NégyfájlosRendezés(Változó X:Bemenet, M:SFV, K:Egész): Szétrak(X,M,K) SoxorÖsszefésül(M,K) Töröl(M(2).fájl,M(3).fájl,M(4).fájl) Eljárás vége. Kezdő futamhossz Adatfedolgozás

26 4.1 Négy munkafájlos rendezés (folytatás)
A H függvény kiszámítása. Eljárás Szétrak(Változó X:Bemenet, M:SFV, K:Egész): … [fájlnyitások] M(1).db:=0; M(2).db:=0; MI:=1 Ciklus amíg nem Vége?(X) FutamOlvasás(X,R,K) [R=puffer] FutamRendezés(R) FutamÍrás(M(MI).fájl,R); M(MI).db:+1; MI:=3-MI Ciklus vége … [fájlzárások] Eljárás vége. Eljárás SoxorÖsszefésül(Változó M:SFV, K:Egész): Ciklus Páronként(M,K) [(1,2)(3,4)] Csere(1,3) [„megcseréli” a fájlokat]; K:=2*K amíg M(1).db+M(2).db≠1 Ciklus vége Eljárás vége. hf hf hf A G függvény kiszámítása. Adatfedolgozás

27 4.1 Négy munkafájlos rendezés (folytatás)
A G1 függvény kiszámítása. Eljárás Páronként(Változó M:SFV, Konstans K:Egész): … [fájlnyitások] HOVA:=3; HONNAN:=1 M(HOVA).db:=0; M(HOVA+1).db:=0 Ciklus I=1-től M(HONNAN+1).db-ig [a „rövidebbig”] Ha I Mod 2=1 akkor CÉL:=HOVA különben CÉL:=HOVA+1 KétFutamotÖsszefésül(M,K,HONNAN,CÉL); M(CÉL).db:+1 Ciklus vége Ha M(HONNAN).db>M(HONNAN+1).db akkor [utolsó egyke] Ha M(HONNAN).db Mod 2=1 akkor CÉL:=HOVA különben CÉL:=HOVA+1 Másol(M(HONNAN).fájl,M(CÉL).fájl); M(CÉL).db:+1 Elágazás vége … [fájlzárások] Eljárás vége. hf A „rövidebbig”-hez: világos, hogy ha nem azonos számú futamot tartalmaz a két fájl, akkor a kisebb végén van az „egyke”. hf Adatfedolgozás

28 4.2 Három munkafájlos rendezés
A lényeg: Az előzőhöz hasonlóan a rendezés (F): a bemenet futamokra szedése 2 munkafájlba (H), majd a fájlbeli futamok összefésülése (G). A részletek megértéséhez egy példa: F(X):=H•G(X) Visszafelé követve a fájlokbeli futamszám alakulását 1. fájl 2. fájl 3. fájl 1 0 0 Végállapot 0 1 1 Összefésülés: (2,3)  1 1 0 2 Összefésülés: (3,1)  2 3 2 0 Összefésülés: (1,2)  3 0 5 3 Összefésülés: (2,3)  1 5 0 8 Összefésülés: (3,1)  2 Adatfedolgozás

29 4.2 Három munkafájlos rendezés (folytatás)
Megfigyelés: Az összefésülésben résztvevő fájlok ciklikusan következnek. A futamok száma az egymást követő Fibonacci- számok. Következmény: A kezdeti Fibonacci-futamszám „mesterséges” (0 hosszúságú) futamok hozzáillesztésével érhető el. Nem azonos hosszúak a futamok: tárolni kell a futamhosszat vagy egy futamvégjelet. Adatfedolgozás

30 4.2 Három munkafájlos rendezés (folytatás)
A G, G1 megfontolása: l. korábban. Implementáció: Eljárás SoxorÖsszefésül(Változó M:SFV): Ciklus amíg M(1).db+M(2).db+M(3).db≠1 Páronként(M) [(1,2)3] CiklikusLéptetés(M) [1231] Ciklus vége Eljárás vége. Adatfedolgozás

31 4.3 Prioritási soros rendezés
A lényeg: · a memóriában egy rendezett (prioritási) sor van, · a legkisebb elemét kiírjuk a munkafájlba, és · rendezettségnek (prioritásának) megfelelő helyre, beillesztjük következőként a beolvasott elemet. · Amikor a fájlt végigolvastuk, · a memóriában a legnagyobbak találhatók, és · a kiírt fájlban minden elem (legalább a memó-riabeli darabszám-1-gyel) közelebb kerül a vég-leges helyéhez. Adatfedolgozás

32 4.3 Prioritási soros rendezés (folytatás)
Implemetáció: Eljárás PrSorosRendezés(Változó X:Bemenet,Y:Kimenet): Ciklus amíg … kell? … … [fájlnyitások] db:=0; ÜresPrSor Ciklus amíg nem Vége?(X) és db<K Olvas(X,adat); PrSorba(adat); db:+1 Ciklus vége Ciklus amíg nem Vége?(X) PrSorból(adat); Ír(Y,adat) Olvas(X,adat); PrSorba(adat) Ciklus vége Ciklus amíg nem ÜresPrSor? PrSorból(adat); Ír(Y,adat) Ciklus vége … [fájlzárások] Ciklus vége Eljárás vége. hf hf Adatfedolgozás