Transpose of a matrix

1. Sablon:Label mátrix transzponáltja

---

A mátrix transzponáltja a lineáris algebra egyik alapvető művelete, amely gyakran előfordul a matematikai számításokban, gépi tanulásban, fizikában és más tudományos területeken. A transzponált mátrix létrehozása azt jelenti, hogy egy adott mátrix sorait oszlopokká alakítjuk, és az oszlopokat sorokká. A következőekben részletesen bemutatom a mátrix transzponálásának elméletét és annak C++-os implementálását.

Mi a mátrix transzponáltja?

A mátrix transzponálása során a mátrix sorait oszlopokká alakítjuk, és fordítva. Formálisan, ha egy $A$ nevű mátrixunk van, amely $m$ sorból és $n$ oszlopból áll, akkor a transzponált mátrixot $A^T$-t jelöljük, és ez egy $n\times m$ dimenziójú mátrixot eredményez.

\**Alapképlet**: Ha $A$ egy $m\times n$ mátrix, akkor a transzponált mátrix $A^T$ egy $n\times m$ mátrix, és az elemeket az alábbi módon helyezzük át:

$$A^T[i][j]=A[j][i]$$

Ez azt jelenti, hogy $A^T$-ben a $(i,j)$-edik elem $A$-ban a $(j,i)$-edik elem lesz.

Például, ha van egy $2\times 3$-as mátrixunk:

$$A=\left(\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right)$$

A transzponáltja:

$$A^T=\left(\begin{array}{cc}1& 4\\ 2& 5\\ 3& 6\end{array}\right)$$

Hogyan működik a mátrix transzponálása?

A mátrix transzponálása a következő lépésekben valósítható meg:

1. A bemeneti mátrix sorainak és oszlopainak cseréje: A transzponált mátrixban az eredeti mátrix sorai oszlopokká válnak, és az oszlopok sorokká.
2. Egy új mátrix létrehozása: Az új mátrix dimenziója az eredeti mátrix oszlopainak és sorainak helyet cserélésével keletkezik.
3. Az elemek áthelyezése: Minden egyes elem helyét az eredeti mátrixból az új helyére kell másolni a fenti képlet alapján.

Íme a program pszeudokódja, amely segít megérteni az algoritmus működését magasabb szinten:

FUNKCIÓ transzponál(mátrix)
    SOROK = mátrix sorainek száma
    OSZLOPOK = mátrix oszlopainak száma

    Hozz létre egy új mátrixot: transzponált[OSZLOPOK][SOROK]

    CIKLUS i = 0-tól SOROK-ig
        CIKLUS j = 0-tól OSZLOPOK-ig
            transzponált[j][i] = mátrix[i][j]
        CIKLUS VÉGE
    CIKLUS VÉGE

    VISSZATÉR transzponált
FUNKCIÓ VÉGE

FUNKCIÓ mátrix_kiírás(mátrix)
    CIKLUS minden sorban a mátrixban
        CIKLUS minden elemben a sorban
            Írd ki az elemet
        CIKLUS VÉGE
        Új sorba lépés
    CIKLUS VÉGE
FUNKCIÓ VÉGE

FŐPROGRAM
    Írja ki: "Adja meg a mátrix sorainak számát:"
    Olvassa be: SOROK

    Írja ki: "Adja meg a mátrix oszlopainak számát:"
    Olvassa be: OSZLOPOK

    Hozz létre egy új mátrixot: mátrix[SOROK][OSZLOPOK]

    Írja ki: "Adja meg a mátrix elemeit:"

    CIKLUS i = 0-tól SOROK-ig
        CIKLUS j = 0-tól OSZLOPOK-ig
            Olvassa be: mátrix[i][j]
        CIKLUS VÉGE
    CIKLUS VÉGE

    Írja ki: "Eredeti mátrix:"
    mátrix_kiírás(mátrix)

    transzponált_mátrix = transzponál(mátrix)

    Írja ki: "Transzponált mátrix:"
    mátrix_kiírás(transzponált_mátrix)
PROGRAM VÉGE

Mátrix transzponálása C++-ban

Most nézzük meg, hogyan implementálhatjuk a mátrix transzponálásának műveletét C++ nyelven. Ehhez egy egyszerű programot készítünk, amely bemeneti mátrixot kér a felhasználótól, majd kiszámítja annak transzponáltját.

C++ kód:

#include <iostream>
#include <vector>

using namespace std;

// Mátrix transzponálása
vector<vector<int>> transpose(const vector<vector<int>>& matrix) {
    int rows = matrix.size();
    int cols = matrix[0].size();

    // Új mátrix létrehozása a transzponáláshoz
    vector<vector<int>> transposed(cols, vector<int>(rows));

    // Az elemek áthelyezése a transzponált mátrixba
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            transposed[j][i] = matrix[i][j];
        }
    }

    return transposed;
}

// Mátrix kiíratása
void printMatrix(const vector<vector<int>>& matrix) {
    for (const auto& row : matrix) {
        for (int elem : row) {
            cout << elem << " ";
        }
        cout << endl;
    }
}

int main() {
    int m, n;

    // A felhasználó bemeneti mátrix mérete
    cout << "Adja meg a mátrix sorainak számát: ";
    cin >> m;
    cout << "Adja meg a mátrix oszlopainak számát: ";
    cin >> n;

    // Mátrix létrehozása
    vector<vector<int>> matrix(m, vector<int>(n));

    // A felhasználótól a mátrix elemeinek beolvasása
    cout << "Adja meg a mátrix elemeit:" << endl;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> matrix[i][j];
        }
    }

    // A mátrix kiíratása
    cout << "Eredeti mátrix:" << endl;
    printMatrix(matrix);

    // Transzponált mátrix kiszámítása
    vector<vector<int>> transposedMatrix = transpose(matrix);

    // A transzponált mátrix kiíratása
    cout << "Transzponált mátrix:" << endl;
    printMatrix(transposedMatrix);

    return 0;
}

A program működése

1. Bemenó adatok: A program első lépése, hogy bekéri a mátrix sorainak és oszlopainak számát a felhasználótól.
2. Mátrix létrehozása: A program ezt követően létrehozza a megfelelő méretű mátrixot.
3. Elemek beolvasása: A felhasználó által megadott elemeket beolvassuk a mátrixba.
4. Transzponálás: A transpose függvény felelős a mátrix transzponálásáért. Létrehoz egy új mátrixot, amelynek dimenziói felcserélődnek az eredeti mátrix dimenzióival, és a ciklus segítségével átmásolja az elemeket.
5. Kiíratás: A printMatrix függvény segítségével kiírjuk mind az eredeti, mind a transzponált mátrixot a képernyőre.

Példa

Ha a felhasználó egy ( 2 )-as mátrixot ad meg:

Adja meg a mátrix sorainak számát: 2
Adja meg a mátrix oszlopainak számát: 3
Adja meg a mátrix elemeit:
1 2 3
4 5 6

A program a következő kimenetet adja:

Eredeti mátrix:
1 2 3 
4 5 6 
Transzponált mátrix:
1 4 
2 5 
3 6

A transzponálás működése

Ebben az esetben az eredeti mátrix:

$$A=\left(\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right)$$

A transzponált mátrix:

$$A^T=\left(\begin{array}{cc}1& 4\\ 2& 5\\ 3& 6\end{array}\right)$$

Ahogy láthatjuk, a sorok és oszlopok felcserélődtek, és az eredeti $2\times 3$-as mátrix egy $3\times 2$-es mátrixszá vált.

A transzponálás hatékonysága

A transzponálás egy egyszerű művelet, amelynek időbeli bonyolultsága $O(m\times n)$, ahol $m$ és $n$ a mátrix sorainak és oszlopainak száma. Ez azért van, mert minden egyes elemnek át kell kerülnie a transzponált mátrix megfelelő helyére.

Összegzés

A mátrix transzponálása egy egyszerű, de alapvető művelet a lineáris algebrában és a számítástechnikában. C++-ban a transzponálás implementálása egyszerűen megoldható egy kétdimenziós tömb vagy vektor segítségével, és a transzponált mátrix létrehozása egy új tömb vagy vektor létrehozását és a megfelelő elemek áthelyezését jelenti. A bemutatott program bemutatja, hogyan lehet interaktívan kezelni a bemeneti mátrixot és kiszámítani annak transzponáltját.