15. mintafeladatok 15.1. Másodfokú egyenlet megoldása Az együtthatók ismeretében oldjunk meg egy másodfokú egyenletet. A program vizsgálja meg, hogy az egyenletnek van-e megoldása, egy megoldása van-e, illetve a gyökei valósak vagy komplexek. A feladat matematikai modellje Az a,b és c együtthatók ismeretében a másodfokú egyenlet alakja {EMBED Equation |} A programban az alábbi vizsgálatokat kell elvégezni 1. Ha az a,b,c értéke zérus, akkor az egyenletnek bármelyik szám a megoldása. 2. Ha a,b zérus és c nem zérus, akkor az egyenlet ellentmondásos, nincs megoldás. 3. Ha az a zérus, de a b és c nem zérus, akkor az egyenlet elsőfokú {EMBED Equation |} 4. Ha a,b és c nem zérus, akkor kiszámítjuk a diszkrimináns értékét: {EMBED Equation |} 4.a. Ha a d előjele negatív, az egyenletnek komplex megoldása van A gyök valós része az xv a képzetes része xk {EMBED Equation |} {EMBED Equation |} akkor a két komplex gyök {EMBED Equation |} 4.b. Ha a diszkrimináns értéke zérus, akkor az egyenletnek csak egy megoldása van {EMBED Equation |} 4.c. Ha a diszkrimináns értéke pozitív, akkor az egyenletnek két valós gyöke van {EMBED Equation |} {EMBED Equation |} A program felépítése A másodfokú egyenlet algoritmusának a felépítését a 15.1. ábrán látható blokkdiagram mutatja a legszemléletesebben. {EMBED MSDraw \* mergeformat|} 15.1. ábra Másodfokú egyenlet megoldásának blokkdiagramja A másodfokú egyenletet megoldó programban első lépésként beolvassuk a, b és c együtthatók értékét. Ezután egy vizsgálat következik, amellyel eldöntjük, hogy a értéke nulla-e vagy attól eltérő, majd a program két ágon folytatódik. Az a=0 feltétel teljesülése esetén (másképpen mondva, ha az a=0 kifejezés értéke true) akkor a feladatot elsőfokú egyenletként kell megoldani, és csak akkor kell a fenti megoldóképletet használni, ha a fenti kifejezés értéke false. Ekkor azonban a diszkrimináns (b2-4ac) előjelétől függ a megoldások száma, ezért az előjeltől függően három ágon folytatódik a program. Tervezzük meg a program változólistáját: A program a,b és c real típusú változói tartalmazzák a bemenő adatokat, az egyenlet együtthatóit. A program eredménye általában két szám, az egyenlet gyökei, amelyek ugyancsak real típusúak. Meg kell jegyezni, hogy a másodfokú egyenlet megoldásakor elképzelhető, hogy eredményként komplex szám jön ki, ez azonban, mint a programból követhető, két real típusú számból építhető fel. Ez a két változó legyen az x1 és az x2. A program futása során több helyen is felhasználjuk a diszkrimináns értékét, ezért ennek is felveszünk egy segédváltozót, hogy ne kelljen minden egyes esetben újra és újra kiszámolnunk. Ez a változó lesz a d, típusa szintén real. Ezután már csak egy változóra van szükségünk, mégpedig egy olyanra, amelyik megmutatja nekünk a diszkrimináns előjelét. Ez azért célszerű, mert a diszkrimináns pozitív, negatív illetve nulla volta esetén különböző a megoldás menete, azaz összesen három ágon fut tovább a program. Ezt a program írásakor legelegánsabban egy case utasítással oldhatjuk meg, ennek használatához felvesszük a sign nevű integer típusú változót, amelynek értéke a program futása alatt a -1, 0 valamint az 1 lehet. A program listája (* masod.pas *) program masodfoku; var a,b,c,d,x1,x2 : real; sign : integer; begin Writeln(' Másodfokú egyenlet megoldása'); Writeln('Ax^2+Bx+C=0 egyenlet együtthatóinak megadása '); Write('A='); ReadLn(a); Write('B='); ReadLn(b); Write('C='); ReadLn(c); if a=0 then begin if b=0 then begin if c=0 then WriteLn('Az egyenletnek bármelyik szám megoldása') else WriteLn('Ellentmondás, nincs megoldás'); end else begin x1:=-c/b; WriteLn('Az egyenlet elsőfokú, x=',x1:8:4); end; end else begin d:=sqr(b)-4*a*c; if d=0 then sign:=0 else sign:=round(d/abs(d)); case sign of -1:begin x1:=-b/2/a; x2:=sqrt(abs(d))/2/a; Writeln('Az egyenletnek komplex megoldása van'); Writeln('X1=',x1:8:4,'+',x2:8:4,'*i'); Writeln('X2=',x1:8:4,'-',x2:8:4,'*i'); end; 0:begin x1:=-b/2/a; WriteLn('Az egyenletnek csak egy megoldása van'); Writeln('X=',x1:8:4); end; 1:begin x1:=(-b+sqrt(d))/2/a; x2:=(-b-sqrt(d))/2/a; WriteLn('Az egyenlet megoldásai'); WriteLn('X1=',x1:8:4); WriteLn('X2=',x2:8:4); end; end; end; end. A programban két fontos dolgot követhetünk nyomon. Az egyik a begin - end utasítászárójelek használata, a másik pedig a többágú elágazás, a case utasítás. Az utasítászárójelek szerepe az, hogy több utasítást egybefogjon, és például az if utasításban lehetővé tegye több utasítás ugyanazon feltételtől függő végrehajtását. A program futtatási eredménye 1. Futási eredmény Másodfok egyenlet megoldása Ax^2+Bx+C=0 egyenlet együtthatóinak megadása A=1 B=2 C=-15 Az egyenlet megoldásai X1= 3.0000 X2= -5.0000 2. Futási eredmény: Másodfokú egyenlet megoldása Ax^2+Bx+C=0 egyenlet együtthatóinak megadása A=1 B=1 C=2 Az egyenletnek komplex megoldása van X1= -0.5000+ 1.3229*i X2= -0.5000- 1.3229*i 3. Futási eredmény: Másodfokú egyenlet megoldása Ax^2+Bx+C=0 egyenlet együtthatóinak megadása A=0 B=1 C=2 Az egyenlet elsőfokú, x= -2.0000 A másodfokú egyenlet megoldására készíthetünk olyan programot, amely feladatmegoldást eljárásokkal oldja meg. A MASOD.PAS program eljárással működő változata a MASOD_FG.PAS program. A MASOD_F2.PAS programban teljesen különválasztottuk a feladat megoldásától az eremény kiíratását. A MASOD eljárás a jelez formális paraméterében jelzi a megoldás típusát. Az eredmeny_kiir eljárás kiírja az eredményt. (* masod_f2.pas *) program masodfoku; var a1,b1,c1, x1,x2,x1i,x2i : real; j : integer; procedure olvas(var a,b,c :real); begin Writeln('Másodfokú egyenlet megoldása'); Writeln('Ax^2+Bx+C=0 egyenlet együtthatóinak megadása'); Write('A='); ReadLn(a); Write('B='); ReadLn(b); Write('C='); ReadLn(c); end; procedure eredmeny_kiir(x1,x2:real; jelez:integer); begin case jelez of 1: WriteLn('Az egyenletnek bármelyik szám megoldása'); 2: WriteLn('Ellentmondás, nincs megoldás'); 3: WriteLn('Az egyenlet elsőfokú, x=',x1:8:4); 4: begin Writeln('Az egyenletnek komplex megoldása van'); Writeln('X1=',x1:8:4,'+',x2:8:4,'*i'); Writeln('X2=',x1:8:4,'-',x2:8:4,'*i'); end; 5: begin WriteLn('Az egyenletnek csak egy megoldása van'); Writeln('X=',x1:8:4); end; 6: begin WriteLn('Az egyenlet megoldásai'); WriteLn('X1=',x1:8:4); WriteLn('X2=',x2:8:4); end; end; end; procedure masod(a,b,c: real; var x1,x2:real; var jelez: integer); var d : real; sign: integer; begin if a=0 then begin if b=0 then begin if c=0 then jelez:=1 else jelez:=2; end else begin x1:=-c/b; jelez:=3; end; end else begin d:=sqr(b)-4*a*c; if d=0 then sign:=0 else sign:=round(d/abs(d)); case sign of -1 : begin x1:=-b/2/a; x2:=sqrt(abs(d))/2/a; jelez:=4; end; 0 : begin x1:=-b/2/a; jelez:=5; end; 1 : begin x1:=(-b+sqrt(d))/2/a; x2:=(-b-sqrt(d))/2/a; jelez:=6; end; end; end; end; begin olvas(a1,b1,c1); masod(a1,b1,c1,x1,x2,j); eredmeny_kiir(x1,x2,j); end. 15.2. Adatok rendezése Rendezésnek nevezzük azt a folyamatot, amikor egy halmaz elemeit valamilyen szabály szerint sorba (növekvő vagy csökkenő) rendezzük. A rendezés meggyorsítja az elemek későbbi keresését, mivel egy rendezett halmazon való keresés jóval gyorsabban megy végbe. A rendezés kiemelkedően fontos tevékenység az adatfeldogozásban során. Sokfajta rendező algoritmus van, mindegyik ugyanazt a feladatot végzi, mégis van közöttük eltérés. A rendező módszereket két csoportba sorolhatjuk: tömbök rendezése és (soros) file-ok rendezése. Gyakran a két csoportot nevezik még belső ill. külső rendezésnek, mivel a tömbök rendezése a számítógép gyors, belső tárában (memóriájában) zajlik, míg a file-ok a lassúbb, de tágasabb külső tárolón (winchester-en) megy végbe. A tömbök rendezése A legfontosabb követelmény a tömbök rendezőmódszereitől, hogy a rendelkezésre álló tárat gazdaságosan használják ki. Az ismertetett módszerek az adatok átrendezését a saját helyükön hajtják végre. A közvetlen módszerek igen alkalmasak arra, hogy megértsük a legfontosabb rendezőelveket, mivel a programjaik könnyen érthetőek, viszonylag rövidebbek, tehát kevesebb művelettel működnek, kevesebb helyet foglalnak le a memóriában. A bonyolultabb algoritmusok kevesebb lépést tartalmaznak, de ezek a lépések részleteikben jóval bonyolultabbak. Megjegyezzük, hogy a közvetlen módszerek elég kis n-re gyorsabbak, míg a nagyobb n-re már nem érdemes őket használni. Az ismertetésre kerülő módszerek az eredeti helyükön rendezik át az adatokat növekvő sorrendre. Az alkalmazott módszereket az alábbi csoportba sorolhatjuk: 1. rendezés cserével 2. rendezés beszúrással 3. rendezés kiválasztással 15.2.1. Rendezés cserével Nézzünk egy példát egész típsusú tömb adatainak rendezésére adatok cseréjével: Legyen az adatok : n Az elv a következő: Két egymásba ágyazott ciklussal vizsgáljuk az elemeket úgy, hogy a külső i ciklus egytől n-1 -ig, a belső j ciklus pedig i+1 -től n-ig vizsgálja az elemeket. A rögzített i-edik elemet hasonlítjuk össze a mögötte lévő elemekkel és cseréljük, ha a mögötte lévő elem kisebb. A rögzített elem vastag kiemeléssel, az összehasonlítandó elem pedig vastag, dőlt kiemeléssel szerepel a példában. A tömb indexe: 1 2 3 4 5 i=1 j=2 5 2 3 1 4 {SYMBOL 192 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} j=3 2 5 3 1 4 {SYMBOL 192 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} j=4 1 5 3 2 4 nincs csere i=2 j=3 1 5 3 2 4 {SYMBOL 192 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} j=4 1 3 5 2 4 {SYMBOL 192 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} j=5 1 2 5 3 4 nincs csere i=3 j=4 1 2 5 3 4 {SYMBOL 192 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} j=5 1 2 3 5 4 nincs csere i=4 j=5 1 2 3 5 4 {SYMBOL 192 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} Rendezve 1 2 3 4 5 A RENDEZN.PAS program mutatja be az elemek cseréjét. (* rendezn.pas *) program rendez_integer_adatot; { Egesz tipusu adatok rendezese } (* deklaracio *) var x : array[1..50] of integer; n,i,j,s : integer; (* fo program *) begin (* adatok beolvasasa *) writeln; writeln('Egesz tipusu adatok rendezese novekvo sorrendben'); writeln; repeat write('Az adatok szama: '); readln(n); if n>50 then writeln('Hibas adat: max 50… '); until n <= 50; for i:=1 to n do begin write('x[',i:2,']= '); readln(x[i]); end; (* adatok rendezese *) for i:=1 to n-1 do for j:=i+1 to n do (* csokkeno sorrend: x[j]>x[i] javitassal *) if x[j]n then writeln(' Hibas adat: max 50 …'); until m<=n; for i:=1 to m do begin write('x[',i:2,']= '); readln(x[i]); end; end; procedure kiir(x:vekt;m:integer); var i:integer; begin writeln; writeln('Rendezett adatok'); writeln('Az adatok szama: ',m:3); writeln; for i:=1 to m do writeln('x[',i:2,']= ',x[i]); end; begin clrscr; (* kepernyo torlese *) olvas(y,k); rend(y,k); kiir(y,k); end. 15.2.2. Sztring típusú adatok rendezése Sztring típusú adatok rendezése hasonlóan történik a numerikus adatok rendezéséhez, természetesen az ékezetes karakterek nem kerülnek abc sorrendbe. A rendezés csak ékezet nélküli karakterláncra működik helyesen. A NEVREND.PAS program maximálisan 50 darab 30 karakteres nevet rendez. (* nevrend.pas *) program nevrendn; { sztringet tartalmazo tomb abc sorrendbe torteno rendezese } type str=string[30]; var a:array[1..50] of str; i,j,n:integer; g:str; k:boolean; begin writeln('Max. 50 nev rendezese'); writeln; repeat write('Nevek szama: '); readln(n); if n>50 then writeln('Hibas adat: max 50 …'); until n <= 50; writeln; for i:=1 to n do begin write(i,'. nev : '); readln(a[i]); end; writeln; for i:=1 to n-1 do for j:=i+1 to n do if a[i]>a[j] then begin g:=a[i]; a[i]:=a[j]; a[j]:=g; end; for i:=1 to n do writeln(i,'. nev : ',a[i]); end. 15.2.3. Különféle rendező algoritmusok Egyszerű menüvel vezérelt programban kiválaszthatunk rendezést közvetlen beszúrással, valamint buborék módszerrel is. Rendezés közvetlen beszúrással A rendezés közvetlen beszúrásnál az algoritmus úgy működik, hogy minden lépésben, 2-től egyesével m darab adat esetén m-ig kiemeljük a csökkenő sorozat szerinti első elemet és beszúrjuk a megfelelő helyre. Alap 5 2 3 1 4 {SYMBOL 218 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} 1. lépés 2 5 3 1 4 {SYMBOL 218 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} 2. lépés 2 3 5 1 4 {SYMBOL 218 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} 3. lépés 1 2 3 5 4 {SYMBOL 218 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} 4. lépés 1 2 3 4 5 Buborék rendezés Ha a tömböt egy víztartályhoz hasonlítjuk és a rendezendő tételeknek a buborékok súlyát feleltetjük meg, akkor minden lépés egy buborék felemelkesését eredményezi a súlyának megfelelő szintre. Ennél az algoritmusnál előfordul, hogy már nincs szükség cserére, mert az adatok már rendezve voltak, mégsem áll le a rendezési művelet. Ezen úgy javíthatunk, hogy minden menetben feljegyezzük, hogy történt-e csere a menet alatt. Az első olyan menetnél, ahol nem történt csere, az algoritmus befejezheti a munkáját. Sőt tovább javítható az algoritmus úgy, hogy megjegyezzük az utolsó csere indexét. Ha ez az index k, akkor ez azt jelenti, hogy a k alatti adatok már jó sorrenben állnak. Alap 5 2 3 1 4 {SYMBOL 218 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} 1. lépés 1 5 2 3 4 {SYMBOL 218 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} 2. lépés 1 2 5 3 4 {SYMBOL 218 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} 3. lépés 1 2 3 5 4 {SYMBOL 218 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 196 \f "MS LineDraw"}{SYMBOL 217 \f "MS LineDraw"} 4. lépés 1 2 3 4 5 A RENDEZM.PAS mutatja be rendező algoritmusok pascal programját. (* rendezm.pas *) (* Egesz tipusu adatok rendezese menuvel *) (* tobb modszerrel *) program rendezes_menuvel; uses crt; const db =100; type itype=array[1..db] of integer; var y: itype; n,jel: integer; procedure olvas(var x:itype; var m:integer); var i:integer; begin writeln; writeln('Rendezendo (integer tipusu) adatok'); repeat write('Az adatok szama : '); readln(m); if m>db then writeln('Az adatok max. szama : ',db); until m<=db; for i:=1 to m do begin write(' [',i:2,']= '); readln(x[i]); end; end; procedure kiir(x:itype; m,sorszam:integer); var i:integer; begin writeln; writeln('Rendezett adatok'); write('Rendezes modszere: '); case sorszam of 1: writeln('csere'); 2: writeln('kozvetlen csere'); 3: writeln('buborek'); end; writeln('Az adatok szama : ',m); for i:=1 to m do begin writeln(' [',i:2,']= ',x[i]); end; writeln; end; procedure csere(var x:itype; m:integer); var i,j,s:integer; begin for i:=1 to m-1 do for j:=i+1 to m do if x[j]0) and (bufx[j] then begin buf :=x[j-1]; x[j-1]:=x[j]; x[j] :=buf; end; end; end; procedure menu(var sorszam:integer); var s : string; kod: integer; begin repeat clrscr; (* kepernyo torlese *) writeln; writeln(' RENDEZES '); writeln; writeln(' 1. Csere '); writeln(' 2. Kozvetlen csere '); writeln(' 3. Buborek modszer '); writeln(' 4. Kilepes '); writeln; write('A modszer sorszama: '); readln(s); val(s,sorszam,kod); if (kod<>0) or (sorszam<=0) or (sorszam>4) then begin writeln('Hibas menusorszam'); writeln(' Nyomj Enter-t'); readln; end; until (kod=0) and (sorszam>0) and (sorszam<=4); end; (* rendezes foprogramja *) begin menu(jel); clrscr; case jel of 1: begin olvas(y,n); csere(y,n); end; 2: begin olvas(y,n); kozvetlen(y,n); end; 3: begin olvas(y,n); buborek(y,n); end; 4: exit; end; kiir(y,n,jel); end. A program eredménye: RENDEZES 1. Csere 2. Közvetlen beszuras 3. Buborek modszer 4. Kilepes A modszer sorszama: 1 Rendezendo (integer tipusu) adatok Az adatok szama: 5 [ 1]= 5 [ 2]= 2 [ 3]= 3 [ 4]= 1 [ 5]= 4 Rendezett adatok Rendezes módszere: csere Az adatok szama: 5 [ 1]= 1 [ 2]= 2 [ 3]= 3 [ 4]= 4 [ 5]= 5 Rendezés quick (gyors) módszerrel A REKORD.PAS bemutatja rekord típusú adatok rendezését quick módszerrel. A qs eljárás rekurzív módon saját magát hívja. A rekurzió ilyen felhasználása igen hatékony eszköz az algoritmusokban. Az iteratív megoldás lényege az, hogy a felosztások végrehajtási igényét feljegyezzük egy várakozó listára. Minden lépésben két újabb felosztási feladat keletkezik. Csak az egyiket lehet azonnal elkezdeni a soronkövetkező iterációban, a másikat erre a várakozó listára helyezzük. Legyen a következő rekord: cim = record nev : string[25]; utca : string[20]; varos : string[20]; orszag: string[2]; kod : string[5]; end; amely tartalmazza egy személy nevét lakcímét, irányító szám, ország, város és utca adatokkal. (* rekord.pas *) program rekord_rendezes; { rekord rendezes quick modszerrel } const db=50; type cim = record nev : string[25]; utca : string[20]; varos : string[20]; orszag: string[2]; kod : string[5]; end; cim_t = array[1..db] of cim; var lakos : cim_t; r : cim; n : integer; procedure olvas_rec(var x:cim_t; var m:integer); var i:integer; begin writeln('Rendezendo adatok'); repeat write('Az adatok szama : '); readln(m); if m>db then writeln('Az adatok max. szama : ',db); until m<=db; for i:=1 to m do begin write(' Nev (max. 25 kar.) = '); readln(x[i].nev); write(' Utca (max. 20 kar.) = '); readln(x[i].utca); write(' Varos (max. 20 kar.) = '); readln(x[i].varos); write(' Orszag (max. 2 kar. ) = '); readln(x[i].orszag); write(' Kod (max. 5.kar. ) = '); readln(x[i].kod); writeln; end; end; procedure kiir_rec(x:cim_t; m:integer); var i:integer; begin writeln('Rendezett adatok '); writeln('Az adatok szama : ',m); for i:=1 to m do begin writeln(' Nev : ',x[i].nev); writeln(' Utca : ',x[i].utca); writeln(' Varos : ',x[i].varos); writeln(' Orszag : ',x[i].orszag); writeln(' Kod : ',x[i].kod); writeln; end; writeln; end; procedure qs_rekord(var x:cim_t; m:integer); procedure qs(l,r:integer; var xx:cim_t); var i,j :integer; buf1,buf2:cim; begin i:=l; j:=r; buf1:=xx[(l+r) div 2]; repeat while xx[i].nev < buf1.nev do i:=i+1; while buf1.nev < xx[j].nev do j:=j-1; if i<=j then begin buf2 :=xx[i]; xx[i]:=xx[j]; xx[j]:=buf2; i:=i+1; j:=j-1; end; until i>j; if l