A tömb az az adattípus, amikor egy adott típusú változóból egy sorozatot, vagy vektort, mátrixot készítünk. A tömb egy összetett homogén adatstruktúra, melynek tetszőleges, de előre meghatározott számú eleme van. Az elemek típusa azonos. A tömb lehet egy vagy többdimenziós, a dimenzió száma nem korlátozott. Az egydimenziós tömböket vektoroknak hívjuk.
Általános szintaxis: Típus[] tömbnév = new Típus[hossz];
public static void Main() { int[] szamok = new int[5] {1, 3, 6, 3, 2}; // létrehozunk egy tömböt és utána megadjuk az elemeit int[] szamok2; szamok2 = new int[] {3, 6, 1, 6, 8, 3}; // az elemek számából magától kiszámolja, hogy hány elemű... string[] karakterLanc = new string[3] {"egy", "ketto", "harom"}; Console.WriteLine("A szamok tömb 5. elemének értéke: {0}", szamok[4]); Console.WriteLine("A szamok2 tömb 3. elemének értéke: {0}", szamok2[2]); // a tömbök indexelése 0-tól kezdődik, így a 4. indexű eleme a tömb 5. eleme // ciklus, mely végig halad a tömb elemein for( int i = 0; i < karakterLanc.Length; i++ ) Console.WriteLine(karakterLanc[i]); Console.ReadKey(); }
A tömbök elemeinek sorszámozása 0-tól kezdődik, az utolsó elem száma pedig elemek száma-1.
Tehát a szamok tömb elemei: 0. elem az 5, az utolsó elem pedig a szamok[4] amelynek értéke 2
Fontos megjegyezni, hogy a tömb statikus. Ha egyszer beállítottuk a méretét, nem lehet megváltoztatni. Azt viszont gond nélkül megtehetjük, hogy újra lefoglaljuk neki a helyet, de ekkor a benne tárolt adatok elvesznek (kivéve ha lementettük őket).
Tömb elemeinek kiíratása:
- For ciklussal:
for (int i=0; i<szamok.Length;i++) { Console.WriteLine("A szamok tömb{0}.-ik eleme: {1}", i, szamok[i]); }
- Foreach ciklussal
foreach (int i in szamok) { Console.WriteLine("A szamok tömb elemei: {0}", i); }
Példa 1
Nézzünk egy példa tömböt. Töltsünk fel egy 10 elemű tömböt 0-100 közötti véletlen számokkal! Rendezzük növekvő sorrendbe!
A tömb elemeinek növekvő sorba rendezése az Array.Sort(tömbneve) metódussal történeik. Ha szeretnénk fordított sorrendben kiíratni őket, akkor elöször rendezzük növekvőbe, majd az Array.Reverse(tömbneve) metódussal megkapjuk a fordított sorrendet!
int[] veletlenszomok = new int[10]; //10 elemből áll Random elem = new Random(); for (int i = 0; i < veletlenszomok.Length; i++) { veletlenszomok[i] = elem.Next(0, 100); //veletlenszám tárolása } foreach (int item in veletlenszomok)//tömb elemeinek kiírása foreach ciklussal { Console.Write(" {0}", item);//szóköz az elemek között } Console.WriteLine(); Console.WriteLine("Rendezve:"); Array.Sort(veletlenszomok); foreach (int item in veletlenszomok) { Console.Write(" {0}", item); } Console.ReadKey();
Példa 2:
Nézzünk egy másik példát. Állítsunk elő 50 db egész számot -100 és 100 között! Írassuk ki őket 5 sorba! Írjuk ki a pozitív páros számokat is! Ha nincs egy sem, akkor ezt: „Nincs pozitív páros szám.” Itt a feladat második része miatt használunk tömböt, hogy meg tudjuk vizsgálni, van-e közöttük pozitív páros szám.
{ int[] tomb = new int[50]; //50 elemű tömb int i = 0; bool van = false; //ez jelzi, találtunk-e + egész számot Random vsz = new Random(); Console.WriteLine("A 50 db szám:"); Console.WriteLine(); for (i=0; i<=49; i++) { tomb[i] = vsz.Next(-100,101); if (i % 10 == 9) //mivel 0-tól számozza a tömb elemeit, a 10. elem a 9-es tömbelem Console.WriteLine("{0, 6}",tomb[i]); else Console.Write("{0, 6}", tomb[i]); } Console.WriteLine(); for (i=0; i<=49; i++) //végigmegyünk mind az 50 elemen { if (tomb[i]%2==0 && tomb[i]>0) { if (van == false) Console.WriteLine("A pozitív páros számaink: "); Console.Write("{0,4}", tomb[i]); van = true; } } if (van == false) //ha egyet sem talált Console.WriteLine("A számok között nincs pozitív páros szám!"); Console.ReadKey(); }
Két vagy többdimenziós tömbök
Nézzünk egy 2 dimenziós tömböt:
int [ , ] szamok2d = new int[ 1 , 2 ];
string [ , ] szoveg = new string [10, 9];
Vesszővel választjuk el a dimenziók számát. A többdimenziós tömbök elemeinek feltöltését egymásba ágyazott ciklusokkal valósítjuk meg.
Hozzunk létre egy 3×3-as „mátrixot”, töltsük fel véletlen számokkal. A többdimenziós tömböknél a tömb nagyságát a Tömb.GetLength(dimenzio száma) függvénnyel kérdezzük le. A tömb elemeinek feltöltéséhez több egymásba ágyazott ciklust használunk.
using System;
class Program
{
static public void Main()
{
int[,] matrix = new int[3, 3];
Random r = new Random();
for (int i = 0; i < matrix.GetLength(0); ++i)// sorok
{
for (int j = 0; j < matrix.GetLength(1); ++j)// oszlopok
{
matrix[i, j] = r.Next(1,20);
Console.Write(matrix[i, j]+"\t");
}
Console.WriteLine();
}
Console.ReadKey();
}
}
A következő példában egy 3×3-mas tömböt töltünk fel „kézzel”, majd kiíratjuk a tömb elemeit 3×3-as formában.
namespace matrix_feltolt
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Tömb elemeinek feltöltése...");
int[,] tomb = new int[3, 3];
int i, j;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
{
Console.Write("Kérem a {0}. sor {1}. oszlop elemét: ", i, j);
tomb[i, j] = int.Parse(Console.ReadLine());
}
Console.WriteLine("Az eredeti mátrix: ");
for (i = 0; i < 3; i++)
{
for (j = 0; j < 3; j++)
Console.Write("{0} ", tomb[i, j]);
Console.WriteLine();
}
}
}
}
Egy halgazdaság próbafogást rendez, 5 halat fognak ki, és vizsgálják a súlyukat és méretüket.
Az egyszerűség kedvéért dkg és cm mértékegységet használnak.
A program feladatai:mennyi a halak összsúlya?
– Mennyi a legkisebb súly? Milyen fajta hal?
– Mennyi a legnagyobb súly? Milyen fajta hal?
using System;
namespace ConsoleApp3
{
class Program
{
static void Main(string[] args)
{//hal fajtája, tömege, hossza 5sor 3 oszlop
string[,] halak = new string[5, 3] {
{"csuka","100","40"},
{"ponty","510","75"},
{"harcsa","2250","88"},
{"ponty","2450","62"},
{"törpeharcsa","25","24"},
};
/*
Console.WriteLine("{0} hal tömege: {1}dkg hossza: {2}cm",halak[0,0], halak[0,1], halak[0,2]);
Console.WriteLine("{0} hal tömege: {1}dkg hossza: {2}cm", halak[1, 0], halak[1, 1], halak[1, 2]);
Console.WriteLine("{0} hal tömege: {1}dkg hossza: {2}cm", halak[2, 0], halak[2, 1], halak[2, 2]);
*/
//Halak adatai
for (int i = 0; i < halak.GetLength(0); i++)
{
for (int j = 0; j < halak.GetLength(1); j++)
{ Console.Write("{0} ", halak[i, j]); }
Console.WriteLine();
}
//A halak össztömege
//Legnehezebb hal tömegének mentése
int maxsuly = 0; int minsuly = 1000;
int ossztomeg = 0; string maxsuly_index=""; string minsuly_index="";
for (int i = 0; i < halak.GetLength(0); i++)
{
ossztomeg += Convert.ToInt32(halak[i, 1]);
if (Convert.ToInt32(halak[i, 1]) > maxsuly)
{
maxsuly = Convert.ToInt32(halak[i, 1]);
maxsuly_index = halak[i, 0];
}
if (Convert.ToInt32(halak[i, 1]) < minsuly)
{
minsuly = Convert.ToInt32(halak[i, 1]);
minsuly_index = halak[i, 0];
}
}
Console.WriteLine("össztömeg: {0} dkg",ossztomeg);
Console.WriteLine("legnehezebb hal:{0} súlya: {1} dkg",maxsuly_index,maxsuly);
Console.WriteLine("legkönnyebb hal:{0} súlya: {1} dkg", minsuly_index, minsuly);
}
}
}
Feladat: Töltsünk fel egy 10 elemű tömböt 1-20 közötti véletlenszámokkal, úgy, hogy ne ismétlődjenek a tömbben a számok!
namespace tomb_ism_nelkul
{
class Program
{
static void Main(string[] args)
{
Random vsz = new Random();
int[] tomb= new int[10];
bool vanmar; //van-e már ilyen eleme a tömbnek?
int ujelem=0;
for (int i = 0; i <tomb.Length; i++)
{
do
{
vanmar = false;
ujelem = vsz.Next(1, 20);
for (int j = 0; j < tomb.Length; j++)
if (tomb[j] == ujelem)
{
vanmar = true;
}
}
while (vanmar);
tomb[i] = ujelem;
}
Console.WriteLine();
foreach (int item in tomb)
Console.Write("{0} ",item);
}
}
}
Feladat: Készítsünk egy órarendet, amit egy kétdimenziós tömb tárol. Írassuk ki a tömb összes elemét! Írassuk ki csak 1db óra adatát! Az átláthatóbb adatok miatt a tömbbe beírtam a napok neveit is.
using System;
namespace szept20_orarend
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Órarend");
string[,] orarend = new string[5, 5]
{
{"hétfő","info","ének","rajz","úszás"},
{"kedd","úszás","tech","biosz","matek"},
{"szerda","magyar","földrajz","töri","info"},
{"csütörtök","ofő","magyar","matek","angol"},
{"péntek","matek","tesi","rajz","angol"}
};
//kiíratás, összes adat
for (int i = 0; i < orarend.GetLength(0); i++)
{
for (int j = 0; j < orarend.GetLength(1); j++)
{
Console.Write("{0} ", orarend[i, j]);
}
Console.WriteLine();
}
//kiíratás 1 adat, szerda 4.óra
//a tömbök elemei 0 sorszámmal kezdődnek!
Console.WriteLine("{0}",orarend[2,4]);
}
}
}
Feladat: Totó
Készítsünk programot, amely totó tippeket sorsol! A feladatot 2 tömb segítségével oldjuk meg! Az egyik tömb tartalmazza az elemeket (1,2,x) a másikat pedig töltsük fel véletlenszerűen az első tömb elemeivel!
using System;
namespace okt11_toto_tombok
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("TOTÓ tippek...");
string[] elemek = new string[3] {"1","2","x"};
string[] toto = new string[14];
Random vsz = new Random();
for (int i=0; i<toto.Length; i++)
{
toto[i] = elemek[vsz.Next(0, 3)];
}
foreach (string i in toto)
Console.Write("{0} ",i);
}
}
}
Feladat: min,max, megszámlálás, átlag gyakorlása.:
Állítson elő véletlenszerűen 40 számot a [-20, 20] tartományból!
- Állapítsa meg pozitív vagy negatív számból van-e több? A választ
és a darabszámokat írja a képernyőre! - Hányszor fordult elő a 7-es szám?
- Van-e a számok között 0?
- Adja meg a legkisebb szám indexét!
- Adja meg a negatív számok átlagát!
- Adja meg melyik a legkisebb, és a legnagyobb szám!
- Melyik volt a pozitív számok közül a legkisebb?
- Melyik volt a negatív számok közül a legnagyobb?
-Írassa ki növekvő sorrendben a számokat!
-Írassa ki csökkenő sorrendben a számokat!
using System;
namespace gyakorlas1018
{
class Program
{
static void Main(string[] args)
{
int min = 20; int max = -20; int poz = 0; int neg = 0; int hetes = 0;
int nulla = 0; int minind = 0; int minpoz = 20; int maxmin = -20;
int negativok = 0;
Random vsz = new Random();
int[] tomb = new int[40];
for (int i = 0; i < tomb.Length; i++)
{
tomb[i] = vsz.Next(-20, 21);
if (min > tomb[i]) { min = tomb[i]; minind = i; }
if (max < tomb[i]) max = tomb[i];
if (tomb[i] > 0) poz++;
if (tomb[i] < 0) { neg++; negativok = negativok + tomb[i]; }
if (tomb[i] == 7) hetes++;
if (tomb[i] == 0) nulla++;
if (tomb[i] > 0 && tomb[i] < minpoz) minpoz = tomb[i];
if (tomb[i] < 0 && tomb[i] > maxmin) maxmin = tomb[i];
}
int se = 0;
foreach (int i in tomb)
{
se++;
if (se % 20 == 0) Console.WriteLine();
Console.Write("{0} ", i);
}
Console.WriteLine("poz: {0} db negatív: {1} db", poz, neg);
if (poz > neg) Console.WriteLine("Több a pozitív szám!");
else if (neg > poz) Console.WriteLine("Több a negatív szám!");
else Console.WriteLine("Egyenlő");
if (hetes == 0) Console.WriteLine("Nincs hetes szám!");
else Console.WriteLine("Hetesek: {0} db", hetes);
if (nulla == 0) Console.WriteLine("Nincs 0!");
else Console.WriteLine("Nullák: {0} db", nulla);
Console.WriteLine("min: {0} indexe: {2},max: {1}", min, max, minind);
Console.WriteLine("Negatív számok átlaga: {0}",negativok/neg);
Console.WriteLine("Legkisebb pozitív szám: {0}", minpoz);
Console.WriteLine("Legnagyobb negatív szám: {0}", maxmin);
Array.Sort(tomb);
Console.WriteLine("Növekvő sorrendben:");
se = 0;
foreach (int i in tomb)
{
se++;
if (se % 20 == 0) Console.WriteLine();
Console.Write("{0} ", i);
}
Array.Reverse(tomb);
Console.WriteLine("Csökkenő sorrendben:");
se = 0;
foreach (int i in tomb)
{
se++;
if (se % 20 == 0) Console.WriteLine();
Console.Write("{0} ", i);
}
}
}
}