# Matrix auf Symmetrie überprüfen



## treask (8. Nov 2014)

Hallo,

ich habe hier folgenden Code:


```
int mat[][] = new int[][] {{2,4,6,8},{4,14,8,6},{6,8,14,4},{8,6,4,2}}; 
 
        int x = mat.length; 
        int y = mat[0].length;
    
        int[][] sym = new int[x][y];
    
        if (x == y) {
           if (y == x)

           System.out.println("true");
}
```

Aufgabe ist es die Matrix auf Symmetrie zu überprüfen. Was ich gemacht habe ist zwar ausführbar, aber glaube ich nicht das was richtig ist. Zum Beispiel zeigt er an, dass die Matrix symmetrisch ist, wenn man Elemente einer Zeile entfernt, außer wenn man die erste Zeile verändert. Dann gibt das Programm aber eine leere Zeile aus, obwohl ich das ganze auch noch mit einer if-Schleife überprüfen lies, ob die Zeilen und Spalten ungleich sind. Mein Programm zeigt glaube ich auch nur an, ob  eine Matrix quadratisch ist was an sich unwichtig ist, weil das ja Vorraussetzung für Symmetrie ist.

Das ganze muss man bestimmt mit einen Suchalgorithmus machen, aber wie soll das funktionieren? Kann mir da jemand helfen? Gibt es da eine "einfache" Möglichkeit zur Überprüfung, ob die 1. Zeile mit der 1. Spalte übereinstimm, die 2. Zeile mit 2. Spalte usw. identisch sind? Das hört sich für mich etwas zu umständlich an oder denk ich da zu kompliziert?

Danke schon mal im vorraus.

MfG


----------



## Thallius (8. Nov 2014)

Du musst ja nachsehen ob die Länge des Arrays gleich der Länge ALLER seine Inhalte ist. Du überprüfst aber nur die Länge des ersten Inhalts. Du musst eine Schleife über die Länge des Arrays machen und jeden einzelnen Inhalt mit der Länge des Arrays überprüfen und nur wenn alle gleich sind ist es true.

Gruß

Claus


----------



## stg (8. Nov 2014)

Ich hab dir mal die Symmetrie-Abfrage zusammengebastelt und einige Systemausgaben mit eingebaut, damit du verstehst, was da genau passiert. Eine Überprüfung, ob überhaupt eine quadratische Matrix vorliegt, hab ich extra noch nicht mit eingebaut ... das kannst du dann hoffentlich bestimmt selbst?

Schau mal hier:

```
public class Matrix {

    public static void main(String [] args) {
        int mat[][] = new int[][] {{2,4,6,8},{4,14,8,6},{6,8,14,4},{8,6,4,2}}; 
        System.out.println("Ist symmetrisch? "+isSymmetric(mat));
    }
    
    public static boolean isSymmetric(int [] [] matrix) {
        for(int zeile = 0; zeile < matrix.length; zeile++) { // Für jede Zeile der Matrix
            System.out.println("Überprüfe Zeile "+zeile+": ");
            for(int spalte = 0; spalte < zeile; spalte++) {  // Für jede Spalte in der aktuellen Zeile bis hin zur Diagonale
                System.out.print("["+zeile+"]["+spalte+"] = "+matrix[zeile][spalte]+" /"+"["+spalte+"]["+zeile+"] = "+matrix[spalte][zeile]);
                if(matrix[zeile][spalte] != matrix[spalte][zeile]) {
                    System.out.println(" stimmen nicht überein!");
                    System.out.println("Abbruch! Matrix ist nicht symmetrisch!");
                    return false;
                }
                else {
                    System.out.println(" stimmen überein!");
                }
            }
        }
        System.out.println("Matrix ist symmetrisch!");
        return true;
    }
}
```

Ausgabe auf der Konsole ist dann:

```
run:
Überprüfe Zeile 0: 
Überprüfe Zeile 1: 
[1][0] = 4 /[0][1] = 4 stimmen überein!
Überprüfe Zeile 2: 
[2][0] = 6 /[0][2] = 6 stimmen überein!
[2][1] = 8 /[1][2] = 8 stimmen überein!
Überprüfe Zeile 3: 
[3][0] = 8 /[0][3] = 8 stimmen überein!
[3][1] = 6 /[1][3] = 6 stimmen überein!
[3][2] = 4 /[2][3] = 4 stimmen überein!
Matrix ist symmetrisch!
Ist symmetrisch? true
```


----------



## treask (8. Nov 2014)

Danke, das ist genau der Ansatz den ich gebraucht habe. 

Zeige ich denn nicht durch meinen Code nicht, ob das ganze quadratisch ist oder nicht? Vergleicht es nicht die Anzahl der Zeilen und Spalten? Hier ist mal das was ich probiert habe:


```
int zeilen_test = mat.length; 
    int spalten_test = mat[0].length;

      if (zeilen_test == spalten_test) {
      if (spalten_test == zeilen_test)
      System.out.println("Die Matrix ist quadratisch.");
      
      else {
        if (spalten_test != zeilen_test) {
        if (zeilen_test != spalten_test)
        System.out.println("Die Matrix ist nicht quadratisch."); 
        } 
      }  
    }
```

Den ersten Teil der if-Schleife klappt problemlos, aber wenn die Zeilen und Spalten nicht übereinstimmen, dann wird da nichts ausgeben statt, dass es nicht quadratisch ist. Wo habe ich da den Fehler gemacht?

Was für einen Befehl kann ich einfügen, wenn ich beispielsweise möchte, dass der nachfolgende Code ignoriert werden soll? Beispielsweise möchte ich, dass die Symmetrieüberprüfung nur stattfinden soll, wenn die Matrix quadratisch ist.


----------



## Androbin (8. Nov 2014)

treask hat gesagt.:


> ```
> int zeilen_test = mat.length;
> int spalten_test = mat[0].length;
> 
> ...


Das ist totaler quatsch!
Wenn a == b ist, dann MUSS auch b == a sein!
Und wenn a != b ist, dann ist auch b != a, oder?
Also WIESO prüfst du das unnötigerweise zweimal?


----------



## njans (8. Nov 2014)

```
if (zeilen_test == spalten_test) {
if (spalten_test == zeilen_test)
```

??? Äquivalenz ist symmetrisch.

Zu deinem Problem. Klammer mal deine Ifs. dann siehst du auch worauf sich das else bezieht.


----------



## arilou (10. Nov 2014)

In Java müssen die Unter-Dimensionen eines Arrays nicht gleichgroß sein:
	
	
	
	





```
int[][] ar ;
ar = new int[5][] ; // erst mal Platz für 5 Zeilen schaffen; Anzahl der Spalten bleibt noch unbestimmt.
ar[0] = new int[] { -1 , 10 , 2 } ; // erste Zeile, 3 Elemente/Spalten
ar[1] = new int[] { 0 } ; // zweite Zeile, nur 1 Element/Spalte
ar[2] = null ; // auch das darf zwischendrinn vorkommen!
ar[3] = new int[] {} ; // formal ein Array, aber mit 0 Elementen/Spalten ; das ist != null
ar[4] = new int[] { 2 , -2 , 2 , 100 , 58 } ; // fünfte Zeile, 5 Elemente/Spalten
```


----------

