Sattelpunkt einer Matrix

[Gagamel]

Bin mal wieder hier
Also das Problem ist ansich relativ einfach, man sollte eine Matrix einlesen, bestimmen ob symmetrisch oder nicht, die Transponierte bestimmen und den Sattelpunkt, falls vorhanden

Bis auf den Sattelpunkt habe ich das auch hinbekommen, aber da scheiter ich.

Ok ich weiß, dass der Sattelpunkt, einen niedrigsten Wert in der Zeile und einen höchsten in der Spalte hat.
Um das zu lösen brauche ich auf jeden Fall ein Zwischenarray. Dennoch komme ich irgendwie auf keinen vernünftigen Algorithmus
bzw
erst die niedrigsten Werte der Zeilen in ein Array --> das habe ich geschafft

public static double sattelpunkt(double[][] matrixSat, int x, int y){
     int x1=0,y1=0;
     double[][] matrixZeile = new double[1][x];   //niedrigster Wert der Zeile
     

     for (y1=0; y1<=(y-1); y1++){
     matrixZeile[0][y1]=matrixSat[0][y1]+1;
     for (x1=0;x1<=(x-1);x1++){
     // System.out.println(matrixZeile[0][y1] +"   "+matrixSat[x1][y1]);

       if (matrixSat[x1][y1] < matrixZeile[0][y1]){
         matrixZeile[0][y1]=matrixSat[x1][y1];
          }
     }

Dann müßte ich bestimmen ob einer dieser Punkte der höchste in seiner Spalte ist und hier scheiter ich, der Code den ich bisher gebaut habe hat wenn überhaupt nur für einen spezifischen Fall funktioniert oder aber außer Acht gelassen, dass es auch sein kann, dass kein Sattelpunkt existiert.
Könnte mir da jemand auf die Sprnge helfen

zum Verständnis das restliche Programm.

import java.util.*;
import java.io.*;

public class Aufgab2_beta
{
  static boolean neustart=false;
  public static void main( String args[] )
  {
  int x=0,y=0;
  Scanner sc = new Scanner(System.in);
  boolean symmetrisch;
  do{
  System.out.println("Bitte geben sie die Matrixdimension mit Leerzeichen getrennt ein (Spalten Zeilen)");
  try {
       neustart=false;                      //boolean für Neustart bei Falscheingabe
       x=sc.nextInt();                      //Spaltenanzahl
       y=sc.nextInt();                      //Zeilenanzahl
       }
     catch (Exception e){
       System.out.println("Ungueltige Angabe");
       sc.next();
       neustart=true;
     }
   }
   while (neustart==true);
   
   
   double[][] matrix = new double[x][y];     //Array mit x Spalten und y Zeilen
   double[][] matrixTrans = new double[y][x];
   double sattel;
   
                                             
   matrix=einlesen(x,y);                     //Eingaberoutine der Matrix. Übergeben werden x und y für die
                                             //Matrixausmeßungen
   
   matrixAusgabe(matrix,x,y);                //Ausgabe der eingegebenen Matrix mit y Zeilen und x Spalten
   symmetrisch = symmetrieCheck(matrix,x,y);
   matrixTrans = transpo(matrix,x,y);
   System.out.println("\n \n \n");
   matrixAusgabe(matrixTrans,y,x);
   //sattel = sattelpunkt(matrix,x,y);
  //System.out.println("\n \n \n");
   //System.out.println(sattel);
   
}



  public static double[][] einlesen(int x, int y){
    double[][] matrix = new double[x][y];            //Erzeugung von Array mit x Spalten und y Zeilen
    boolean neustart=false;
    Scanner sc = new Scanner(System.in);
    do{
    neustart=false;
    for (int y1=0;y1<=(y-1);y1++){                   //gehe Zeilen durch
      System.out.println("Geben sie die Werte der Zeile "+(y1+1)+" mit Leerzeichen getrennt ein.(a b c)");
      for(int x1=0;x1<=(x-1);x1++){                  //gehe Spalten durch
        try {
          matrix[x1][y1]=sc.nextDouble();              //trage Werte ein
          }
        catch(Exception E){
          System.out.println("Ungueltige Eingabe");
          neustart=true;
          sc.next();
          y1=y+1;
          break;
        }
      }
    }
    }
    while(neustart==true);
    return matrix;
  }



  public static void matrixAusgabe(double[][] matrixAusgabe,int x, int y){
    int x1,y1;
    for (y1=0; y1<=(y-1); y1++){  //i für die Zeilen, j für die Spalten
    System.out.println();
      for (x1=0; x1<=(x-1); x1++){
      System.out.print(matrixAusgabe[x1][y1] + "   ");
      }
    }
  }
  
  
  public static boolean symmetrieCheck(double[][] matrixSym, int x, int y){
    int x1=0,y1=0;
    if (x==y){
      for (y1=0; y1<=(y-1); y1++){
        for (x1=0;x1<=(x-1);x1++){
          if (matrixSym[x1][y1]!=matrixSym[y1][x1]) {
            return false;                                            }
        }
      }
    return true;
    }
    return false;
  }


  public static double[][] transpo(double[][] matrixTrans,int x, int y){
  int x1=0,y1=0;
  double[][] matrixTransNew = new double[y][x];
    for (y1=0; y1<=(y-1); y1++){
      for (x1=0;x1<=(x-1);x1++){
      matrixTransNew[y1][x1]=matrixTrans[x1][y1];
      }
    }
   return matrixTransNew;
  }
 public static double sattelpunkt(double[][] matrixSat, int x, int y){

[/code]

 

[Redfrettchen]

Hi,
erstmal ein paar Bemerkungen:

1. Die Methodik beim Einlesen sieht sehr komisch aus.
Besser:

...
// Ich geh mal davon aus, dass Scanner existiert...
Scanner sc = new Scanner(System.in);
String s;
while (true) {
    System.out.println("...");
    try {
        // und next() eine Zeile einliest.
        s = sc.next();
    } catch (Exception e) {
        System.out.println("Ungueltige Eingabe");
        continue;
    }
break;
}

2. Was sind das für Zählschleifen?
Besser:

for (int x1=0; x1<x; x1++)
// Man beachte, dass die Zählvariable innerhalb der Schleife deklariert wurde.
// Nach der Schleife wird sie so wieder gelöscht.
...

3. Wenn du ein Array übergibst, dann kann die Methode selbst die Abmessungen herausfinden:

...
int[][] matrix = einlesen(x,y);
ausgeben(matrix);
...
void ausgeben(int[][] matrix) {
   int y=matrix.length, x=matrix[0].length;
   // denn das Array sollte ja rechteckig sein.
   ...
}

4. Allgemein besser wäre es natürlich, wenn Matrizen eine eigene Klasse bekämen und sich selbst verwalten. So wie du es gemacht hast sieht es sehr prozedural aus.

Nun zum eigentlichen Problem.
In deiner Sattelpunkt-Methode erstellst du ein zweidimensionels Array, das aber nur aus einer Zeile besteht. Wieso? Es reicht doch ein einfaches Array für das speichern einer Zeile von Daten. Außerdem steht da zwar als Kommentar, dass der niedrigste Wert der Zeile gespeichert wird, das Array wird aber so angelegt, dass für die Anzahl der Spalten Platz gemacht wird (x ist die Anzahl der Spalten oder die Länge einer Zeile, oder?).
Du durchläufst die Zeilen, speicherst in deinen Hilfsarray den Wert der ersten Spalte in der Zeile, allerdings um 1 erhöht. Dann durchläufst du die aktuelle Zeile, wobei die Werte mit der gespeicherten verglichen, und falls sie kleiner sind, in das Speicherarray übertragen werden.
Du könntest gleich den ersten Wert als Referenzwert behalten und alle weiteren in der Zeile mit ihm vergleichen und ggf. ersetzen. Aber ich glaube, es wäre besser, statt dem Wert die jeweilige Spalte zu merken
Daraus folgt:

  public static double sattelpunkt(double[][] matrixSat){ 
      int y=matrixSat.length, x=matrixSat[0].length;
  	double ref; // Referenzwert
  	int[] matrixZeile = new int[x];   // Spalte des niedrigsten Wertes in der Zeile

  	for (int y1=0; y1<y; y1++) { 
  	    ref = matrixSat[y1][0];
  	    matrixZeile[y1] = 0;

  	    for (int x1=1;x1<x;x1++) { 
  	        if (matrixSat[y1][x1] < ref){
  	            ref = matrixSat[y1][x1];
  	            matrixZeile[y1]=x1; 
  	        } 
  	    }
  	}

Ja und dann kannst du die ganze Suche doch nocheinmal durchlaufen lassen nur suchst du diesmal nach dem größten Wert in den Spalten. Schließlich durchläufst du nocheinmal das erste Hilfsarray und überprüfst, ob das zweite Hilfsarray an der Stelle des aktuellen Element (es ist eine Spaltenposition) die Laufvariable ist. Wenn ja, dann ist ein Sattelpunkt gefunden.

  public static double sattelpunkt(double[][] matrixSat){ 

      int y=matrixSat.length, x=matrixSat[0].length;
  	double ref; // Referenzwert
  	int[] matrixZeile = new int[x];   // Spalte des niedrigsten Wertes in der Zeile

  	for (int y1=0; y1<y; y1++) {
	    // erste Spalte der Zeile als Referenzwert
  	    ref = matrixSat[y1][0];
  	    matrixZeile[y1] = 0;

  	    for (int x1=1; x1<x; x1++) {
  	        if (matrixSat[y1][x1] < ref){
		    // neue Referenz setzen und Spalte speichern
  	            ref = matrixSat[y1][x1];
  	            matrixZeile[y1]=x1; 
  	        } 
  	    }
  	}

  	int[] matrixSpalte = new int[y]; // Zeile des höchsten Wertes der Spalte
  	for (int x1=0; x1<x; x1++) {
	    // erste Zeile der Spalte als Referenzwert
  	    ref = matrixSat[0][x1];
  	    matrixSpalte[x1]=0;

  	    for (int y1=1;y1<y;y1++) {
  	        if (matrixSat[y1][x1] > ref) {
  	            ref = matrixSat[y1][x1];
  	            matrixSpalte[x1]=y1;
  	        }
  	    }
  	}

  	for (int y1=0; y1<x; ++y1) {
  	    if (matrixZeile[matrixSpalte[y1]] == y1) return matrixSat[matrixSpalte[y1]][y1];
  	}
    return 0;
  }

Aber ein anderes Problem wäre vielleicht noch, dass der Benutzer es irgendwie erfahren sollte, wenn es keinen Sattelpunkt gibt. Bei mir steht da jetzt einfach "return 0", aber das ist ja nicht die Lösung. Da musst du dir noch irgendwas mit Rückgabewert boolean überlegen. Wie gesagt, eine Matrizen-Klasse wäre besser.

Grüße und viel Spaß,
Redfrettchen

 

[Gagamel]

Erstmal ein riesiges Danke

zu 1.) Hier verstehe ich deine Version nicht sc.next() liest meines Wissens einen String ein, den müßte ich aber dann ja erst noch wieder auseinander schneiden und umwandeln um ihn in die Matrix einzutragen.

Aber eine while(true)-SchleifenVariante wäre in der Tat irgendwie besser als immer eine Hilfsvariable zu benutzen, das baue ich nochmal um


zu 2.)habe ich erst später bedacht, dass man die Zählvariablen ja auch in der Schleife definieren könnte, habe das waber zumindest mal vereintheitlicht und mal genauere Variablennamen benutzt

zu 4.)das weiß ich gar nicht, wie man das macht. Wir haben erst die 2.Woche Java und ich fand es schon recht schwer mir, dies alles beizubringen. Wie man das Programm auf mehrer Klassen aufteilt müßte ich mich auch erstmal reinlesen, darum ist halt noch alles in einer Datei.


Die Lösung schaue ich mir jetzt erst einmal genauer an, man sollte ja auch durch das durchsteigen, was man benutzt :=)