Bevezetés a 2-D tömbökbe a C-ben
Egy tömb egy elemcsoport, amelynek azonos (homogén) adattípusa van. Származtatott adattípusnak is hívják. Ha egy primitív adattípust tekintünk, és az alábbiak szerint adunk hozzá értéket,
És most, ha új értéket akarunk tárolni az a változóba, az új érték felváltja a régi értéket. Egy primitív változóval egyszerre csak egy értéket tárolhatunk, több értéket sem tudunk tárolni.
Ahhoz, hogy egynél több elem tárolódjon egy változóban, például a hallgatói pontok, a munkavállalói azonosítók, a nagy számú adatszámmal rendelkező mobilszámok, 100-as egyedi változókat kell létrehoznunk, ami nagyon összetett feladat. Ezért vezették be a tömbök koncepcióját.
Fogalmak a 2-D tömbökben a C-ben
A tömböket definiálhatjuk
- Egydimenziós
- Dupla dimenziós
És így tovább, egészen az igényig alapuló N-dimenziós dimenzióig. De itt a 2-D tömbökkel foglalkozunk. Ahogy a neve is sugallja, a 2-D tömbök olyan adatok mátrix ábrázolása lehetnek, amelyeket egy relációs adatbázishoz hasonló adatszerkezet megvalósításához hoztak létre, és táblázatos formában tárolhatók. Ez megkönnyíti a nagy mennyiségű adat tárolását, amelyet a követelmény alapján tetszőleges számú funkcióhoz továbbíthatunk. Ezen tömbök adatai a sor- és oszlop-azonosítókon keresztül érhetők el.
Hogyan lehet meghatározni és végrehajtani őket? Hol használhatjuk őket? Ha tovább megyünk, értjük ezeket a fogalmakat.
A C-ben a dimenziós tömbök a következők szerint deklarálhatók:
Szintaxis
Tehát ugyanúgy deklarálhatjuk a 2-D tömböt:
A fenti ábrázolás jelentése a következőképpen érthető:
- A b változóhoz hozzárendelt memória int típusú.
- Az adatok 2 sor és 3 oszlop formájában vannak ábrázolva.
A tömbön belüli adatok a fenti ábrán keresztül érhetők el. Kétdimenziós tömbök ábrázolásánál az első szögletes zárójel a sorok számát, a második az oszlopok számát jelöli. Az első elem tömbének index-ábrázolása mindig nullával kezdődik, és az 1-es mérettel végződik. Array változó (itt b) mindig megtartja a memóriablokk alapcímét, és belső mutató változónak nevezzük.
Tehát például, ha a sorok száma 3, akkor a sorokhoz való adatok eléréséhez az index ábrázolása 0, 1 és 2 lesz. Ugyanez a logika vonatkozik az oszlopindexekre is. A fenti ábrázoláshoz a 2. sor 3. oszlopának adatainak beolvasásához b (1) (2) pontot használhatunk.
A tömbök inicializálása
Kétféle módszer van az értékek inicializálására a C értéken. A módszerek csak szintaktikailag különböznek egymástól.
Az alábbiakban egy.
Az inicializálás másik módja a következő:
Általában az inicializálás első módszerét részesítjük előnyben, mivel világosan megértjük és megjeleníthetjük a C-ben lévő 2-D tömbök sorát és oszlopát.
Az alábbiakban látható az elemek képi ábrázolása és címe a b tömb számára.
A tömb elemeit általában egymást követő memória helyeken tárolják az elemek adattípusa alapján.
Elemek behelyezése a kétdimenziós tömbökbe
Az elemek beillesztéséhez a 2-D tömbökbe az adatokat mind sorokba, mind oszlopokba be kell illeszteni. Tehát erre a hurkok koncepcióját használjuk. Az adatok tömbben történő inicializálásának a fenti folyamatában előre meghatároztuk az értékeket.
Itt az elemeket a felhasználó a követelményeknek megfelelően dinamikusan beillesztheti. Az alábbiakban található egy példakód az elemek beillesztésére.
#include
int main()
(
int b(2)(3);
int i, j, num;
printf("Enter elements into 2-D array: ");
for(i=0;i<2;i++)
(
for(j=0;j<3;j++)
(
scanf("%d", &b(i)(j));
)
)
)
Amint azt a kód megfigyelte:
- Először a tömb változóját és a tömb méretét deklaráljuk a sorok és oszlopok számával.
- Ezután két változót deklarálunk a tömb elemeinek iterálására.
- Ezután hurkokhoz használják. A hurok külső része a sorok iterációja, a belső hurok az oszlopok számára.
- A Scanf függvény az adatok beolvasásához használja az adatokat, majd behelyezett értéket i és j helyzetébe helyezzük.
A fenti példában az adatokat egy 2 sorból és 3 oszlopból álló mátrixba illesztettük. A következők kimenete az alábbiak szerint kapható:
Mivel a printf funkciót nem használtuk a kimenet megjelenítéséhez, az írt program csak a felhasználó által megadott értékeket olvasta. A nyomtatási funkció megírása után (hurkok használatával) a kimenet a következőképpen jelenik meg:
Frissítse az elemeket a kétdimenziós tömbökben
A tömb elemeinek frissítése elvégezhető vagy azzal, hogy meghatározza a cserélni kívánt elemet, vagy meghatározza egy helyet, ahol a csere megtörténik. A frissítéshez általában az alábbi részletekre van szükségünk.
- Egy tömb elemei
- Pozíció / elem, ahova be kell illeszteni
- A beillesztendő érték.
A tömb adatainak frissítéséhez az elem részletein keresztül először meg kell keresnünk az elemet a tömbben, meg kell értenünk annak helyét, majd a régi elemet új elemekkel kell cserélnünk.
Az alábbiakban két példát mutatunk be a 2-D tömb elemének frissítésére.
Először olvassa el egy példát, ahol a frissítendő elem helyzete már ismert.
#include
int main()
(
int b(2)(3);
int i, j, num;
printf("Enter elements into 2-D array: ");
for(i=0;i<2;i++)
(
for(j=0;j<3;j++)
(
scanf("%d", &b(i)(j));
)
)
b(0)(2)=10;
for(i=0;i<2;i++)
(
for(j=0;j<3;j++)
(
printf("\t%d", b(i)(j));
)
printf("\n");
)
return 0;
)
A fenti programban az első sorban és a harmadik oszlopban az elemet választják ki, és az ezen a helyen lévő adatok értéke frissült.
A fenti eredmény a következő:
A második példában bemutatjuk, hogy az elem pozícióját miként lehet dinamikusan figyelembe venni a felhasználó által megadott értékként, és frissítjük az elem értékét az adott pozícióban.
#include
int main()
(
int b(2)(3);
int i, j, num;
printf("Enter elements into 2-D array: ");
for(i=0;i<2;i++)
(
for(j=0;j<3;j++)
(
scanf("%d", &b(i)(j));
)
)
printf("Enter the value of row and coulmn number :");
scanf("%d %d", &i, &j);
printf("Enter the number you want to update with: ");
scanf("%d", &num);
b(i)(j)=num;
for(i=0;i<2;i++)
(
for(j=0;j<3;j++)
(
printf("\t%d", b(i)(j));
)
printf("\n");
)
return 0;
)
Itt a scanf függvényt olvastam be a felhasználó által megadott értéket az elem pozíciójára, a sor- és oszlopszám alapján.
A kimenet a következő:
Gyakorlatként megpróbálhat egy programot írni a mátrix teljes sorának a felhasználó által megadott értékekkel történő frissítésével?
Most, amint tudjuk, a kétdimenziós tömbben a tömb méretét az elején deklaráljuk. Tisztában vagyunk a tömb méretével, de mi van, ha a felhasználó véletlenszerű sort és oszlopot ad meg a tömb méretén kívül?
Figyelem: mivel nem írtunk semmilyen if / condition feltételt vagy try / catch blokkot, a mátrix kimenete nem változik. Azonban a fenti feltételekkel írhatjuk a kódot, hogy ilyen esetekben hibákat jelenítsünk meg.
Elemek törlése a kétdimenziós tömbökben
A tömbön belüli adatok beillesztésének és frissítésének fogalma után lássuk, hogyan lehet egy sort törölni a tömbből.
Egyszerű formátumban írtunk programot, hogy a kétdimenziós tömb különböző műveleteinek fogalma könnyen érthető legyen.
#include
int main()
(
int b(2)(3), i, j, num, x;
printf("Enter elements into 2-D array: ");
for(i=0;i<2;i++)
(
for(j=0;j<3;j++)
(
scanf("%d", &b(i)(j));
)
)
printf("Enter the value of row number :");
scanf("%d", &x);
for(i=0;i<2;i++)
(
if(i==x)
(
for(j=0;j<3;j++)
(
if((i+1)<2)
(
printf("\t%d", b(i+1)(j));
)
)
i++;)
else
(
for(j=0;j<3;j++)
(
printf("\t%d", b(i)(j));
)
)
printf("\n");
)
)
A követett lépések a következők:
- Dinamikusan vette át a tömb értékeit
- Megkérte a felhasználót, hogy adja meg a törlendő sor számát (indexét).
- A hurok iterációjához összehasonlítjuk, hogy a sor száma és a felhasználói bemeneti szám megegyezik-e.
- Ha egyeznek, és ha a sor száma kisebb, mint egy tömb mérete, akkor a következő sort nyomtatjuk ki. Máskülönben a sort úgy nyomtatjuk, ahogy van.
A kimenet a következő:
Mi van, ha a sor számát a tömb határán kívül adom meg?
A teljes tömb kinyomtatásával nem fogja megtalálni a sort a program törlésére és kilépésére.
Mint már ismert, dinamikusan deklarálhatjuk a sor- és oszlopszám értékeit is, és ennek megfelelően megírhatjuk a programot.
Nem tűnik egyszerűnek és könnyen megtanulhatónak?
Gyakorlatként megpróbálhatja törölni egy adott elemet a kétdimenziós tömbből?
Következtetés
Ebben a szakaszban megtanultuk az alapvető műveleteket a 2-dimenziós tömbökön. Ezek a kétdimenziós tömbök valós időben hasznosak a mátrixműveletekkel és sok matematikai számítással.
A tömbök akár naptárak, akár a parkoló elhelyezésének megjelenítésére is felhasználhatók, sakkjátékot is felvehetünk.
Sok más adatszerkezetnek, például a kapcsolt listáknak, a sornak, a grafikonoknak és a fáknak a kétdimenziós tömbök ezt a koncepcióját kell használniuk alapvető követelményként a különböző elemek helyének tárolására és elérésére. Próbálja meg megoldani a 2d tömb alapműveleteit, és érezd jól magad a C tanulásban.
Ajánlott cikkek
Ez egy útmutató a 2-D tömbökhez C-ben. Itt tárgyaljuk a Bevezetést, a tömbök inicializálását, az elemek beillesztését, frissítését, törlését a 2-D tömbökben. A következő cikkeket is megnézheti további információkért -
- Tömbök R-ben
- A tömb előnyei
- Tömbök C ++-ban
- Tömbök a JavaScript-ben
- Példák a C # tömbjeire
- Tömbök a PHP-ben