Tömb (adatszerkezet)

A Programozás Wiki wikiből
(Tömb szócikkből átirányítva)

A tömb talán a legtöbb programozási nyelv által támogatott adatszerkezet. Alapesetben a tömb azonos (bázis) típusú elemek egy sorozatának tekinthető, aminek elemeit a sorszámukon (index) keresztül érhetjük el. A tömb mérete lehet előre - fordítási időben - rögzített (statikus), vagy futás közben változtatható (dinamikus). Ha a tömbelemek nem egy, hanem több - egymástól független - index megadásával címezhetők meg, akkor több dimenziós tömbről beszélünk, amely végső soron tömbök tömbjeinek is felfogható. Az egydimenziós tömböt vektornak, a kétdimenziós tömböt mátrixnak is nevezik. A programozási nyelvekben a tömbindexelést (tömb elemére hivatkozást) általában szögletes - ritkábban gömbölyű - zárójellel jelölik.

Példák[szerkesztés]

C / C++[szerkesztés]

A számozás nullától kezdődik.

Példakód statikus tömbre:

   char arr[20]; 
   arr[17]='t';

Dinamikus tömb:

#include <vector>

// üres tömb
std::vector<int> a;
// az 'a' tömb végére szúr egy 5-ös értéket
a.push_back(5);
// most még egy 42-t is, most tehát (5,42) a tartalma.
a.push_back(42);
// törli a 0. indexű (első) elemet, az 5-öst
a.erase(a.begin()+0);
// a méret most 1, az egyetlen elem pedig a 42
std::cout << a.size() << " " << a[0] << std::endl;

// 12 elemű tömb, minden eleme 0
std::vector<int> b(12);
// 42 elemű tömb, minden eleme 1.7
std::vector<double> c(42,1.7);


Java[szerkesztés]

A számozás nullától kezdődik.

Példakód statikus tömbre:

   String [] arr = { "a", "b", "c" }; 
   arr[2] = arr[1].concat("d");


JavaScript[szerkesztés]

A számozás nullától kezdődik.

Példakód statikus tömbre:

   arr = new Array(1,'a',true);
   arr2 = [1,'a',true];


Pascal[szerkesztés]

A Pascal nyelv jellegzetessége, hogy a tömb indexe egy meghatározott sorszámozott (enumerated) típus értékkészletéből vehet fel értékeket. Szokványos esetekben ez egy egész érték, és az értékkészletet az egész számok egy tartományaként adjuk meg a deklaráció során. Ebből következik, hogy az index akár negatív is lehet!

Egyszerű példakód egy egész indexű statikus tömbre:

   Program tomb;
   Var t:array[1..5]Of Byte;{egy egydimenziós tömb deklarálása}
       i:Byte;{index változó}
   Begin
     {a tömb bejárása lehetséges cikluson keresztül,
      vagy közvetlenül.}
     {For ciklus segítségével}
     For i:=1 to 5 Do Begin
       Write(i,'. elem erteke: ');
       ReadLn(t[i]);
     End;
     {közvetlen hozzáférés}
     WriteLn('A tomb 4. eleme: ',t[4]);
   End.

A fentieknél azonban sokkal összetettebb, a feladathoz jobban illeszkedő, ám a hagyományos - csupán egész indexű - tömbszemlélettel nehezen érthető tömböket is definiálhatunk. A Pascal-ban ugyanis a tömb deklarációja során az indexet sorszámozott típusként(!) definiáljuk, vagy a sorszámozott típus nevét megadva, vagy pedig a típus leírását feltüntetve. Ez utóbbi kétféle lehet:

  • Intervallum (résztartomány) típus az egész illetve karakteres értékekből, pl.
   1..90 {lottószámok}
   -273..1000 {hőmérsékletek az abszolút 0 foktól}
   'A'..'Z' {ASCII nagybetűk}
  • Felsorolt típusok. Ezek a többi típussal nem kombinálható értékeket képviselnek, melyeket a fordító általában 0-tól kezdődő és egyesével növekvő értékként tárol a programban. Pl.
   (alma, korte, szilva) {gyümölcsök}
   (jan, feb, mar, apr, maj, jun, jul, aug, szep, okt, nov, dec) {hónapok}
   (HighLevel, LowLevel, ThreeState) {TTL logikai kimenetek állapotai}

A fentieket mind szerepeltethetjük a tömb deklarációjában a szögletes zárójelek között, vagy pedig neveket adhatunk nekik a Pascal típudefiníciós részében, és a típusleírás helyett ezt a nevet tüntejük fel. A Pascal valójában az egész típusokat (ShortInt, Byte, Integer, Word) és a karakteres (Char) típust résztartományként, illetve a Boolean típust felsoroltként előre definiálja az alábbi módokon (Turbo Pascal System Unit-ja):

   type
     ShortInt = -128..127;
     Byte     = 0..255;
     Integer  = -32768..32767;
     Word     = 0..65535;
     Char     = #0..#255; {karakteres konstansok}
     Boolean  = (false, true);

Így az alábbi tömbdeklarációk mind megengedettek:

   type  {itt definiálunk néhány típust a fentiekből}
     Lotto    = 1..90;
     Honap    = (jan, feb, mar, apr, maj, jun, jul, aug, szep, okt, nov, dec);
     Kimenet  = (HighLevel, LowLevel, ThreeState);
   var  {változókat deklarálunk}
     HanyszorHuztak : array[Lotto] of Word;
     HaviAtlag      : array[Honap] of Real;
     Fajsuly        : array[-273..1000] of Double;
     Beirhato       : array['A'..'Z'] of Boolean;
     Impedance      : array[Kimenet] of Real;
     MikorErik      : array[(alma, korte, szilva)] of Honap;
     BUFF           : array[Byte] of Byte; {256 bájtos puffer}
     EBCDIC         : array[Char] of Byte; {kódkonverziós táblához}
     Magyarul       : array[Boolean] of String; {a logikai értékek magyar nevét tárolhatjuk benne}


PHP[szerkesztés]

Ha a PHP tömbjeit hagyományos tömbként használjuk, az index számozása nullától kezdődik.

Példakód:

   $arr = array("alpha","beta"); 
   echo $arr[1]; // beta

A PHP-ban azonban a tömbök rendezett leképzéseket valósítanak meg, ahol is kulcsokhoz értékeket rendelünk. A kulcsokat indexként adjuk meg, és egész értékek mellet bármilyen más adattípus, tehát string is lehet. Egy tömbön belül a tömbelemek értékei - a hagyományos tömböktől eltérően - szintén tetszőleges típusúak lehetnek, és a program futása során a típus is megváltozhat. Az egésztől eltérő kulcsokat már a tömb definíciójánál is megadjuk, és ha a tömbelem értékadásában eddig még nem szerepelt kulcs jelenik meg, akkor a tömb kiegészül egy új elemmel:

   $tomb = array("egy" => "Kati", "ketto" => "Pisti", "harom" => "Zoli"); 
   echo $tomb["harom"]; // Zoli
   $tomb["harom"]=15.6;
   $tomb["tiz"]=84.3;
   echo $tomb["harom"]; // 15.6
   echo $tomb["tiz"];   // 84.3

Python[szerkesztés]

A Python terminológia szerint list (lista), dict (asszociatív tömb, szótár) és tuple (módosíthatatlan lista) típusok léteznek. Mivel nem kell definiálni a bennük szereplő adatok típusát, ezért int,float,string típusokat felváltva írhatunk bele. Sőt még összetett típusokat (list, dict, tuple, complex) is.

Példakód:

   a = ["alpha","beta"] # üres lista is létrehozható, a = [] szintaktikával 
   a.append(45) # bővítés int típussal
   a.append(45.) # bővítés float típussal
   a.append("gamma") # bővítés stringgel

   b = {"alma":"piros", "banan":"sarga"} # asszociatív tömb, üresen deklarálva b = {} lenne
   a.append(b) # ekkor a lista N. eleme egy asszociatív tömb, ami tovább indexelhető a kulcsával.
   print b["banan"]
   print a[5]["banan"] # épp az 5. elemre esik az asszociatív tömb a fenti bővítések okán.
   a.append(21 + 43j) # komplex számot is tárolhatunk.

   print a.pop() # utolsó elem kiemelése és eltávolitása, stack
   print a.pop(0) # első elem kiemelése és eltávolítása, fifo

   c = (4, 5, "alma") # int,int,string értékeket felvevő módosíthatatlan lista, melynek neve tuple.

VB6/VBA[szerkesztés]

Példakód statikus tömbre:

   ' Option base 0 esetén
   Dim arr(2)
   arr(0) = 1
   arr(1) = Date
   arr(2) = "Helló világ"
   '
   Dim arr2(2 To 3)
   arr2(2) = 1
   arr2(3) = Time
   '
   Dim arr3
   arr3 = Array(1, Date, "Helló")
   '
   Dim arr4()
   ReDim arr4(1) 'Kitörölve a tartalmat, ha lenne
   arr4(0) = 0
   arr4(1) = Time
   ReDim Preserve arr4(2) ' Megtartva az eddigi tartalmat
   arr4(1) = "Helló"
   '
   Dim arr5(0)
   arr5(0) = Array(Date, Time)
   arr5(0)(0) = ""
   arr5(0)(1) = Now()


Go[szerkesztés]

A számozás nullától kezdődik.

  var arr [5]int

vagy

  arr := make([]int,5)

vagy

  arr := []int{1,2,3,4,5}

Nem szám típussal indexelt tömböket(map-ek), a 'map' nyelvi elem segítségével valósíthatunk meg.

  arr2 := map[string]int{"str1":1,"str2":2,"str3":3 ... }

egyszerű kiiratás:

  fmt.Printf("%v\n",arr)        // teljes tomb
  fmt.Printf("%v\n",arr[2:3])   // {3,4}

elemenkénti feldolgozás:

  for i,v := range arr2 {
    fmt.Println("%s: %d\n",i,v)
  }