# Mehrdimensionales Array sortieren



## stoi (7. Jan 2014)

Hallo,

Wie kann ich ein Mehrdimensionales Array sortieren?


```
String[][] test = String[10][10];
String[0][0]= String.valueOf(doublevariable);
String[0][1]="Test";
String[1][0]= String.valueOf(doublevariable2);
String[1][1]="Test2";
```

Ich weiß, das ein einfaches Array über Array.sort sortiert werden kann, aber ich möchte, dass der String auch mitsortiert wird. Habt ihr Ideen?

Viele Grüße
stoi


----------



## ursteiner (7. Jan 2014)

Stehen diese beiden Werte in einer festen Beziehung?


```
String[0][0]= String.valueOf(doublevariable);
String[0][1]="Test";
```

Dann sollte man das nicht über ein mehrdimensionales Array lösen.

Schreib dir eine Klasse mit den 2 Attributen. Dann erzeugst du für jedes dieser Paare ein Objekt und steckst es in eine Liste. Danach musst du dir für deine Klasse nur noch einen Komparator schreiben und mit Collections.sort(...) kannst du dann deine Liste sortieren.


----------



## stoi (7. Jan 2014)

Ja, ich möchte Monate sortieren.
Es werden zuerst für jeden einzelnen Monat Standardabweichungen berechnet, und diese möchte ich nach der Größe sortieren. Und dazu soll der zugehörige Monat mitsortiert werden.
Ich probiere es wie oben beschrieben, danke!


----------



## strußi (7. Apr 2014)

Mein Angebot: Eine Methode , die eine Matrix nach einer Spalte sortiert.


```
/**
     * Methode zum Sortieren einer beliebigen Spalte in einem 2Dimensionalen Array
     * @param toSort Array dessen Werte sortiert werden sollen
     * @param colToSort Spalte die sortiert werden soll A C H T U N G - die Zahl muss dem ArrayIndex der Spalte entsprechen
     * @return double[][] mit den sortieren Werten  
     */
    public double[][] sort( double[][] toSort, int colToSort){
        int zeilen =toSort.length; //Zeilenanzahl auslesen
        int spaltenAnzahl =toSort[ zeilen-1].length; //Spaltenzahl auslesen
        int inZeile =0; //Variable für die Zeile in die aus toSort kopiert werden soll
        double vMax =toSort[ 0][ colToSort]; //Anfangswert aus dem zu sortierenden Array auslesen und setzen
        double vMax2 =vMax; //Variable für größten Wert 
        double vMin =0; //Variable für den kleinesten Wert im Array der >0 ist 
        int vMinInZeile =0; //Variable in welcher der Zeilenwert gespeichert wird, in der der kleinste Wert gefunden wurde
        double[][] retVal =new double[ zeilen][ spaltenAnzahl]; //Array in den kopiert werden soll muss die gleiche größe haben wie der Array aus dem Kopiert werdens oll
        if( colToSort <spaltenAnzahl &&colToSort >=0){ //Prüfen ob es die zu sortierende Spalte überhaupt gibt
            while( inZeile <zeilen){ //Solange noch nicht alle Zellen des retVal gefüllt sind
                //Suche den kleinsten Wert
                //erster unbestimmter Suchlauf
                for( int zeilenIndex =0; zeilenIndex <zeilen; zeilenIndex++){ //Suchlauf über alle Zeilen auf der Spalte sToSort
                    if( toSort[ zeilenIndex][ colToSort] <vMax && toSort[ zeilenIndex][ colToSort] >=vMin){ //Sucht den kleinsten Wert >0
                        vMax =toSort[ zeilenIndex][ colToSort]; //Obergrenze nach unten setzen bis der kleinste Wert gefunden ist
                        vMinInZeile =zeilenIndex; //Index der Zeile übergeben, in dem der aktuell kleinste wert gefunden ist
                    } else if( vMax2 <toSort[ zeilenIndex][ colToSort]){ //Prüfen ob der bisherige absolute Maximalwert kleiner ist als als der gerade geprüfte Wert
                        vMax2 =toSort[ zeilenIndex][ colToSort]; //Größter Wert speichern, um für Spätere Durchläufe eine Referenz zu haben
                    } else{} //Im Sonstfall nichts tun
                }
                vMin =vMax; //die Varaible für den kleinsten Wertes mit der gefunden Zahl belegen
                //Ersten Datentupel sichern
                for( int spalte=0; spalte <spaltenAnzahl; spalte++){ //kopieren des einen, sicheren Datentupels und überschreiben des inputs mit 0
                    retVal[ inZeile][ spalte] =toSort[ vMinInZeile][ spalte]; //Kopieren des Datentupels
                    toSort[ vMinInZeile][ spalte] =0; //überschreiben mit 0 damit fällt dieser Datentupel aus der Prüfung  "Suchlauf"
                }
                inZeile++; //Zählervariable des retVal[] in die als nächstes gespeichert werdensoll
                //Abfangen von OutOfBounds
                if( inZeile <zeilen){ //Prüfen ob die Zählervariable noch kleiner ist als die Anzahl der vorhandenen Zeilen
                    //Zweiter Suchlauf nach einer bestimmten Zahl /Wert
                    for( int i =0; i <zeilen; i++){ //Suchlauf über alle Zeilen
                        if( toSort[ i][ colToSort] == vMin && i !=vMinInZeile){ //Prüfen in der Zelle der i-ten Zeile und der zu sortierenden Spalte (sToSort) der gleiche Wert nochmal vorkommt
                            for( int col=0; col <spaltenAnzahl; col++){ //Positiver Fall; den Datentupel kopieren
                                retVal[ inZeile][ col] =toSort[ i][ col]; //Datentupel kopieren
                                toSort[ i][ col] =0; //Gefundener Datentupel mit 0 überschrieben
                            }
                            inZeile++; //Zählervariable auf die nächste Zeile setzen
                            //Abfangen von java.lang.ArrayIndexOutOfBoundsException
                            if( inZeile <zeilen){ //Solange die Zählervariable kleiner als die gesamtzahl der Zeilen ist muss nichts unternommen werden
                            } else{
                                break; //beenden der Sortierung, sonst läuft man in java.lang.ArrayIndexOutOfBoundsException
                            }                            
                        } else{} //Im Sonstfall nichts tun soSort[i][sToSort] != vMin
                    }
                    vMax =vMax2+1; //Der Variablen vMax wird der größte, im Array vorkommenden Wert zugewieden.
                                   //Die Erhöhung um 1 ist nötig, da auf echt < geprüft wird 
                } else{
                    break; //beenden der Sortierung, sonst läuft man in java.lang.ArrayIndexOutOfBoundsException
                } //inZeile ist >=der Anzahl der vorhandenen Zeilen
            }
        } else{ //Fehlermeldung bei der Nutzung in 
            except.MyException miss =new MyException(); //Object von der Fehlerklasse SortierenFehler erstellen
            miss.spaltenFehler( spaltenAnzahl-1); //Aufruf der Methode spaltenFehler( int) mit dem Parameter wieviele Spalten es gibt
        }        
        return retVal; //Das Sortierte Array zurückgeben
    }
```


----------

