Tárolók

Tömb

A tömb olyan adatszerkezet, amely több azonos típusú változót tárolhat. Egy tömb deklarálásához meg kell adnunk ,hogy milyen típusú elemeket fogunk benne tárolni. Ha bármilyen típusú elemeket szeretnénk tárolni benne, akkor a tömböt object-ként kell deklarálni.

típus[] elnevezés;

• példa típus-ok:

  • int[] egeszSzam = new int[x];

  • string[] karakterLanc = new string[x];

  • bool[] logikai = new bool[x];

  • ...
• Tömbök egydimenziósak és többdimenziósak is lehetnek. Ezeket a deklarálások során kell megadni.

Tulajdonságok	Leírás
IsFixedLength	Megkapja vagy beállítja azt a logikai értéket (bool), amely jelzi, hogy a tömb fix méretű-e.
IsReadOnly	Megkapja vagy beállítja azt a logikai értéket (bool), amely jelzi, hogy a tömb csak olvasható-e.
Length	A tömb összes dimenziójának összes elemének számát ("tömb méretét") kapja meg vagy állítja be.
MaxLength	A tömbben található elemek maximális számát kapja meg vagy állítja be.
Rank	Az dimenziók számát kapja meg vagy állítja be. Például egy egydimenziós tömb 1, egy kétdimenziós tömb 2....

Important

Az indexelés 0-val kezdődik. Ez azt jelenti, hogy a tömb első eleme a 0. indexen lesz, nem pedig az 1-ön.

Egydimenziós tömb:

Az egydimenziós tömb olyan adatszerkezet ,amelynek elemei egymás után kerülnek tárolásra a memóriában. Ezt úgy lehet elképzelni, mint egy listát (Array), ahol minden elemnek van egy egyedi indexe, amely nullával kezdődik.

Deklarálás:

int[] 1DTomb = new int[14];

Példa: Osztálynévsor

string[] nevsor = new string[12];

Minden egyes gyerek nevéhez tartozik egy szám (index), ezzel tudjuk őket azonosítani.
Jelen esetben az osztály 12 fős (string[12].
Mivel a tömb indexelése 0-val kezdődik, ezért a kódunkban át kell alakítani a felsorolást, ha ki szeretnénk iratni a névsort.

//Tömb:

nevsor[0] = "Antal Pista";
nevsor[1] = "Dénes Albert";
nevsor[2] = "Nagy Lajos";
nevsor[n+1] = "....";

for(int i=0;i<nevsor.length;i++){
 Console.WriteLine("{0}. {1}", i+1 , nevsor[i])
}

Többdimenziós/mátrix tömb:

A többdimenziós tömbök, egynél több dimenzióval rendelkező tömbök. Egy kétdimenziós tömb például egy sorokkal és oszlopokkal rendelkező táblázatként jeleníthető meg. Úgy is mondhatjuk, hogy ez a "tömbök tömbje"

Deklarálás:

int[,] tobbDimenzios = new int[sor][oszlop];

Példa: Tic-Tac-Toe

string[,] palya = new string[3,3]{
  { "", "", "" },
  { "", "", "" },
  { "", "", "" }
};

Tic-Tac-Toe játéktere 3 oszlopból és 3 sorból áll. Minden olyan kombinációt meg kell vizsgálnunk, amivel a játékos nyerhet. Ezt úgy valósítjuk meg, hogy a tömb adott indexein lévő elemeket összevetjük a velük (függölegesen/vízszintesen/átlósan) szomszédos elemekkel.

"Koordináták" szerint:
   |  0 | 1 | 2
0  |{ 0,  1,  2 } -> palya[0, 0], palya[0, 1], palya[0, 2]);
1  |{ 0,  1,  2 } -> palya[1, 0], palya[1, 1], palya[1, 2]);
2  |{ 0,  1,  2 } -> palya[2, 0], palya[2, 1], palya[2, 2]);

A kód szerint:
   |   0  | 1  | 2
0  |{ "O", "O", "O" }
1  |{ "O", "X", "X" }
2  |{ "X", "O", "X" }

A fenti ábrán az "O" játékos nyert, ugyanis az első sorban 3 "O"-t tett le egymás mellé, ezt az alábbi módon tudjuk leellenőrizni:

if (palya[0, 0] == "O" && (palya[0, 0] == palya[0, 1]) && (palya[0, 1] == palya[0, 2]))
  {
  //Console.WriteLine("O nyert");
  }

Tömbök feltöltése:

A tömb random számokkal való feltöltése for ciklussal:

Random rnd = new Random();

for (int i=0; i<tomb.Length; i++){
  tomb[i] = rnd.Next(); 
}

A tömb a felhasználó megadott adatokkal feltöltése for ciklussal:

for (int i=0; i<tomb.Length; i++){                
  Console.WriteLine("Adja meg a/az {0}. elemet: ", i);
  tomb[i] = Console.ReadLine();
}

Tömb elemeinek kiiratása:

Tömb elemeinek kiiratása foreach-al:

foreach(var elem in tömb)
{
 Console.WriteLine(elem.ToString());
}

Tömb elemeinek kiiratása for ciklussal:

for (int i=0; i<tomb.Length; i++){                
  Console.WriteLine(tomb[i].ToString());          
}

Tömbön használt függvények

• Sort(tomb)

  Ez a függvény, a tömb elemeit növekvő sorrendbe rendezi.

  int[] tomb = { 3, 1, 4, 2 };
  Array.Sort(tomb);

  Eredmény:

  [1,2,3,4]

Note

Ha string-et (karakter sorozatot) szeretnénk sort() függvénnyel sorba rendezni, akkor az, az ABC-nek megfelelően helyezi sorba.

• Reverse(tomb)

  Ez a függvény, megfordítja a tömb elemeinek sorrendjét.

  int[] tomb = { 1, 2, 3, 4 };
  Array.Reverse(numbers);

  Eredmény:

  [4,3,2,1]

• IndexOf(tomb, int)

  Ez a függvény, egy adott értéket keres a tömbben, és az érték (első előfordulásának) indexét adja vissza.

   int[] tomb = { 1, 2, 3, 4 };
   int index = Array.IndexOf(numbers, 3);

  Eredmény:

  Index: 2

Important

Ha az értéket nem találja, akkor -1-et ad vissza.

• Clear(tomb)

  Ez a függvény, a tömb összes elemét egy alapértelmezett értékre állítja.

  int[] tomb = { 1, 2, 3, 4 };
  Array.Clear(tomb, 0, numbers.Length);

  Eredmény:

  [0,0,0,0]

• Resize(tomb, int)

  Ez a függvény megváltoztatja a tömb méretét, akár elemek hozzáadásával, akár eltávolításával.

  int[] tomb = { 1, 2, 3, 4 };
  Array.Resize(ref tomb, 6);

  Eredmény:

  [1,2,3,4,0,0]

Lista

Az index alapján elérhető objektumok szabványosított listáját valósítja meg. Metódusokat biztosít a listák kereséséhez, rendezéséhez és manipulálásához/módosításához.

A C# lista egy általános osztály, és a eléréséhez ezt a névteret kell importálnia a projektjébe.

using System.Collections.Generic

Tulajdonságok	Leírás
Capacity	Megkapja vagy beállítja a belső adatszerkezetben átméretezés nélkül tárolható elemek teljes számát.
Count	Megkapja vagy beállítja a listában található elemek számát.
Item[Int]	Megkapja vagy beállítja a megadott indexen lévő elemet.

Deklarálás

List<int> egeszSzam = new List<int>();

List<string> karakterLanc = new List<string>(2); // <- így megadjuk a 'capacity'-t

string[] tomb = { "elem" };
List<string> tombbolLista = new List<string>(tomb);

Lista feltöltése

Többféle módon tölthetjük fel a listánkat elemekkel:

Add(elem)

Ezzel a függvénnyel egyesével tudjuk, hozzáadni az elemeket a listánkhoz.

List<string> lista = new List<string>();
lista.Add("Ez egy elem lesz");
lista.Add("Ez egy másik elem");

Eredmény:

{"Ez egy elem lesz", "Ez egy másik elem"}

AddRange(elemek-csoportja)

Az AddRange() függvény egy adott elem csoportot (/vagy tömb elemeit) ad hozzá a listánkhoz

int[] tomb = {1,2,3,4};
List<int> lista = new List<int>();
lista.AddRange(tomb);

Eredmény:

{1,2,3,4}

vagy

int[] tomb = {1,2,3,4};
List<int> lista = new List<int>();
tomb.ForEach(elem => lista.Add(elem));

Eredmény:

{1,2,3,4}

Important

Ha tömbből szeretnénk listába áthelyezni az elemeket, akkor azonos adattípusú kell legyen a két tároló. (list , int[])

Insert(id, elem)

Az Insert() függvénnyel egy listába, index alapján tudunk beszúrni/módosítani elemet

int[] tomb = {1,2,3,4};
List<int> lista = new List<int>();
tomb.ForEach(elem => lista.Add(elem));
/*
lista:{
1, id: 0
2, id: 1
3, id: 2
4  id: 3
}
*/
lista.Insert(1, 4)

Eredmény:

{1,4,3,4}

Listán használt függvények:

• LastIndexOf()

Visszaadja egy érték utolsó előfordulásának nulla alapú indexét a listában vagy annak egy részében.

• Remove(T)

Eltávolítja egy adott objektum első előfordulását a listából.

• RemoveAll()

Eltávolítja az összes olyan elemet, amely megfelel a meghatározott feltételeknek.

RemoveAt(Int)

Eltávolítja a lista megadott indexén lévő elemet.

• RemoveRange(Int, Int)

Eltávolít egy elemtartományt a listából.

• Reverse()

Megfordítja a lista elemeinek vagy egy részének sorrendjét.

• Sort()

A lista elemeit vagy azok egy részét rendezi.

• ToArray()

A lista elemeit egy új tömbbe másolja.

• ToString()

Visszaad egy stringet, amely az aktuális objektumot reprezentálja.