2D tömb feltöltése és sorok elforgatása: a kód, ami megoldja a problémádat!

A digitális világban az adatok rendezése, tárolása és manipulálása alapvető feladat. Különösen igaz ez, amikor komplexebb struktúrákkal dolgozunk, mint például a kétdimenziós tömbök, amelyek egyfajta digitális táblázatként funkcionálnak. Gyakran találkozunk olyan kihívással, hogy egy ilyen mátrixot ne csak feltöltsünk, hanem annak tartalmát dinamikusan, akár a felhasználó igényei szerint módosítsuk. Az egyik legérdekesebb és leggyakoribb feladat ebből a szempontból a sorok elforgatása. De miért is olyan fontos ez, és hogyan valósíthatjuk meg a gyakorlatban? Merüljünk el benne!

Miért Pontosan a 2D Tömbök? A Háttér 📊

A kétdimenziós tömb, amit gyakran mátrixnak is nevezünk, sorokból és oszlopokból álló adatszerkezet. Képzelj el egy egyszerű Excel táblázatot vagy egy sakktáblát – pontosan ilyen elrendezésű adatok tárolására alkalmasak. Minden elemnek van egy egyedi „címe”, amelyet a sor- és oszlopindexe ad meg, például `tömb[sor][oszlop]`. Ez a fajta struktúra ideális számtalan alkalmazáshoz:

• Képfeldolgozás: Egy kép pixeljeit gyakran egy 2D tömbben tárolják, ahol minden elem a pixel színét vagy intenzitását jelöli.
• Játékfejlesztés: Játéktérképek (pl. stratégiai játékok, táblás játékok) modellezésére.
• Adatbázis-kezelés: Táblázatos adatok ideiglenes tárolására és feldolgozására.
• Matematikai műveletek: Mátrixszámításokhoz.

Alapvető fontosságú tehát, hogy ne csak deklarálni tudjuk őket, hanem hatékonyan fel is töltsük, és persze manipuláljuk, például elforgassuk a sorokat.

A Feltöltés Művészete: Dinamikus Adatbevitel ✍️

Egy 2D tömb feltöltésének több módja is van, a legegyszerűbbtől a legdinamikusabbig.

1. Statikus (hardkódolt) feltöltés

Ez a legegyszerűbb, de a legkevésbé rugalmas módszer. Ekkor közvetlenül a kódban adjuk meg az értékeket. Kiváló teszteléshez vagy fix adatokhoz.

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

2. Véletlenszerű feltöltés

Gyakran szükség van arra, hogy nagyméretű tömböket tesztadatokkal töltsünk fel. Erre a véletlenszerű számgenerálás a legalkalmasabb. Így gyorsan és hatékonyan kapunk adatokkal teli mátrixot.

import java.util.Random;

// ...
int rows = 3;
int cols = 4;
int[][] randomMatrix = new int[rows][cols];
Random rand = new Random();

for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        randomMatrix[i][j] = rand.nextInt(100); // 0 és 99 közötti számok
    }
}

3. Felhasználói bevitel (konzolról)

Ez a legdinamikusabb módszer, hiszen a felhasználó adhatja meg az adatokat. Képzelj el egy programot, ahol a felhasználó saját táblázatot akar létrehozni. Ez a megközelítés interaktív és rugalmas. Fontos itt kiemelni, hogy az adatbeviteli hibák kezelése kulcsfontosságú! Nem akarjuk, hogy a programunk összeomoljon, ha a felhasználó szám helyett szöveget ír be.

import java.util.Scanner;

// ...
Scanner scanner = new Scanner(System.in);
System.out.print("Adja meg a sorok számát: ");
int rows = scanner.nextInt();
System.out.print("Adja meg az oszlopok számát: ");
int cols = scanner.nextInt();

int[][] userMatrix = new int[rows][cols];

System.out.println("Kérem adja meg a mátrix elemeit:");
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
        System.out.printf("matrix[%d][%d]: ", i, j);
        userMatrix[i][j] = scanner.nextInt();
    }
}
// scanner.close(); // Fontos erőforrások felszabadítása

Mint láthatjuk, a feltöltés maga nem ördöngösség, csupán a megfelelő ciklusstruktúrára van szükség. A valódi kihívás akkor jön, amikor ezen adatok mozgatásáról van szó.

A Feladat Kulcsa: Sorok Elforgatása 🔄

Amikor sorok elforgatásáról beszélünk, két fő értelmezési mód létezik, és mindkettőre érdemes kitérni:

1. Egy sor elemeinek elforgatása: Ekkor minden egyes sorban az elemeket mozgatjuk egy adott irányba (balra vagy jobbra) egy bizonyos számú pozícióval. Mint amikor egy sorban ülő emberek helyet cserélnek, de a sor maga marad a helyén.
2. Teljes sorok ciklikus elforgatása: Ekkor magukat a sorokat mozgatjuk a mátrixon belül. Például az első sor a második helyére kerül, a második a harmadikra, és az utolsó sor "visszaugrik" az első helyére.

Mindkét forgatási mechanizmus rendkívül hasznos lehet, attól függően, milyen problémát oldunk meg. Nézzük meg az első, gyakrabban előforduló esetet részletesebben!

1. Egy Sor Elemeinek Elforgatása Jobbra (vagy Balra) ➡️⬅️

Képzelj el egy sort, mint egy tömböt: `[1, 2, 3, 4, 5]`. Ha ezt egy pozícióval jobbra akarjuk elforgatni, az 5-ösnek kellene az elejére kerülnie, és minden más elem egy pozícióval jobbra tolódna. Az eredmény: `[5, 1, 2, 3, 4]`.
Ennek legegyszerűbb algoritmusa egy lépésben a következő:

1. Mentsük el az utolsó elemet egy ideiglenes változóba.
2. Vegyük az utolsó előtti elemet, és mozgassuk az utolsó pozícióra.
3. Ismételjük ezt a folyamatot visszafelé haladva, amíg el nem érjük a második elemet, amit az első helyre mozgatunk.
4. Helyezzük az ideiglenes változóban tárolt eredeti utolsó elemet a tömb első pozíciójára.

Ha több pozícióval akarjuk elforgatni (mondjuk `k` lépéssel), akkor egyszerűen ismételjük meg a fenti eljárást `k` alkalommal, vagy használjunk egy okosabb, memóriahatékonyabb algoritmust, mint például egy ideiglenes segédtömbbe másolás, ahol a modulo operátor segít a pozíciók kiszámításában.

Most nézzük meg, hogyan integrálhatjuk ezt a 2D tömbünkbe!

A Kód, Ami Mindent Összefog: Elforgatás Java-ban

A következő Java kód egy átfogó példát mutat be, amely feltölti a 2D tömböt, majd elforgatja annak sorait egy adott számmal (itt jobbra), és ki is írja az eredményt. Felhasználói bevitelt használunk a rugalmasság érdekében.

import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.Random;
import java.util.Scanner;

public class MatrixOperations {

    /**
     * Kiírja a 2D tömb tartalmát a konzolra.
     * @param matrix A kiírandó 2D tömb.
     */
    public static void printMatrix(int[][] matrix) {
        if (matrix == null || matrix.length == 0) {
            System.out.println("A mátrix üres vagy null.");
            return;
        }
        for (int i = 0; i < matrix.length; i++) {
            System.out.println(Arrays.toString(matrix[i]));
        }
    }

    /**
     * Feltölti a 2D tömböt felhasználói bevitellel.
     * @param scanner A Scanner objektum a bemenet olvasásához.
     * @param rows A sorok száma.
     * @param cols Az oszlopok száma.
     * @return A feltöltött 2D tömb.
     */
    public static int[][] fillMatrixFromUserInput(Scanner scanner, int rows, int cols) {
        int[][] matrix = new int[rows][cols];
        System.out.println("Kérem adja meg a mátrix elemeit:");
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                while (true) {
                    System.out.printf("matrix[%d][%d]: ", i, j);
                    try {
                        matrix[i][j] = scanner.nextInt();
                        break; // Sikeres beolvasás esetén kilépünk a belső ciklusból
                    } catch (InputMismatchException e) {
                        System.err.println("Hibás bevitel! Kérem, egész számot adjon meg.");
                        scanner.next(); // Fontos: eldobja a hibás bemenetet
                    }
                }
            }
        }
        return matrix;
    }

    /**
     * Feltölti a 2D tömböt véletlenszerű számokkal.
     * @param rows A sorok száma.
     * @param cols Az oszlopok száma.
     * @param maxVal A véletlen számok maximális értéke (exkluzív).
     * @return A feltöltött 2D tömb.
     */
    public static int[][] fillMatrixRandomly(int rows, int cols, int maxVal) {
        int[][] matrix = new int[rows][cols];
        Random rand = new Random();
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                matrix[i][j] = rand.nextInt(maxVal);
            }
        }
        return matrix;
    }

    /**
     * Egyetlen sort forgat el jobbra 'k' lépéssel.
     * @param row A forgatandó tömb (sor).
     * @param k A forgatás mértéke (pozíciók száma).
     */
    public static void rotateRowRight(int[] row, int k) {
        if (row == null || row.length <= 1 || k == 0) {
            return; // Nincs mit forgatni
        }
        int n = row.length;
        k %= n; // A forgatás mértékét normalizáljuk a tömb méretéhez képest
        if (k < 0) k += n; // Negatív k kezelése (balra forgatásként)

        // Optimálisabb megoldás: segédtömb használata
        int[] temp = new int[n];
        for (int i = 0; i < n; i++) {
            temp[(i + k) % n] = row[i];
        }
        System.arraycopy(temp, 0, row, 0, n); // Visszamásoljuk az eredeti tömbbe
    }

    /**
     * Egyetlen sort forgat el balra 'k' lépéssel.
     * @param row A forgatandó tömb (sor).
     * @param k A forgatás mértéke (pozíciók száma).
     */
    public static void rotateRowLeft(int[] row, int k) {
        if (row == null || row.length <= 1 || k == 0) {
            return; // Nincs mit forgatni
        }
        int n = row.length;
        k %= n; // A forgatás mértékét normalizáljuk a tömb méretéhez képest
        if (k < 0) k += n; // Negatív k kezelése (jobbra forgatásként)

        // Egyszerűen hívjuk a jobbra forgatást (n-k) lépéssel
        rotateRowRight(row, n - k);
    }

    /**
     * Elforgatja a 2D tömb összes sorát jobbra 'k' lépéssel.
     * @param matrix A 2D tömb.
     * @param k A forgatás mértéke (pozíciók száma).
     */
    public static void rotateAllRowsRight(int[][] matrix, int k) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            System.out.println("A mátrix üres vagy null, nem forgatható.");
            return;
        }
        for (int i = 0; i < matrix.length; i++) {
            rotateRowRight(matrix[i], k);
        }
    }

    /**
     * Elforgatja a 2D tömb összes sorát balra 'k' lépéssel.
     * @param matrix A 2D tömb.
     * @param k A forgatás mértéke (pozíciók száma).
     */
    public static void rotateAllRowsLeft(int[][] matrix, int k) {
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            System.out.println("A mátrix üres vagy null, nem forgatható.");
            return;
        }
        for (int i = 0; i < matrix.length; i++) {
            rotateRowLeft(matrix[i], k);
        }
    }


    /**
     * Ciklikusan elforgatja a teljes 2D tömb sorait 'k' lépéssel lefelé.
     * Pl: 1. sor -> 2. sor, utolsó sor -> 1. sor.
     * @param matrix A forgatandó 2D tömb.
     * @param k A forgatás mértéke (pozíciók száma).
     */
    public static void rotateEntireMatrixRowsCyclically(int[][] matrix, int k) {
        if (matrix == null || matrix.length <= 1 || k == 0) {
            return;
        }
        int numRows = matrix.length;
        k %= numRows; // Normalizáljuk a forgatás mértékét
        if (k < 0) k += numRows; // Negatív k kezelése (felfelé forgatásként)

        // Létrehozunk egy ideiglenes tömböt a sorok tárolására
        int[][] tempMatrix = new int[numRows][];
        for (int i = 0; i < numRows; i++) {
            tempMatrix[(i + k) % numRows] = matrix[i];
        }

        // Visszamásoljuk az eredeti mátrixba
        for (int i = 0; i < numRows; i++) {
            matrix[i] = tempMatrix[i];
        }
    }


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int rows = 0;
        int cols = 0;

        try {
            System.out.print("Adja meg a sorok számát (min. 1): ");
            rows = scanner.nextInt();
            System.out.print("Adja meg az oszlopok számát (min. 1): ");
            cols = scanner.nextInt();

            if (rows <= 0 || cols <= 0) {
                System.err.println("A sorok és oszlopok számának pozitívnak kell lennie!");
                return;
            }

            // Mátrix feltöltése felhasználói bevitellel
            // int[][] myMatrix = fillMatrixFromUserInput(scanner, rows, cols);

            // Vagy véletlenszerű feltöltés:
            int[][] myMatrix = fillMatrixRandomly(rows, cols, 50); // 0-49 közötti számokkal

            System.out.println("n--- Eredeti Mátrix ---");
            printMatrix(myMatrix);

            System.out.print("nKérem adja meg, hány pozícióval szeretné elforgatni az egyes sorokat (pozitív = jobbra, negatív = balra): ");
            int rotationSteps = scanner.nextInt();

            rotateAllRowsRight(myMatrix, rotationSteps); // Elforgatjuk az egyes sorokat

            System.out.println("n--- Mátrix az egyes sorok elforgatása után (" + rotationSteps + " lépéssel jobbra) ---");
            printMatrix(myMatrix);

            // Párhuzamosan bemutatjuk a teljes sorok elforgatását is
            System.out.print("nKérem adja meg, hány sorral szeretné ciklikusan elforgatni a mátrixot (pozitív = lefelé, negatív = felfelé): ");
            int rowRotationSteps = scanner.nextInt();

            rotateEntireMatrixRowsCyclically(myMatrix, rowRotationSteps); // Elforgatjuk a teljes mátrix sorait

            System.out.println("n--- Mátrix a teljes sorok ciklikus elforgatása után (" + rowRotationSteps + " lépéssel lefelé) ---");
            printMatrix(myMatrix);


        } catch (InputMismatchException e) {
            System.err.println("Hibás bevitel! Kérem, egész számot adjon meg a méretekhez vagy a lépésszámhoz.");
        } finally {
            scanner.close();
        }
    }
}

Ahogy a kód is mutatja, a moduláris felépítés kulcsfontosságú. Külön függvényeket hoztunk létre a feltöltésre, kiírásra és az elforgatásra, ami javítja a kód olvashatóságát és karbantarthatóságát. A `rotateRowRight` függvényben egy hatékonyabb algoritmust alkalmazunk, amely egy segédtömb segítségével `O(N)` idő alatt végzi el a `k` lépéses forgatást, szemben a `k` alkalommal ismételt egylépéses forgatással, ami `O(N*k)` lenne.

2. Teljes Sorok Ciklikus Elforgatása ↕️

Ez az az eset, amikor nem az elemek mozognak egy soron belül, hanem a sorok mint egységek. Képzelj el egy pakli kártyát, ahol az alsó kártya felülre kerül, és minden más kártya lefelé csúszik.
Ennek implementációja is hasonlóan történhet egy ideiglenes tárolóval. Például, ha a sorokat lefelé szeretnénk ciklikusan elforgatni `k` lépéssel:

1. Létrehozunk egy ideiglenes 2D tömböt.
2. Az eredeti tömb minden sorát az új pozíciójára másoljuk az ideiglenes tömbben, figyelembe véve a `k` lépést és a modulust a ciklikusság miatt.
3. Végül az ideiglenes tömb tartalmát visszamásoljuk az eredeti tömbbe.

Ezt a funkcionalitást a fenti Java kódban a `rotateEntireMatrixRowsCyclically` metódus demonstrálja.

Gyakori Hibák és Tippek a Hibakereséshez ⚠️

Bár a kétdimenziós tömbök és a forgatás logikája egyszerűnek tűnhet, néhány buktatóra érdemes odafigyelni:

• Indexhatáron kívüli hozzáférés (ArrayIndexOutOfBoundsException): Ez a leggyakoribb hiba. Mindig ellenőrizzük, hogy a ciklusaink indexei (i és j) a tömb érvényes határain belül mozognak-e (`0`-tól `length-1`-ig).
• Elfelejtett ideiglenes változó: Forgatáskor, ha nincs ideiglenes tároló, könnyen felülírhatjuk az adatokat, mielőtt még felhasználnánk őket.
• "Off-by-one" hibák: A ciklusfeltételek (< vs. <=) vagy a kezdő/végpontok helytelen megadása egy-egy elemet kihagyhat vagy túlindexelhet.
• Moduló operátor helyes használata: Ciklikus mozgásnál a `%` (moduló) operátor elengedhetetlen, hogy az indexek a tömb határain belül maradjanak, és a forgatás "körbeérjen".

Tipp: Kezdjünk kisebb méretű tömbökkel (pl. 2x2 vagy 3x3), és manuálisan ellenőrizzük az eredményt minden lépés után. Használjunk debugger-t, hogy nyomon kövessük a változók értékét a ciklusokon belül! ✨

Teljesítmény és Optimalizáció – Mikor Számít? ⚙️

Egy 3x3-as tömb esetén a teljesítmény különbsége elhanyagolható, de mi van, ha milliószor milliós méretű képek pixeleit forgatjuk? Ekkor már kritikus az algoritmus hatékonysága.

"A tapasztalat azt mutatja, hogy míg a kezdők gyakran a "csak működjön" elvre fókuszálnak, addig a valós projektekben a skálázhatóság és a teljesítmény legalább annyira fontos. Egy jól megírt algoritmus, ami nagy adathalmazok esetén is hatékony, hosszú távon rengeteg erőforrást és fejfájást spórol meg."

A fenti kódban a `rotateRowRight` metódus már egy optimalizált, O(N) komplexitású megoldást használ (`N` a sor hossza). Ez azt jelenti, hogy a sor forgatásához szükséges idő egyenesen arányos a sor elemeinek számával, ami sokkal jobb, mint egy O(N*k) megoldás, ahol `k` a forgatás lépésszáma.

További optimalizálási lehetőségek: ha a mátrix rendkívül nagy és ritkán változik, esetleg érdemes lehet az adatokat más formában tárolni, vagy speciális adatszerkezeteket alkalmazni, de az esetek nagy részében a fent bemutatott megoldás kiválóan megfelel.

Kódod Egyedi Stílusa: Miért érdemes odafigyelni? ✅

Egy jól megírt program nem csak működik, hanem könnyen érthető is. Ezt hívjuk olvasható kódnak. Néhány tipp:

• Konzekvens formázás: Használj azonos behúzásokat, szóközt.
• Értelmes változónevek: Nevezd el a változókat úgy, hogy a nevükből kiderüljön a szerepük (pl. `rows` helyett `r`).
• Kommentek: Magyarázd el a bonyolultabb részeket, a függvények célját és paramétereit.
• Moduláris felépítés: Ahogy a példánkban is láttuk, bontsd kisebb, jól körülhatárolt függvényekre a feladatokat.

Ezek az apró részletek nem csak neked segítenek később, hanem a csapatodnak is, ha mások is dolgoznak majd a kódon.

Összefoglalás és Következtetés 💡

A 2D tömbök feltöltése és sorainak elforgatása alapvető, mégis rendkívül tanulságos feladat a programozásban. Nem csupán egy algoritmikus kihívásról van szó, hanem arról is, hogy megértsük, hogyan kezelhetjük hatékonyan az adatok áramlását és szerkezetét. A fent bemutatott kód és magyarázat remélhetőleg útmutatóul szolgál ahhoz, hogy magabiztosan vágj bele hasonló problémák megoldásába.

Ne feledd: a programozás leginkább arról szól, hogy problémákat oldjunk meg. Minél több gyakorlati feladaton dolgozol, annál mélyebb lesz a megértésed, és annál könnyebben birkózol meg a jövőbeli kihívásokkal. Hajrá!