Sortierung

public class Sortierung {
    static int array[] ;
    static java.util.Random numberGenerator = new java.util.Random() ;
    static long tStart, tEnd, msecs ;
    public static void main(String[] args) {
        /*
         * Es vergleicht, ob das Array größer als 1 ist, weil sonst das komplette Programm keinen Sinn ergibt.
         * Wenn der erste Parameter keine Zahl ist, dann wird der Fehler gefangen plus das Programm beendet.
         * Kommt es zur einer sonstigen Exception, wird die richtige Anwendung des Programms angezeigt.
         */
        try {
            assert (Integer.parseInt(args[0]) > 1) : "Die Länge des Arrays muss größer als 1 sein!";
            array = new int[Integer.parseInt(args[0])] ;
        } catch (NumberFormatException nfe) {
            System.out.println(" Fehler! Bitte geben Sie als ersten Parameter eine Zahl, die größer als 1 ist, ein!" + "\n" + "Folgende Eingaben werden akzeptiert:" + "\n"
                + "java Sortierung Feldgroesse [insert|merge [auf|ab|rand]]." + "\n"
                + "rand bzw. auf oder ab sind dabei OPTIONAL und bestimmen die Füllungsart des Feldes!") ;
            System.exit(0) ;
        } catch (Exception e) {
            e.printStackTrace() ;
            System.out.println("Fehler!" + "\n"
                + "Starten Sie das Programm wie folgt: java Sortierung Feldgroesse [insert|merge [auf|ab|rand]]." + "\n"
                + "rand bzw. auf oder ab sind dabei OPTIONAL und bestimmen die Füllungsart des Feldes!") ;
            System.exit(0) ;
        }
        // Es prüft, ob 3 Parameter eingegeben sind.
        // Wenn dies zutrifft, dann benutzt es die einzelnen Parameter und führt dementsprechend die Füllung, Zeitmessung und Sortierung aus.
        if (args.length == 3) {
            assert (args[2].equals("auf") || args[2].equals("ab") || args[2].equals("rand")) : "Der dritte Parameter muss entweder \"auf\", \"ab\" oder \"rand\" lauten!" ;
            if (args[2].equals("auf")) {
                fillInAuf(array) ;
            }
            else if (args[2].equals("ab")){
                fillInAb(array) ;
            }
            else {
                fillInRand(array) ;
            }
            assert (args[1].equals("insert") || args[1].equals("merge")) : "Der zweite Parameter muss entweder \"insert\" oder \"merge\" lauten!" ;
            if (args[1].equals("insert")) {
                tStart = System.currentTimeMillis() ;
                insertionSort(array) ;
                tEnd = System.currentTimeMillis() ;
            }
            else {
                tStart = System.currentTimeMillis() ;
                mergeSort(array,0,array.length-1) ;
                tEnd = System.currentTimeMillis() ;
            }
            // Wenn nur 2 Parameter vorhanden sind, dann prüft es, welche da sind und füllt das Array per fillInrand.
            // Es sortiert danach das Array mit InsertionSor ODER MergeSort.
        }
        else if (args.length == 2) {
            assert (args[1].equals("insert") || args[1].equals("merge")) : "Der zweite Parameter muss entweder \"insert\" oder \"merge\" lauten!" ;
            fillInRand(array) ;
            if (args[1].equals("insert")) {
                tStart = System.currentTimeMillis() ;
                insertionSort(array) ;
                tEnd = System.currentTimeMillis() ;
            }
            else {
                tStart = System.currentTimeMillis() ;
                mergeSort(array,0,array.length-1) ;
                tEnd = System.currentTimeMillis() ;
            }
        }
        else if (args.length == 1) {
            fillInRand(array) ;
            tStart = System.currentTimeMillis() ;
            mergeSort(array,0,array.length-1) ;
            tEnd = System.currentTimeMillis() ;
        }
        msecs = tEnd - tStart ;
        // Wenn das Array HÖCHSTENS 100 Elemente enthält, soll das Feld wiedergegeben werden.
        if (array.length <= 100) {
            printArray(array) ;
        }
        // Die Meldung über den Zustand der Sortierung.
        if (isSorted(array)) {
            System.out.println("Das Feld ist sortiert!") ;
        }
        else {
            System.out.println("Das Feld ist NICHT sortiert!") ;
        }
        // Zeitmessung
        System.out.println("Die Sortierung dauerte: " + msecs + " millisekunden!");
    }
    // Die Befüllung in aufsteigender Reihenfolge.
    public static void fillInAuf(int[] array) {
        for (int i=0;i<array.length;i++) {
            array[i] = i ;
        }
    }
    // Die Befüllung in absteigender Reihenfolge.
    public static void fillInAb(int[] array) {
        int counter = array.length-1 ;
        for (int i=0;i<array.length;i++) {
            array[i] = counter ;
            counter-- ;
        }
    }
    // Die Befüllung in zufälliger Reihenfolge.
    public static void fillInRand(int[] array) {
        for (int i=0;i<array.length;i++) {
            array[i] = numberGenerator.nextInt();
        }
    }
    // Das Array wird auf Sortierung geprüft.
    public static boolean isSorted(int[] array) {
        for (int i=0;i<array.length-1;i++) {
            if (!(array[i] < array[i+1])) {
                return false;
            }
        }
        return true;
    }
    // Es zeigt das Array auf der Konsole.
    public static void printArray(int[] array) {
        for (int i=0 ; i<array.length ; i++) {
            System.out.println(array[i]) ;
        }
    }
    // Der InsertionSort Algorithmus.
    public static void insertionSort(int[] array) {
        for (int j=1 ; j<array.length ; j++) {
            int key = array[j] ;
            int i = j ;
            while(i>0 && array[i-1] > key) {
                array[i] = array[i-1] ;
                i-- ;
            }
            array[i] = key ;
        }
    }
    // Der MergeSort Algorithmus.
    public static void mergeSort(int[] array, int left, int right) {
        if (left < right) {
            int q = (left + right) / 2 ;
            mergeSort(array, left, q) ;
            mergeSort(array,q+1, right) ;
            merge(array,left, q, right) ;
        }
    }
    // Die Hilfsmethode für MergeSort.
    public static void merge(int[] array, int left, int center, int right) {
        int[] arr = new int[array.length] ;
        int i, j ;
        for (i = left; i <= center; i++) {
            arr[i] = array[i] ;
        }
        for (j = center + 1; j <= right; j++) {
            arr[right + center + 1 - j] = array[j];
        }
        i = left;
        j = right;
        for (int k = left ; k <= right ; k++) {
            if (arr[i] <= arr[j]) {
                array[k] = arr[i] ;
                i++ ;
            } else {
                array[k] = arr[j] ;
                j-- ;
            }
        }
    }
}