# Sortieren von einem 2 dimensionalen Array



## thedirm (30. Dez 2010)

Hallo liebes Forum,
ich bin neu hier und habe gerade ein Informatik Fernstudium begonnen. :autsch:
Wir haben als Aufgabe bekommen, Kundendaten aus einem 2 dimensionalen Array zu lesen und Abhängig von dem Index die Werte des Arrays sortiert auszugeben.
Ich habe nun ein bisschen probiert, aber so richtig sortiert er es nicht. Vielleicht hat ja jemand erbarmen und kann mir einen Tipp geben, wo ich die Fehler platziert habe.
Ich kann leider nur compareTo benutzen, da wir nicht weiter sind und ich schlecht dann andere Sortier- Funktionen nutzen kann. Vielen lieben Dank für eure Hilfe und Gruß, Dirk.


```
import inout.Console;

class OptiTravel
{ 
    public static void main (String args[]) 
    { 
        /*
        String[][] kunden = {{"1234", "Calrissian", "Lando", "Wolkenstadt 1" },
                             {"7891", "Organa" , "Leia", "Rebellenplatz 2"},
                             {"4582", "Solo", "Han", "Schmugglerweg 4"},
                             {"5821", "Skywalker", "Luke", "Jediallee 6"}};
        */
        String[][] kunden = {{"Meyer","1"},{"Schulz","2"},{"Balzert","3"}};
            
        sortieren(kunden);
        System.out.println("Ausgabe: \n--------" );
        for (int j = 0; j < kunden.length; j++)
            {
            int pos = j;
                for (int i = 0; i < kunden[1].length; i++) 
                    System.out.println(kunden[pos][i]);
                }
            
    }

    static void sortieren(String[][] kdNeu)
    {
        int pos, posMin;
        String min;

        System.out.println("Bitte Auswahl eingeben :");
        int auswahl = Console.readInt();

        for (int i= 0; i < kdNeu.length; i++)
        { 
            posMin = 1;
            min = kdNeu[posMin][auswahl];
            
            for (pos = i+1; pos<kdNeu.length; pos++)
               if (kdNeu[i][auswahl].compareTo(min)< 0)
               {
                  min = kdNeu[pos][auswahl];
                  posMin = pos;
                  System.out.println("posMin " + posMin);
               }  
            String[] temp = kdNeu[i];
            kdNeu[i] = kdNeu[posMin];
            kdNeu[posMin] = temp;
        }
    }
}
```


----------



## homer65 (30. Dez 2010)

Deinen Code durchschaue ich nicht.
Aber vom Grundsatz her solltest du das 2 dimensionale Array in ein 1 dimensionales kopieren, das dann sortieren und anschließend wieder zurückkopieren.


----------



## thedirm (30. Dez 2010)

Hallo Homer65,
ich will die Arrays. Anhand der Inhalte sortieren:
Beispiel:
{Meyer, 9734},{Schulze, 5678} wähle ich Index 0, soll beispielsweise so sortiert werden,
Ausgabe
Meyer,9734
Schulze,5678
Sortiere ich nach Index 1, soll die Ausgabe danach erfolgen.
Schulze,5678
Meyer,9734
Ist vielleicht etwas konfus, sorry dafür. Aber danke für die Hilfe.


----------



## Marco13 (31. Dez 2010)

Du kannst http://download.oracle.com/javase/6/docs/api/java/util/Arrays.html#sort(T[],%20java.util.Comparator) verwenden, und einfach vescheidene Comparatoren verwenden. Zu Comparatoren gibt's hier auch einen FAQ-Eintrag.


----------



## tagedieb (31. Dez 2010)

```
posMin = 1;
```

1. begint ein Array mit Index 0
2. wenn element 1 bei jedem durchlauf immer defaultmaessig als kleinstes element markiert wird wirst du fuer die positionen > 1 keine kleineren elemente mehr finden, da element 1 das kleinste bleibt.


Versuchs mal mit 
	
	
	
	





```
posMin = [COLOR="Red"]i[/COLOR];
```


----------



## pilx (31. Dez 2010)

Bucket Sort könnte interessant sein.


----------



## thedirm (31. Dez 2010)

Vielen Dank erst einmal an alle die mit eine Antwort gegeben haben. Leider kann ich wie gesagt keine anderen Funktionen nutzen, wie Bucket Sort oder ähnliche. Laut Lehrplan kenne ich erst einmal nur compareTo 
Ich glaube ich habe es jetzt aber fertig :bahnhof:


```
import inout.Console;

class OptiTravel
{ 
    public static void main (String args[]) 
    { 
        String[][] kunden = {{"1234", "Calrissian", "Lando", "Wolkenstadt 1" },
                             {"7891", "Organa" , "Leia", "Rebellenplatz 2"},
                             {"4582", "Solo", "Han", "Schmugglerweg 4"},
                             {"5821", "Skywalker", "Luke", "Jediallee 6"}};
        //String[][] kunden = {{"Zeyer","1"},{"Wchulz","2"},{"Aalzert","3"}};
            
        sortieren(kunden);
        System.out.println("Ausgabe: \n--------" );
        for (int j = 0; j < kunden.length; j++)
            {
            int pos = j;
                for (int i = 0; i < kunden[1].length; i++) 
                    System.out.println(kunden[pos][i]);
                    System.out.println("================");
                }
            
    }

    static void sortieren(String[][] kdNeu)
    {
        int pos, posMin;
        String min;

        System.out.println("Bitte Auswahl eingeben :");
        int auswahl = Console.readInt();

        for (int i= 0; i < kdNeu.length; i++)
        { 
            posMin = i;
            min = kdNeu[i][auswahl];
            for (pos = i+1; pos<kdNeu.length; pos++)
               if (kdNeu[pos][auswahl].compareTo(min) < 0)
               {
                  min = kdNeu[pos][auswahl];
                  posMin = pos;
                  System.out.println("CompareTo: "+ min);
               }  
            String[] temp = kdNeu[i];
            kdNeu[i] = kdNeu[posMin];
            kdNeu[posMin] = temp;
        }
    }
}
```

Geändert habe ich das, wie vom Tagedieb angemerkt, posMin=1 in posMin=i und if (kdNeu_[auswahl].compareTo(min) < 0) in if (kdNeu[pos][auswahl].compareTo(min) < 0). 
Vielen Dank noch einmal und guten Rutsch ins neue Jahr. Und immer drank denken, nur soviel trinken wie man auch tragen kann _


----------



## XHelp (31. Dez 2010)

Bei dir ist aber 9 größer als 1000, weil du das ganze als String behandelst.


----------



## tagedieb (31. Dez 2010)

```
if (kdNeu[pos][auswahl].compareTo(min) <[B][COLOR="Red"]=[/COLOR][/B] 0)
```

Wieso hast du die Bedingung auf kleiner-gleich geaendert? Wenn die Werte gleich sind brauchst du die Positionen ja nicht vertauschen??


----------



## thedirm (31. Dez 2010)

@tagedieb
habe ich nur zu probieren mal eingefügt und dummerweise mit gepostet, soll aber nur "<0" heissen.
Habe ich im Post korrigiert.
@xhelp
da hast du natürlich recht, aber ich glaube so tief soll dann die Aufgabe nicht werden. Man hat eigentlich nur 60 Minuten für die Aufgabe. Keine Ahnung wie ich dies in der Zeit schaffen soll. Ich setze einfach mal fest, dass die Nummern am Anfang von 1000 bis 9999 festgelegt sind


----------



## ezdvftsaG (2. Jan 2011)

Es kommt darauf an, ob das Sortieren selbst umgesetzt werden soll oder nicht. Wenn dafür bestehende Methoden benutzt werden dürfen (jedes Element hat eine Methode compareTo?), könnte man es mit java.util.Arrays.sort so erledigen:


```
import java.util.Arrays;
import java.util.Comparator;

public class Cla {

public static void sort2DArray(Comparable[][] caa, final int index) {
    
    Arrays.sort(caa, new Comparator<Comparable[]>() {
        public int compare(Comparable[] a1, Comparable[] a2) {
            return a1[index].compareTo(a2[index]);
        }
    });
}

public static void main (String[] args) {
    Comparable[][] caa = new Comparable[][] {
                    { "z", "2" },
                    { "e", "1" },
                    { "d", "3" },
                };
    
    sort2DArray(caa, 0);

    for (Comparable[] ca : caa) {
        System.out.println(Arrays.toString(ca));
    }
    System.out.println();
    
    sort2DArray(caa, 1);

    for (Comparable[] ca : caa) {
        System.out.println(Arrays.toString(ca));
    }
    System.out.println();
}

}
```

Wenn nicht, müsste man eine Methode schreiben, die das Sortieren eines solchen Arrays nach gegebenem Index erledigt. 2D-Arrays sind so aufgebaut, dass deren Elemente wiederum Arrays sind, und deren Elemente endlich vom angegeben Typ (Comparable ist eine Schnittstelle, die compareTo deklariert) sind.

Ein einfacher Algorithmus, der sich unproblematisch nicht-rekursiv programmieren lässt, ist Sortieren durch Einfügen:


```
public static void sort(Comparable[][] caa, final int index) {
	boolean sorted = false;
	while (!sorted) {
		sorted = true;
		for (int i = 0; i + 1 < caa.length; i++) {
			if (caa[i][index].compareTo(caa[i + 1][index]) > 0) {
			/* absteigend oder aufsteigend */
				Comparable[] elem = caa[i + 1];
				caa[i + 1]        = caa[i];
				caa[i]            = elem;
				sorted = false;
			}
		}
	}
}
```

Man könnte den auch so schreiben, dass nicht erst die innere Schleife dann erneut ausgeführt wird, wenn getauscht wurde, sondern sie jedes mal arraylängenabhängig oft ausgeführt wird. So macht man sich zunutze, dass nach endlich vielen Vertauschungen das Array sortiert sein muss - anderenfalls dass spätestens nach einer bestimmten Anzahl an Durchläufen das Array sortiert ist.


----------



## thedirm (2. Jan 2011)

@ezdvftsaG
Sehr eindrucksvoll, vielen Dank. :toll:


----------

