Sortieren

[Mikrowelle]

Hallo
Nachdem ich die Woche damit verbracht habe muss ich jetzt kapitulieren. Und Morgen schon die Abgabe. Für jegliche Hilfe wäre ich sehr sehr sehr sehr dankbar.

Ein Chef Zwerg bekommt Zahlen, und muss diese der grösse nach in einem Array sortieren. (Als Tip steht das es sinnvoll wäre 2DArray zu benutzen. Wobei ich nicht weis ob ein 2D Array reicht oder es mehrere sein sollten)

drei Zahlen | 212, 52345, 123 |

Alle Zahlen müssen fünf Stellig sein, heisst es wird |00212, 52345, 00123|
Jetzt muss die erste Ziffer betrachtet werden alle Zahlen mit der gleichen Ziffer kommen auf ein "Abstellplatz" mit der entsprechnen Nummer.

Heisst
Abstellplatz 0: 00212, 00123
Abstellplatz 5: 52345

Bis hierhin habe ich es geschaft.

Jetzt schickt der Chef Zwerg an jeden Abstellplatz einen kleinen Zwerg, der das ganze mit von diesen Abstellplatz geholten Zahlen wiederholen muss.Nur dieses mal muss die zweite Ziffer betrachtet werden . Jeder der kleinen Zwerge hat noch einen kleineren Zwerg der es dann mit der dritten Ziffer macht usw...



Am ende soll es rekursiv sein und ein Sortier Array wäre die Belohnung.... ;(
Ich habe so einges versucht aber ich krieg das nur hin das die richtigen Zahlen auf ihre Abstellplätze kommen. Sobald es bis zu der zweiten Ziffer verliere ich den Überblick....

Falls es jemanden Hilft mein Haufen Code zu sehen

Diese Methode soll einen Array von Zahlen erhalten und die Stelle wo verglichen werden soll

static int counter =0; // Soll Irgendwann per IF die Rekursion unterbrechen aber ist auch irgendwie unsinn
static int substringStart=0; // Schneidet die Ziffer an der richtigen Stelle raus
static int substringEnd=1;

    public static int[] sort(int[] zahlen, int ziffer) {
        String formatierterString = null; // Da die Zahlen die Form 00000 haben müssen wandle ich alle in ein String der Form 00000 dann hole ich mir die richige Ziffer als String und wandle es wieder zurück 
        int[][] ablageFach = new int[10][0];

        for (int i = 0; i < zahlen.length; i++) {
            formatierterString = formatierterString.format("%05d \n", zahlen[i]);
            String legeInsFachString = formatierterString.substring(substringStart, substringEnd);
            int legeAufAbstellplatzNR = Integer.valueOf(legeInsFachString);


            ablageFach[legeAufAbstellplatzNR] = legeInFach(ablageFach[legeAufAbstellplatzNR], zahlen[i]);


        }
     
        substringStart++; //
        substringEnd++;
        

        return sort(ablageFach[counter], ziffer);
    }

    /*
     * Kopiert den Inhalt von einem Array in einen grösseren und fügt eine Zahl zu
     * Diese Methode zu schreiben war Teil der Aufgabe
     */
    public static int[] legeInFach(int[] abstellplatz, int zahl) {
        int[] vergroesserterAbstellplatz = Arrays.copyOf(abstellplatz, abstellplatz.length + 1);
        vergroesserterAbstellplatz[vergroesserterAbstellplatz.length - 1] = zahl;

        return vergroesserterAbstellplatz;
    }
    }

 

[MChrista]

Das int-array muss auf [10][1] gesetzt werden. mit 0 hast du gar keine Felder.

Ich glaube einen sortier-Algorithmus kansst dir selber überlegen. Ist beim Array aber ziemlich aufwändig.

 

[Bleiglanz]

mach das rekursiv

nimm deine int's, sortiere sie und verwandle das in ein array von Strings mit fester Länge (führende Nullen)

dann bleibt die Sortierung immer richtig, auch wenn später abgeschnitten wird und du kannst das vergessen

dann machst du einem Baum, wobei jeder Knoten eine Liste von Kindern hat (für "0", für "1", für "2", ...)

public class Knoten {

    private List<Knoten> kinder = new ArrayList<Knoten>();

    private List<String> zahlen = new ArrayList<String>();

    public Knoten(Knoten parent, List<String> azahlen) {

        // erfasse die liste der Strings
        this.zahlen = azahlen;

        // Map: erstes Zeichen zu Liste von Strings
        HashMap<String, List<String>> map = new HashMap<String, List<String>>();

        // Map befüllen
        for (String s : this.zahlen) {
            if (s.length() > 1) {
                String key = String.valueOf(s.charAt(0));
                if (map.containsKey(key)) {
                    map.get(key).add(s.substring(1));
                } else {
                    List<String> value = new ArrayList<String>();
                    value.add(s.substring(1));
                    map.put(key, value);
                }
            }
        }

        for (String key : map.keySet()) {
            kinder.add(new Knoten(this, map.get(key)));
        }
    }

    public void drucke() {
        System.out.print("KNOTEN: ");
        for (String s : this.zahlen)
            System.out.print(s+",");
        System.out.println();
        for (Knoten kind : this.kinder)
            kind.drucke();
    }
}

erzeugen kannst du das dann ganz einfach

        Knoten k = new Knoten(null,Arrays.asList(new String[]{"123","124","125","223","224"}));

 

[Mikrowelle]

Ich habe das jetzt endlich gelöst.
Meine letzte Frage ist, dieses Vefahren ist es zufällig das "Radix Exchange Sort" ?

Ich habe alle VErfahren die es in Wikipedia gibt durchgelesen und das Klingt sehr ähnlich dem was ich machen musste. Bin mir aber nicht sicher.

UPDATE: Die Lösung werde ich nächsten Freitag veröffentlichen können