A tömb adatszerkezet

Az adataink szerkezeti szempontból lehetnek egyszerûek, vagy összetettek. Az egyszerû szerkezetû adatok nem bonthatók értelmes részekre, nincs is szerkezetük. Ilyen egyszerû adat a karakter, melynek nincsenek igazi részei, az egész számok sem állnak értelmes részekbõl a valós számokat is egyszerûnek tekintjük. Az összetett adatok, tehát melyeknek szerkezete van, értelmes, önmagukban is jelentéssel bíró részekbõl állnak. Az összetett adat elemi részei egymáshoz meghatározott módon kapcsolódnak, szerkezetet alkotnak. Egyik ilyen összetett, szerkezettel rendelkezõ adattípus a tömb.

A tömb azonos típusú elemekbõl álló összetett adatszerkezet. Elemeire a tömb indexei segítségével hivatkozhatunk. Ezek az indexek hasonló szerepet töltenek be a tömbnél, mint az utcák esetén a házszámok. A Kazinczy utca 12 számra úgy hivatkozunk, hogy Kazinczy[12]. A Nevek tömb 12. eleme a Nevek[12] módon hivatkozható.

Megjegyzés: A string adatszerkezet is felfogható egy karakterekbõl álló tömbnek. A string elemeire is hivatkozhatunk egyenként.

Var nev:string;

begin

nev:=’Katica’.

Write(nev[2]);

End.

A kis program kiírja az a betût, a nev változó 2. elemét. Mj. vége.

Ha egy olyan adathalmazhoz deklarálunk változót, amelynek elemeire érdemes sorszámukkal hivatkozni ezt tömb szerkezettel tehetjük meg. A tömbváltozó tárolja a teljes adathalmazt és elemei egy-egy elemét tárolják a halmaznak. A tömbváltozót úgy nevezzük el, hogy annak vagy többes számú nevet adunk, vagy az adathalmaz összességének megfelelõ új nevet választunk. Ha például több összetartozó nevet akarunk tárolni, az adatokat tartalmazó tömb adatszerkezetû változót nevezhetjük nevek-nek. Ha ezek egy osztály tagjai akkor esetleg a nevsor nevet is kaphatja a változó. Egyformán értelmes a nevek[3], vagyis a nevek közül a 3. elemrõl, vagy a nevsor[3] vagyis a névsor 3. elemérõl beszélni.

A megfelelõ deklaráció után a tömbelem éppúgy viselkedik, mit bármely változó. A szamok, numerikus értékek tárolására alkalmas tömb típusú változó egy elemének adhatunk értéket:

Szamok[2]:=12;

A változó elemenként részt vehet értékadásban:

szamok[3]:= szamok[2]+4;

A fenti tömb elemeket egy tömbként a program deklarációs részében létre kell hozni. Az alábbi példában a szamok tömböt 10 elemûre deklarálom, elemeinek sorszáma 1..10, és elemei integer típusúak lehetnek.

Var szamok: array[1..10] of integer;

Amikor megadom az array kulcsszót, azzal azt fejezem ki, hogy tömböt deklarálok. Az array kulcsszó mögötti [1..10] a tömb elemének alsó és felsõ indexét adja meg. Vagyis legkisebb sorszámú elem az 1. a legnagyobb a 10. lesz, vagyis összesen 10 elem lehet. A szamok tömb tartama pedig egész számokból állhat, erre utal az of integer. A szamok tömb 10 db egész szám tárolására alkalmas. A legelsõ szám sorszáma 1. a legutolsó sorszáma pedig 10 lesz.

Var nevek : array[1..32] of string;

A nevek alkalmas lesz 32 név tárolására, a legelsõ 1. a legutolsó 32. sorszámmal szerepel. A névsorban elsõ tanuló bevitele:

Nevek[1]:=’Andirkó Erika’;

A legutolsó megadása pedig:

Nevek[32]:=’Zsuga Zsiga’;

A konkrét szám helyett egy változó is szerepelhet az index helyén a tömbváltozó mögötti szögletes zárójelben. (feltételezzük, hogy a nevek tömb fel van töltve.)

Write(’ Hányadik tanuló neve kell? ’);

Readln(sorszam);

Writeln(’A kért tanuló: ’, nevek[sorszam]);

Az alábbi program a teljes osztálynévsor bevitelét adja meg.

Program NevsorFeltolt;

Var i: integer;

egynev: string;

nevek:array[1..32] of string;

Begin

For i:=1 to 32 do

begin

writeln(’Kérem az’,i,’. nevet:’ );

readln(egynev);

nevek[i]:=egynev;

end;

End.

Gyakran szükségünk van a tömb két elemének cseréjére. Az i. és j. elemet az alábbi módon cseréljük meg az elem nevû változó segítségével:

elem:=tomb[i];

tomb[i]:=tomb[j];

tomb[j]:=elem;

Az elem nevû változó a tömb elemének típusával egyezik meg. Ha általában beszélünk tömbökrõl azt gyakran tomb néven illetjük és feltétezzük, hogy rendelkezik a szükséges tulajdonságokkal. Ha két tömböt kezelünk az egyiket gyakran A, a másikat gyakran B tömbnek nevezzük. A tömbök között általában nem végezhetünk közvetlen értékadást, hanem csak elemenként lehet rájuk a mûveletek során hivatkozni. A tömb nem íratható ki egyben, hanem csak elemenként. A tömb kiíratását egy ciklusban végezzük, ahol minden elemre sorszáma segítségével hivatkozunk, és egyenként íratjuk ki az elemeket.

A tömb megértéséhez egy újabb magyarázatot nézzünk meg, ha még kell!

A tömböt a következõképpen lehetne szemléltetni. Képzeljünk el egy olyan tartályt, amely 10 egyforma ûrtartalmú kisebb tároló rekeszt tartalmaz (10 elemû tömb). Az egész tömböt együtt nem tudjuk kezelni, csak egy akkora szállító edényt, amekkora egyetlen rekesznek a térfogata, vagyis egy akkorát, mint a tartály egy eleme. Feladat, hogy ezt a tartályt feltöltsük. Mivel a nagy tartályt nem tudjuk mozgatni, ezért vagyunk kénytelenek a nagy tartály egy-egy rekeszét egymás után feltölteni.

Tehát van 10 kisebb rekeszünk, egyszerre csak egy ilyen kis tartályt tudunk a tömbben feltölteni, tehát 10-szer kell az egyedüli kis tartályt feltölteni és a tömb soron következõ rekeszébe beletölteni. Mivel 10-szer végezzük ugyan azon cselekvéssorozatot, tehát kis tartály feltöltése, kiürítése a tömb soron következõ elemébe, ezért ezt ciklikus mûveletvégzéssel fogjuk elvégezni. Tehát a ciklusban azonos utasításokat többször hajtunk végre. Mivel tudtuk, hogy a tömbben tíz elem található, ezért tudtuk az ismétlések számát, tehát a feladatot ismert számszor kell végrehajtanunk. A megoldáshoz számláló ciklust kell alkalmazni.

A következõ mintaprogramban egy tömböt töltünk fel egész számokkal, majd a tömb egyes elemeit visszaíratjuk. Figyelje meg, hogy hogyan változtatjuk a tömbindexet és ennek segítségével hogyan érjük el, hogy a soron következõ tömbelem töltõdjék fel.

Deklarálási példa:

Type

T_tomb= array[1..10] of integer;

Var Tomb : T_tomb;

A fenti példa az eddigiektõl hosszabb úton jut el a var tomb:array[1..10] of integer deklarációig, de a késõbbiek miatt elegánsabb az útja.

Ez a program az egydimenziós tömb ( késõbbiekben vektor ) feldolgozását mutatja be.

Feladat: töltsünk fel egy 10 elemû vektort, majd elemeit írassuk vissza

program tomb_muvelet;

Const N=10;

Type típus definiálás

tombtipus=array[1..N] of integer; definiálunk egy N elemû tömböt, mely integer típusú elemeket tartalmaz

var Változó deklarálás

tomb:tombtipus; A tomb tombtípus típusú változó lesz

i:byte; az i byte típusú változó a ciklusváltozó szerepét fogja ellátni

valt :integer;

begin FÕPROGRAM kezdete

mivel a tömbünk 10 elemet tartalmaz

ezért 10 számot kell beolvasni

for i:=1 to N do ezt valósítjuk meg FOR ciklussal

begin ciklus belsõ blokkja

ReadLn(valt);

tomb[i]:=valt; Minden egyes tömbelem beolvasása

Mivel a ciklusváltozó értéke sorra

1,2,3,..10 értéket veszi fel biztosítva,

hogy mindig a megfelelõ tömbelem kapjon

értéket

end;

for i:=1 to 10 do A ciklus u.a. a feladatot látja el mint

begin az elõzõekben azzal a különbséggel, hogy

WriteLn(tomb[i]); a megfelelõ tömbelem kiíratását vezérli

end;

ReadLn;

end.

FELADAT: próbálja ki a programot valós számokból felépített tömbbel is!

Kiegészítõ anyag az elágazásokhoz a CASE szerkezet.

Ez a program a többágú kiválasztást mutatja be. A feladat beolvasni egy karaktert és eldönteni, hogy az szám betû vagy speciális karakter

program case_elagazas;

uses crt; Mivel használjuk a READKEY fv-t, amely egy billentyût olvas,

meg kell nyitnunk a crt unitot amely tartalmazza ezt a fv-t

var DEKLARACIOK

ch:char; Karakter típusú változó ebben tároljuk a readkey által visszaadott eredményt

begin FÕPROGRAM

ch:=readkey; Egy karakter beolvasása

case ch of Többágú kiválasztás a ch tartalma alapján

'0'..'9':write('SZAM'); CH 0 es 9 közötti karakter írd ki....

'a'..'z':write('KISBETU'); CH a es z közötti karakter írd ki.... 'A'..'Z':write('NAGYBETU'); CH A es Z közötti karakter írd ki....

else Egyébként

write('KULONLEGES KARAKTER'); írd ki ...

end; A többágú kiválasztás vége

ReadLn; Enterre vár

end. FÕPROGRAM VÉGE

elválik :P

WebGeneral Portálmotorral

Menü

Oszd meg!

PDF-ből szöveg

Közösség

Belépés

A tömb adatszerkezet

A tömb adatszerkezet