Probleme bei einer Uni Aufgabe

[sunny611]

Hallo Leute,

Habe eine Aufgabe zum Programmieren bekommen und finde keine Lösung.
Deswegen Poste ich mal die Aufgabenstellung und würde mich über Hilfe euerseits freuen, da ich die kompltte Geschichte mit dem Feldern gar nicht verstanden habe.

Aufgabenstellung:

Die Firma OptiTravel hat beschlossen, ihre Anwendung um eine Kundenverwaltung zu erweitern. Sie werden mit der Entwicklung betraut.

a) Im Zuge dessen soll eine Funktion erstellt werden, die ein ihr übergebenes zweidimensionales Feld mit Kundendaten sortiert. Dabei soll jedes Element der ersten Dimension einen Kunden speichern und jedes Element der zweiten spezifische Daten zu einem Kunden. Die zweite Dimension soll folgende Struktur aufweisen:
1. Position: Kundennummer
2. Position: Name
3. Position: Vorname
4. Position: Adresse

Bei der Sortierfunktion muss der Index der Spalte nach der sortiert werden soll (Kundennummer (0), Name (1), Vorname (2), Adresse (3)) sowie die Sortierfolge (aufsteigend/absteigend) parametrisierbar sein.

Erstellen Sie eine entsprechende Funktion und testen Sie diese, in dem Sie ein Feld mit unsortierten Datensätzen erzeugen, dieses dann mit Hilfe der Funktion sortieren und das Feld in Form einer tabellarischen Auflistung ausgeben.

b) Des Weiteren soll eine Suchfunktion entwickelt werden. Diese soll es ermöglichen, nach einem Kunden unter Angabe eines Kundennamen zu suchen. Im Erfolgsfall sollen alle Daten zu einem Kunden ausgegeben werden. Die Funktion soll als Eingabeparameter sowohl das Feld mit den Kundendaten als auch den Suchstring erhalten.

Erstellen Sie eine entsprechende Funktion und testen Sie diese, in dem Sie beispielhaft nach einem Datensatz suchen.


Ich hoffe ihr könnt mir helfen

MfG

sunny611

 

[dngfng]

a) Im Zuge dessen soll eine Funktion erstellt werden, die ein ihr übergebenes zweidimensionales Feld mit Kundendaten sortiert. Dabei soll jedes Element der ersten Dimension einen Kunden speichern und jedes Element der zweiten spezifische Daten zu einem Kunden. Die zweite Dimension soll folgende Struktur aufweisen:
1. Position: Kundennummer
2. Position: Name
3. Position: Vorname
4. Position: Adresse

Die Formulierung der Aufgabe löst ja schon Kopfweh aus. Mein Professor konnte auch keine Anforderungen verständlich formulieren.;(

2 Dimensionen - ist die rede hier von einer schlichten 2 dimmensionallen Array String [][] kunden....

 

[dngfng]

String [][]kunden = {{"1","Licoln","Abraham","Muster Str. 271, MusterStadt"},{"2","Xa","Xavian","Shanghai,China"}};

Also so würde diese Datenstruktur als Array aussehen falls das der Sinn der Aufgabe sein sollte. Dies kann man dann auch noch sortieren und durchsuchen.

Um and die Kundennummer des 1 eintrags zu kommen müsstest du dann

String custNo = kunden[0][0];

für Denn Namen dann:

String name = kunden[0][1];

etc...

Diese kannst du dann mit den folgenden vergleichen und gegeben falls umsortieren ich nehme an bei so einer aufgaben Stellung wurde euch schon Sortieralgorithmen beigebracht.

Kannst du dir hier was drunter vorstellen oder brauchst du mehr Details?

 

[sunny611]

Vielen Dank für deine Schnelle Hilfe.
Habe bereits von Sortieralgorithmen gehört und habe einige im Buch als Beispiele, aber nur 1 Dimensionale Felder 2 Dimensionale Felder habe ich nicht hinbekommen zu sortieren.

Wenn du mir zeigen könntest, wie es geht wäre ich dir sehr Dankbar.

MfG
Sunny611

 

[partsch]

Naja ich hab mal hier ne Lösung geschrieben für die 2 Funktionen aber ist eher nur profesorisch (keine Fehlerabfragen und search(String name) kann man um einiges besser schreiben) aber das sollte dir helfen mal den Ansatz bei deiner Aufgabe zu finden.
Info: Der Benutzer muss jeweils vor dem Element die richtige bezeichnung davon schreiben. (du wirst diese im BeispielArray schon sehen)

public class Kundenverwaltung {

	private String[][] daten;
	private String firmenName;

	public Kundenverwaltung(String[][] daten, String firmenName) {
		this.daten = daten;
		this.firmenName = firmenName;
	}

	public static void main(String... args) {
		String[][] daten = {
				{ "firstName Hans", "land Österreich", "numb 00001", "secName Martinsson" },
				{ "land Schweiz", "firstName Kurt", "numb 00002", "secName Wallander" },
				{ "numb 00003", "secName Bergmann", "firstName Rune", "land Deutschland" } };
		Kundenverwaltung k = new Kundenverwaltung(daten, "OptiTravel");
		k.sort();
		k.print();
		System.out.println("Die Suche:");
		k.search("Kurt Wallander");
	}
	
	public void sort() {
		for (int i = 0; i < daten.length; i++) { /* zeilen durchgehen */
				String[]matchPat = {"numb ", "firstName ", "secName ", "land "}; /*  in dieser folge müssen die daten geordnet sein */
				String[]sortRow = new String[daten[i].length]; /* "zwischen speicher" der geordneten zeile */
				for(int j=0; j<matchPat.length; j++){ /* die korrekte folge durchgehen und in sortRow den jeweiligen String richtig einfügen*/
					for(int k=0; k<daten[i].length; k++){ /* jede einzelne spalte der zeile durch gehen */
						if(daten[i][k].contains(matchPat[j])){ /* abfragen ob der String das derzeit gesuchte element enthält */
							sortRow[j] = daten[i][k].substring(matchPat[j].length()); /* wenn ja einfügen in die richtige stelle in der sortRow*/
							break;
						}
					}
				}
				daten[i] = sortRow; /* reihe ersetzen */
		}
	}
	
	public void search(String name){
		String[]components = name.split(" ");
		String firstName = components[0], secName = components[1];
		for(int i=0; i<daten.length; i++){
			if(daten[i][1].equals(firstName) && daten[i][2].equals(secName)){
				System.out.println(daten[i][0]+", "+daten[i][1]+" ,"+daten[i][2]+" ,"+daten[i][3]);
			}
		}
	}

	public void print() {
		System.out.println("Kundenverwaltung der Firma " + firmenName);
		for (int i = 0; i < daten.length; i++) {
			for (int j = 0; j < daten[i].length; j++) {
				System.out.print(daten[i][j] + "   ");
			}
			System.out.println();
		}
	}

}

@edit: sort könnte man mit matches schöner gestalten dann wären auch die Zusatzworte unnötig

 

[Freddii]

[offtopic]Das ist typisch für w3l Aufgaben das die doof gestellt sind, gewöhn dich schonmal dran Hätte ich einen ordentlichen Laptop hätte ich die alten Programme noch, aber find die nicht mehr [/offtopic]

 

[dngfng]

String[][] daten = {
                { "firstName Hans", "land Österreich", "numb 00001", "secName Martinsson" },
                { "land Schweiz", "firstName Kurt", "numb 00002", "secName Wallander" },
                { "numb 00003", "secName Bergmann", "firstName Rune", "land Deutschland" } };

In der aufgabe wurde doch die reinfolge der daten definiert - also müsste die Datenstruktur doch wohl er so aussehen:

String[][] daten = {
                { "00001", "Meiser", "Hans", "Adresse" },
                { "00002", "Bauer", "Alois", "Adresse" },
                { "00003", "Bergmann", "Rune", "Adresse" } };

Die Aufgabe spezifiziert das man die Sortiere Relevanz einstellen können muss. Die rein-folge der Felder ist definiert.


Also das man die rein folge der Einträge in der Array um sortiert und nicht die rein-folge der Datenfelder innerhalb des Datensatzes.


So das man entweder nach Kunden Nummer, Name, Vorname, Adresse.

Oder nach jeder andres beliebigen rein folge sortieren kann.

Erst nach Namen, Vorname, Adresse, Kunden, Nummer

Oder jede andre möglich Kombination.

Hierzu muss man einen Bubble sort auf das Primäre Sortiere Feld ausführen und falls diese dem nächsten Satz gleichen sollte dann die andren Sortiere folgen ausführen in der angegeben rein folge.

 

[dngfng]

Ich habe mir mal die Mühe gemacht die Sortiere Funktion zu Programmieren.

public class Sorter {
	
	private boolean ascending = true;
	
	private int firstOrder = 0;
	private int secondOrder = 1;
	private int thirdOrder = 2;
	private int fourthOrder = 3;
	
	/**
	 * Es muss angegeben werden in welcher reinfolge die Felder Sortiert werden sollen.
	 * 0-3 
	 * 
	 * 
	 * @param first - Das Primare Sortier Feld
	 * @param second - Das Secondare Sortier Feld
	 * @param third - Das Dritte Sortier Feld
	 * @param fourth - Das Vierte Sortier Feld
	 * @param ascending - boolean ob Ab oder Aufsteigend sortiert werden soll.
	 */
	public Sorter(int first, int second, int third, int fourth, boolean ascending) {
		this.firstOrder = first;
		this.secondOrder = second;
		this.thirdOrder = third;
		this.fourthOrder = fourth;
		this.ascending=ascending;
	}
	
	public String[][] sortStringBubble(String input[][]) {
		if(ascending){
			return sortStringBubbleAscending(input);
		} else {
			return sortStringBubbleDescending(input);
		}
	}
	
	/**
	 * Abfallend Sortieren
	 * 
	 * @param input
	 * @return
	 */
	public String[][] sortStringBubbleDescending( String input [][]) {
	      int j;
	      boolean flag = true;  //Flag bo Sortirung Abgescholssen ist
	      String temp[] = {"","","",""};
	
	      while (flag) {
	            flag = false;
	            for ( j = 0;  j < input.length - 1;  j++ ) {     
	            		int firstComp = input[j][firstOrder].compareToIgnoreCase(input[ j+1 ][firstOrder]);
	            	
	            		if (firstComp < 0) {                                             
	                                temp = input[j];
	                                input[j] = input[j+1];     
	                                input[j+1] = temp;
	                                flag = true;
	                     } else if(firstComp==0) {
	                    	 int secondComp = input[j][secondOrder].compareToIgnoreCase(input[ j+1 ][secondOrder]);
	                    	 
	                    	 if(secondComp < 0) {
	                                temp = input[j];
	                                input[j] = input[j+1];     
	                                input[j+1] = temp;
	                                flag = true;
	                    	 } else if(secondComp==0){
		                    	 int thirdComp = input[j][thirdOrder].compareToIgnoreCase(input[ j+1 ][thirdOrder]);
		                    	 
		                    	 if(thirdComp < 0) {
		                                temp = input[j];
		                                input[j] = input[j+1];     
		                                input[j+1] = temp;
		                                flag = true;
		                    	 } else if(thirdComp==0){
			                    	 int fourthComp = input[j][fourthOrder].compareToIgnoreCase(input[ j+1 ][fourthOrder]); 
			                    	 if(fourthComp < 0) {
			                                temp = input[j];
			                                input[j] = input[j+1];     
			                                input[j+1] = temp;
			                                flag = true;
			                    	 } 
		                    	 }
	                    	 }
	                    	 
	                     }
	             }
	      }
	      return input;
	} 

	/**
	 * Aufsteigend Sortieren
	 * 
	 * @param input
	 * @return
	 */
	public String[][] sortStringBubbleAscending( String input [][]) {
	      int j;
	      boolean flag = true;  //Flag bo Sortirung Abgescholssen ist
	      String temp[] = {"","","",""};
	
	      while (flag) {
	            flag = false;
	            for ( j = 0;  j < input.length - 1;  j++ ) {     
	            		int firstComp = input[j][firstOrder].compareToIgnoreCase(input[ j+1 ][firstOrder]);
	            	
	            		if (firstComp > 0) {                                             
	                                temp = input[j];
	                                input[j] = input[j+1];     
	                                input[j+1] = temp;
	                                flag = true;
	                     } else if(firstComp==0) {
	                    	 int secondComp = input[j][secondOrder].compareToIgnoreCase(input[ j+1 ][secondOrder]);
	                    	 
	                    	 if(secondComp >0) {
	                                temp = input[j];
	                                input[j] = input[j+1];     
	                                input[j+1] = temp;
	                                flag = true;
	                    	 } else if(secondComp==0){
		                    	 int thirdComp = input[j][thirdOrder].compareToIgnoreCase(input[ j+1 ][thirdOrder]);
		                    	 
		                    	 if(thirdComp>0) {
		                                temp = input[j];
		                                input[j] = input[j+1];     
		                                input[j+1] = temp;
		                                flag = true;
		                    	 } else if(thirdComp==0){
			                    	 int fourthComp = input[j][fourthOrder].compareToIgnoreCase(input[ j+1 ][fourthOrder]); 
			                    	 if(fourthComp>0) {
			                                temp = input[j];
			                                input[j] = input[j+1];     
			                                input[j+1] = temp;
			                                flag = true;
			                    	 } 
		                    	 }
	                    	 }
	                    	 
	                     }
	             }
	      }
	      return input;
	} 
}

Hier ist ein Beispiel Testaufruf der Funktion:

public class CustSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		//Daten Struktur
		String[][] customers = {
				{"0003","Bauer","Robert","Russland"},
				{"0003","Bauer","Bernd","Deutschland"},
				{"0001","Xan","Antony","China"},
		};
		
		//Angabe der Sortier reinfolge in diesen Fall Land,Nachname,Vorname,Nummer,Abfallend Sortiert
		Sorter sort = new Sorter(3,1,2,0,false); 
		customers = sort.sortStringBubble(customers); //Aufruf Sortier Funktion
		
		//Ausgabe der Sortierten Liste
		for(int i=0;i<customers.length;i++) {
			String[] output = customers[i];
			System.out.println("------------------");
			for(int j=0;j<output.length;j++) {
				System.out.println(output[j]);
			}
		}
	}

}

 

[SlaterB]

	            		int firstComp = input[j][firstOrder].compareToIgnoreCase(input[ j+1 ][firstOrder]);
	            	
	            		if (firstComp < 0) {                                             
	                                temp = input[j];
	                                input[j] = input[j+1];     
	                                input[j+1] = temp;
	                                flag = true;
	                     } else if(firstComp==0) {
	                    	 int secondComp = input[j][secondOrder].compareToIgnoreCase(input[ j+1 ][secondOrder]);
	                    	 
	                    	 if(secondComp < 0) {
	                                temp = input[j];
	                                input[j] = input[j+1];     
	                                input[j+1] = temp;
	                                flag = true;
	                    	 } else if(secondComp==0){
		                    	 int thirdComp = input[j][thirdOrder].compareToIgnoreCase(input[ j+1 ][thirdOrder]);
		                    	 
		                    	 if(thirdComp < 0) {
		                                temp = input[j];
		                                input[j] = input[j+1];     
		                                input[j+1] = temp;
		                                flag = true;
		                    	 } else if(thirdComp==0){
			                    	 int fourthComp = input[j][fourthOrder].compareToIgnoreCase(input[ j+1 ][fourthOrder]); 
			                    	 if(fourthComp < 0) {
			                                temp = input[j];
			                                input[j] = input[j+1];     
			                                input[j+1] = temp;
			                                flag = true;
			                    	 } 
		                    	 }
	                    	 }
	                    	 
	                     }
	             }
	      }

worum immer es hier auch geht, einen solchen Code darf man ja kaum in die Welt lassen,
kürzer wäre

int c = compare(input, j, firstOrder);
if (c == 0) {
  c = compare(input, j, secondOrder);
}
if (c == 0) {
  c = compare(input, j, thirdOrder);
}
if (c == 0) {
  c = compare(input, j, fourthOrder);
}
if (c < 0) {                                             
   temp = input[j];
   input[j] = input[j+1];     
   input[j+1] = temp;
   flag = true;
}

private int compare(array, index, order) {
 return element index .compareToIgnoreCase( element index +1 )
}

oder auch noch die 4 Orders in ein Array stecken und per Schleife den Anfang weiter kürzen

Ascending oder Descending ist dann auch nur an einer Stelle < oder >,
das kann man per Parameter in einer Methode machen, nicht den Code komplett kopieren

 

[dngfng]

Dein Code ist sicherlich effizienter und eleganter, keine Frage.

Allerdings wollte ich auch nicht gerade viel Zeit hiermit verbringe und einfach mal eine Beispiel Lösung bereitstellen. Daher habe ich einfach mal schnell einen schlichten Bubblesort umgebaut.

Außerdem finde ich ja das man keine Vorbildlichen Musterlösung bereitstellen sollte - ein bisschen Arbeit sollten die Herrn von der Uni auch noch rein stecken.

 

[sunny611]

Vielen Dank für all eueren antworten, alles hat mir bei den ansätzen geholfen, aber es gibt ein problem, das wir nur sachen benutzen dürfen was wir auch gelernt haben. WIr müssen dafür ein Ergebnisfeld benutzen.
Das Problem liegt darin, dass alle Kundendaten sortiert werden und somit vermischt werden, d.h. es passt nicht mehr zu einer Person. für die eingabe benutzen wir ein vorgegebenes Paket inout.
Für die Suche im Aufgabenteil b habe ich auch noch keinerlei Idee.
Ich bitte um rasche Antwort da morgen die Abgabe ist.

import inout.Console;

    public class Ereignisfelder 
    {
        public static void main(String[] args) 
        {
            int pos,posMin, spalte,steigung,a=0,b=0;
            String min,merke;
            final String[][] Kundendaten = 
            {{"888","Klug","Max","Herner Straße 88"},
            {"943","Meyer","Udo","Bochumer Straße 88"},
            {"159","Ross","Birgit","Essener Straße 38"},
            {"121","Heyer","Dirk","Joseph Straße 77"}
        };
        final String[][] Ergebnisfeld = new String[4][4];
      System.out.println("Soll es aufsteigend oder absteigend Sortiert werden? \n(Aufsteigend = 0, Absteigend = 1): ");
      steigung = Console.readInt();
      for(int x =0;x<4;x++)
        {
            System.out.println("Bitte Geben Sie an wonach sortiert werden soll \n(Kundennummer = 0,Nachname = 1,Vorname = 2,Straße = 3)) : ");
            spalte = Console.readInt();
            if(steigung == 0 || steigung ==1)
            {
                if (steigung==0)
                {
                    for(int zeile = 0;zeile < Kundendaten.length; zeile++)
                    {
                        posMin = zeile; min = Kundendaten[zeile][spalte];
                        for(pos=zeile+1;pos<Kundendaten.length;pos++)
                        if(Kundendaten[pos][spalte].compareTo(min) < 0)
                        {
                            min= Kundendaten[pos][spalte];
                            posMin = pos;
                        }
                        merke = Kundendaten[zeile][spalte];
                        Kundendaten[zeile][spalte]= Kundendaten[posMin][spalte];
                        Kundendaten[posMin][spalte] = merke;
                        Ergebnisfeld[a][b]= Kundendaten[zeile][spalte];
                        a++;
                        if(zeile == 3)
                        {b++;}
                    }         
                }
                if (steigung==1)
                {
                    for(int zeile = 0;zeile < Kundendaten.length; zeile++)
                    {
                        posMin = zeile; min = Kundendaten[zeile][spalte];
                        for(pos=zeile+1;pos<Kundendaten.length;pos++)
                        if(Kundendaten[pos][spalte].compareTo(min) > 0)
                        {
                            min= Kundendaten[pos][spalte];
                            posMin = pos;
                        }
                        merke = Kundendaten[zeile][spalte];
                        Kundendaten[zeile][spalte]= Kundendaten[posMin][spalte];
                        Kundendaten[posMin][spalte] = merke;  
                        Ergebnisfeld[a][b]= Kundendaten[zeile][spalte];
                        a++;
                        if(zeile == 3)
                        {b++;}
                    } 
                }
            }
            else 
       System.out.println("Ungültige Eingabe ! Aufsteigend = 0 oder Absteigend = 1 EINGEBEN: ");
       a=0;
    }
       for(int i=0;i<=3;i++)       
        {
             System.out.println();
            for(int j=0;j<=3;j++)
                {
                    System.out.print(Ergebnisfeld[i][j]+"\t\t");
                }
        
    }
}

   }

 

[dngfng]

Das liegt daran das du die einzelnen Felder verschiebst anstatt den ganzen Datensätze.

Kundendaten[zeile][spalte]; Referenziert einen Wert.

Beim Verschieben musst du allerdings die Ganze Zeile verschieben also nur
Kundendaten[Zeile];

Und diese dir dann entsprechend merken und verschieben.

String[] merke = Kundendaten[zeile];

Kundendaten[zeile] = Kundendaten[<die einzufügende zeile>];
Kundendaten[<die Zielzeile>] = merke;

Des weiteren musst du das auch mal logisch angehen.

Du sollst doch die Datensätze Sortieren - also die Datensätze sollen unverändert bleiben nur in richtiger rein folge.

Es soll möglich sein die Sortiere rein folge zu spezifizieren ob zuerst nach Kundennummer eines der andren Felder sortiert werden soll. Also nur wenn das Primäre Sortiere Feld gleich dem andren ist werden die andren erst zu rate gezogen. Also wenn man Primäre nach Namen Sortier und man zwei Bauer hat dann erst sollten das Zweite Feld zurate gezogen werden ob diese umgedreht werden müssen oder nicht.

Zurzeit schleifst du über alle Felder und sortierst dies unabhängig von einander erst sortierst du alle nummern dann Namen etc.... Diese bringt natürlich alles durcheinander.

Schau dir doch bitte noch mal meinen Code an bzw. die verbesserte Version von SlaterB.
Dies Sortiert deine Datensätze wie angefordert.

 

[sunny611]

Danke für die rasche antwrt, aber wie ich dir schon gesagt habe dürfen wir nur dies benutzen was wir gelernt haben und dies was du bzw slater B geschrieben hat, da verstehe ich vorne und hinten nichts und wie soll ich es meinen tutor erklären .

zu deinen tipps die funktionieren nicht da, da du Kundendaten nicht mit einen punkt aufrufen kannst.
wie du es geschrieben hast greift er auf ein eindimensionales feld und wir haben en zweidimensionales feld.

daher meckert das programm.

MfG

sunny611

 

[dngfng]

Du sollst doch auch gar nicht Kundendaten mit einen Punkt aufrufen.

Eine Zweidimensionale Array sind ja Array in einer Array.

Also wenn du

Kundendaten[0];

Abfragst kriegst du einen Array von String zurück. An den einzelnen String(Feld) kommst du ran in dem du diesen mit Kundendaten[zeile][spalte] aufrufst diesen kannst du dann mit String operatoren bearbeiten bzw vergleichen.

Nach dem du die spalten verglichen hast musst du ja die komplette Zeile verschieben.

sprich:

String [] zwischspeicher =  Kundendaten[x];
Kundendaten[0] = Kundendaten[x+1];
Kundendaten[x+1] = zwischenspeicher;

So kannst du die kompletten Zeilenvertauschen.

 

[dngfng]

//Wiederholt sich solange die Zeilen noch nicht alle sortiert sind.
while (flag) {
                flag = false;

                //Schleift über alle Zeilen.
                for ( zeile = 0;  j < input.length - 1;  zeile++ ) {

int c = compare(KundenDaten, zeile, 0); //Kunden Nummer wird verglichen

//Wenn der erste Feld vergeleich gleich ist dann wird das
//zweiten Felder miteinenander verglichen usw.
if (c == 0) {
  c = compare(KundenDaten, zeile, 1); //Nachname wird verglichen
}
if (c == 0) {
  c = compare(KundenDaten, zeile, 2); //Vorname wird verglichen
}
if (c == 0) {
  c = compare(KundenDaten, zeile, 3); //Adresse wird verglichen
}
//Falls die derzeitige zeile kleiner ist als die verglichene werden diese vertauscht.
if (c < 0) {                                             
   temp = KundenDaten[j];    //Derzeitger satz wird zwischengespeichert.
   input[zeile] = KundenDaten[zeile+1];     //Der folgende Satz wird in die derzeitige Position verschob.
   input[zeile+1] = KundenDaten; //der Derzeitige Satz wird in die Freigeworden Pos Geschrieben.
   flag = true;
}
}
}

//Die Funkition compareToIngnoreCase gibt eine int zurück.
//Posetive bedeutet ist Größer.
//Negative bedeutet ist Kleiner.
//0 Bedeutet ist gleich.
private int compare(String [][] array, int zeile, int feld) {
 return array[zeile][feld].compareToIgnoreCase( array[zeile+1][feld] );
}

 

[SwizZ]

Ich sitze gerade neben dem TE!

Ja klar ist richtig, aber irgendwie wissen wir vor lauter hin und her nicht mehr was mit was verglichen werden soll.

D.h. die for Schleife mit x muss weg, da das Programm nur noch einmal durchlaufen soll. Dann nimmt er sich einen eingegebenen Wert in die variable spalte, und sortiert dies auch richtig. Allerdings wie er sich dann den Rest der geforderten zeile holt ist uns unbekannt!
Wie kann ich ihm vor allem dann noch die Reihenfolge vorgeben? D.h. das in Spalte 1 der nachname steht ( welcher nur sortiert wird ) in der 2. meinetwegen die adresse dann die kundennummer und dann der vorname?

Liebe Grüße
Und danke schonmal

SwizZ

 

[dngfng]

Durch die euser while schleife wird immer wieder über die Sätze iteriert bis keine satz mehr zu verschieben ist.

boolean satzVerschoben= true;

while(satzVerschoben) {
satzVerschoben=false;
for(int zeilen=0;zeilen<kunden.length;zeilen++) {

<Vergleiche>

if(c<0) {
<verschieben>
satzVerschogen=true;
}
}
}

 

[SwizZ]

BlueJ kennt den Befehl überhaupt nicht. Der meckert sofort rum, dass er die methode nicht kennt!
Wir haben diesen Befehl auch einfach nicht gelernt, ich weiß nicht... irgendwie ist man so nah am Ziel und man sieht die Lösung einfach nicht.
Ich sitze heute schon Stunden daran und komm nun einfach nicht mehr weiter.
Habe auch keine Idee mehr...

lg
SwizZ

 

[dngfng]

Welchen Befehl denn?

 

[SwizZ]

Hey,

wollte mich noch kurz zurückmelden... wir haben den Fehler in unserer Lösung gefunden. Und zwar haben wir in den jeweiligen if Anweisungen zwar sortiert, dies allerdings nur für ein eindimensionales Feld getan und nicht für die gesamte 4 x 4 Matrix! Haben wir dieses nun geändert, funktioniert das Programm einwandfrei.
Die SuFu dann einzubinden war auch sehr einfach.

Vielen Dank an alle Beteiligten hier Ihr habt uns sehr geholfen!


Liebe Grüße
SwizZ