Matrix transponieren - Hilfe

[canyakan95]

Hallo gegeben ist eine klasse , wo ich bei der methode transpose() aus der gegebenen matrix a die transponierte methode erstellen soll.

Hoffe ihr könnt mir da weiterhelfen..
Habe zwar was hingeschrieben , ist aber falsch...

package übung1;

public class Matrix
{
    private int[][] data;

    public Matrix(int[][] data)
    {
        this.data = data;
    }

    // Vorbedingung: anzZeilen > 0 und anzSpalten > 0
    public Matrix(int anzZeilen, int anzSpalten)
    {
        assert(anzZeilen > 0);
        assert(anzSpalten > 0);

        data = new int[anzZeilen][anzSpalten];
    }

    // Diese Methode wird f¸r die Aufgabenstellung nicht benˆtigt,
    // sondern dient der Verdeutlichung und Demonstration
    public void set(int[][] data)
    {
        int anzZeilen = data.length > this.data.length ?
            this.data.length : data.length;
        // Effiziente Form f¸r:
        // int anzZeilen;
        // if (data.length > this.data.length)
        // {
        //   anzZeilen = data.length;
        // }
        // else
        // {
        //   anzZeilen = this.data.length;
        // }

        int anzSpalten = data[0].length > this.data[0].length ?
            this.data[0].length : data[0].length;
        // Effiziente Form f¸r:
        // int anzSpalten;
        // if (data[0].length > this.data[0].length)
        // {
        //   anzSpalten = data[0].length;
        // }
        // else
        // {
        //   anzSpalten = this.data[0].length;
        // }

        for (int a = 0; a < anzZeilen; a++)
            for (int b = 0; b < anzSpalten; b++)
                this.data[a][b] = data[a][b];
    }

/** A.transpose():
*
*  A entspricht Matrix, die transponiert werden soll. (Die
*  zugehˆrigen Zahlen werden im Attribut 'data' gespeichert)
*
*  anzSpalten <- dim(A,1)  // Anzahl Spalten in transp. Matrix
*  anzZeilen <- dim(A,2)   // Anzahl Zeilen in transp. Matrix
*
*  B = create Matrix(anzZeilen, anzSpalten)
*
*  for a <- 1 to anzSpalten do
*    for b <- 1 to anzZeilen do
*      B[b,a] <- A[a,b]
*    end for
*  end for
*
*  return B
*/

    public Matrix transpose()
    {
        int anzSpalten= data[1].length;
        int anzZeilen=data[2].length;
       
        Matrix[][]  A = new Matrix[anzZeilen][anzSpalten];
       
        Matrix B = new Matrix (anzZeilen,anzSpalten);
       
        for(int a=1;a<anzSpalten;a++){
           
            for(int b=1;b<anzZeilen;b++){
               
               
                B= A[a][b];
            }
        }
       
        return B;
    }

 

[JCODA]

Mh ja, ... schau dir das echt nochmal an, das sind echt Grundlagen, ... vielleicht etwa so:

Spoiler: Click

public class Matrix {
    private int[][] data;

    public Matrix(int[][] data) {
        this.data = data;
    }

    // Vorbedingung: anzZeilen > 0 und anzSpalten > 0
    public Matrix(int anzZeilen, int anzSpalten) {
        assert (anzZeilen > 0);
        assert (anzSpalten > 0);

        data = new int[anzZeilen][anzSpalten];
    }

    // Diese Methode wird f¸r die Aufgabenstellung nicht benˆtigt,
    // sondern dient der Verdeutlichung und Demonstration
    public void set(int[][] data) {
        int anzZeilen = data.length > this.data.length ? this.data.length
                : data.length;
        // Effiziente Form f¸r:
        // int anzZeilen;
        // if (data.length > this.data.length)
        // {
        // anzZeilen = data.length;
        // }
        // else
        // {
        // anzZeilen = this.data.length;
        // }

        int anzSpalten = data[0].length > this.data[0].length ? this.data[0].length
                : data[0].length;
        // Effiziente Form f¸r:
        // int anzSpalten;
        // if (data[0].length > this.data[0].length)
        // {
        // anzSpalten = data[0].length;
        // }
        // else
        // {
        // anzSpalten = this.data[0].length;
        // }

        for (int a = 0; a < anzZeilen; a++)
            for (int b = 0; b < anzSpalten; b++)
                this.data[a][b] = data[a][b];
    }

    /**
     * A.transpose():
     *
     * A entspricht Matrix, die transponiert werden soll. (Die zugehˆrigen
     * Zahlen werden im Attribut 'data' gespeichert)
     *
     * anzSpalten <- dim(A,1) // Anzahl Spalten in transp. Matrix anzZeilen <-
     * dim(A,2) // Anzahl Zeilen in transp. Matrix
     *
     * B = create Matrix(anzZeilen, anzSpalten)
     *
     * for a <- 1 to anzSpalten do for b <- 1 to anzZeilen do B[b,a] <- A[a,b]
     * end for end for
     *
     * return B
     */

    public Matrix transpose() {
        int anzSpalten = data.length;
        int anzZeilen = data[0].length;
        Matrix B = new Matrix(anzZeilen, anzSpalten);
        for (int a = 0; a < anzSpalten; a++) {
            for (int b = 0; b < anzZeilen; b++) {
                B.data[b][a] = data[a][b];
            }
        }
        return B;
    }

   
@Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int a = 0; a < data.length; a++) {
            for (int b = 0; b < data[0].length; b++){
                sb.append("\t" + data[a][b]);
            }
            if(a!=data.length)
            sb.append("\n");
        }
        return sb.toString();
    }
}

Und noch eine kleine Testklasse:

public class TestMatrix {
    public static void main(String[] args) {
        Matrix m = new Matrix(new int[][]{{1,2,3},{4,5,6}});
        System.out.print(m);      
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~");      
        System.out.print(m.transpose());
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~");  
        System.out.print(m.transpose().transpose());
    }
}