palindrom_flos_variante

public class Palindrom2 {


    public static void main(String[] args) {
        // TODO Auto-generated method stub


        // TESTCODE ####ANFANG####
        int[] palindromAusgangsArray ={1,2,3,4,5,6,7};

        for( int i=0; i<palindromAusgangsArray.length; i++){
            System.out.print(palindromAusgangsArray[i]);
        }
        int[] palindromErgebnisArray = palindrom(palindromAusgangsArray);
        System.out.println();
        for( int i=0; i<palindromErgebnisArray.length; i++){
            System.out.print(palindromErgebnisArray[i]);
        }
        System.out.println();
        System.out.println("Speicherplatz bzw. hier sieht man dass beide Arrays dieselbe Referenz haben:");
        System.out.println(palindromAusgangsArray);
        System.out.println(palindromErgebnisArray);

        // TESTCODE ####ENDE####


    }

    public static int[] palindrom(int[] palindrom){
        /*
         *  Der Unterschied von meiner Methode zur Musterlösung ist grundsätzlich,
         * dass ich kein neues Array anlege, sondern dass übergebene Array direkt "manipuliere".
         *  Ich muss quasi die erste Ziffer ans Ende hängen, und die letzte Ziffer an den Anfang,
         *  also tausche ich immer den ersten Eintrag mit dem letzten, den zweiten mit dem vorletzten usw. aus,
         *  solange bis zur Hälfte der Länge, da ich ja die Zahl die in der Mitte steht nicht tauschen muss,
         *  denn die hätte ja keinen Tauschpartner. Das erklärt schonmal warum meine for-Loop nur bis vor der Hälfte durchgeht,
         *  und die integer-Variable x hab ich einfach definiert, um nicht überall palindrom.length-1 schreiben
         *  zu müssen. Anschließend kommt folgendes: Kommentar steht direkt über dem Befehl.
         */

        int x= palindrom.length-1;
        for(int i=0; i<(palindrom.length)/2;i++){
            /*
             *
             *  Ich möchte nun die 0-te Stelle in meinem Array mit der Ziffer an der letzten Stelle in meinem
             *  Array ersetzen. Mache ich dies, geht ja die Ziffer an der 0-ten Stelle verloren. ( eh klar oder?)
             *  Genau deswegen muss ich diese Ziffer IMMER "speichern" bevor ich sie ersetze. Dies wird
             *  mit folgender Zeile gemacht: int c = palindrom[i];
             */

            int c=palindrom[i];
            /*
             * So, nun habe ich die Ziffer an der 0-ten Stelle "gespeichert" und kann beruhigt die 0-te Stelle
             * mit der Ziffer in der letzten Stelle des Arrays überschreiben.
             * Die Ziffer an der 0ten Stelle ist nun also nicht mehr 1 sondern 7.
             */
            palindrom[i]=palindrom[x];
            /*
             * So, jetzt habe ich die 0-te Stelle des Arrays richtig gesetzt, denn genau
             * dass muss der Algorithmus ja können. Aber hey, wo ist jetzt die Ziffer von der 0-ten Stelle?
             * Richtig, die habe ich ja unter c "gespeichert". Also
             * setze ich die letzte Stelle mit palindrom[x]=c einfach auf den Wert an der 0-ten Stelle.
             */
            palindrom[x]=c;
            /*
             * x wurde ja oben mit palindrom.length-1 initialisiert. Will ich nun also nicht
             * die letzte Ziffer im Array tauschen sondern die zweitletzte
             * muss ich -1 durchführen. Also wird x mit jedem Schleifendurchgang dekrementiert.
             */
            x--;
            }

        // Veranschaulichung an einem Beispiel-Array komplett durchgeführt
        /*
         * Sei unser Array gefüllt mit 10 11 12 13
         * 10 -> 0.Stelle
         * 11 -> 1.Stelle
         * 12 -> 2.Stelle
         * 13 -> 3.Stelle
         * 1.SCHLEIFENDURCHGANG
         * c = 10
         * Array an der Stelle 0 wird auf den Wert vom Array an der letzten Stelle gesetzt, also auf 13.
         * Array an der Stelle 3(= letzte Stelle) wird auf c gesetzt, also auf 10.
         * 2.SCHLEIFENDURCHGANG
         * c = 11
         * Array an der Stelle 1 wird auf den Wert vom Array an der zweitletzten Stelle gesetzt, da wir "x--" durchgeführt haben!, also auf 12.
         * Array an der Stelle 2 wird auf den Wert von c gesetzt, also 11.
         *
         * Zu diesem Zeitpunkt ist nun i=1 und palindrom.length/2 = 2, also ist dies der letzte
         * Schleifendurchgang, da danach die Bedingung i < palindrom.length/2 nicht mehr zutrifft.
         */

        return palindrom;
    }
}