Array Erste und Letzte Stellen tauschen

Java-Forum Java-Grundlagen
1

Hallo,
ich habe die Aufgabe bei einem Array die ersten und letzten Inhalte zu tauschen
Ich habe dies jedoch nur bei den benachbarten Stellen gemacht gehabt bisher.
Könnt ihr mir nun eine kleine Hilfe geben?

Der Code von meinem Programm bei dem die benachbarten Stellen getauscht werden ist :

{
  public static void main(String[ ] args)
  { 
    int tausch = 0 ; 
    int zaehler = 0 ;
    int[] noten = {3,5,10,3,1,0,18,34,81,2,15,27};

    for (zaehler=0;zaehler<13;zaehler++)
    {
      tausch = noten[zaehler + 1];
      noten[zaehler+1] = noten[zaehler]; 
      noten[zaehler] = tausch ;
    }
  }
}```

Die Aufgabe sollte in einem ähnlichen Schema gelöst werden :)
2

Tauschen von Elementen in einem Array läuft in der Regel immer über einen Dreieckstausch:
-Temporäre Variable anlegen
-Index A in tmp kopieren
-Index B auf index A schreiben
-tmp auf index B schreiben

A wäre in dem Fall der Anfang [0] und B das Ende [length-1].

Gruß

3 
for (int i=0; i<array.length; i++)
{
    vertauscheBenachbarte(array, i, i+1);
}
for (int i=array.length-2; i>0; i--)
{
    vertauscheBenachbarte(array, i, i-1);
}

:o)

Aber mal im Ernst:

int temp = array[0];
array[0] = array[array.length-1];
array[array.length-1] = temp;

So viel "“Transfer”"leistung sollte man eigentlich erwarten können, aber… was solls…

4

Müssten die Schleifen nicht von i=0 bis i<array.length-1 bzw i=array.length-1 bis i>0 gehen?

Gruß

5

Hatte das nur kurz aufgemalt und hingesketcht um die Idee anzudeuten - für Unit-Tests ist mir meine Mittagspause dann DOCH zu schade :wink:

6

tsja, da siehste aber wie wichtig die dann doch sind :wink:

7

Abgesehen von dem offensichlichen -1 (was nur ein Tippfehler war) sollte das doch passen

import java.util.Arrays;

public class ArraySwapTest
{
    public static void main(String[] args)
    {
        int array[] = { 0, 1, 2, 3, 4, 5 };
        
        for (int i=0; i<array.length-1; i++)
        {
            vertauscheBenachbarte(array, i, i+1);
        }
        for (int i=array.length-2; i>0; i--)
        {
            vertauscheBenachbarte(array, i, i-1);
        }        
        
        System.out.println(Arrays.toString(array));
    }
    
    private static void vertauscheBenachbarte(int array[], int i0, int i1)
    {
        int t = array[i0];
        array[i0] = array[i1];
        array[i1] = t;
    }
}

Pff. Unit-Tests. Feigling! :stuck_out_tongue_winking_eye:

8 

        for (int i = 0; i < array.length - 1; i++) {
            vertauscheBenachbarte(array, i, i + 1);
        }
        for (int i = array.length - 2; i > 0; i--) {
            vertauscheBenachbarte(array, i, i - 1);
        }

        System.out.println(Arrays.toString(array));```
Ausgabe:
[5, 1, 2, 3, 4, 0]

```int array[] = { 0, 1, 2, 3, 4, 5 };

        for (int i = 0; i < array.length - 1; i++) {
            vertauscheBenachbarte(array, i, i + 1);
        }
        for (int i = array.length - 1; i > 0; i--) {
            vertauscheBenachbarte(array, i, i - 1);
        }

        System.out.println(Arrays.toString(array));```
Ausgabe:
[0, 1, 2, 3, 4, 5]

:)

Gruß
9

Hmja. Das erste war doch das gewünschte, oder hab’ ich da was verpeilt? :confused:

10

Du hattest in deinem Code in der zweiten for-Schleife noch die -2 drin :slight_smile:
Dann gehts beim Rückwärtstauschen beim vorletzten Index los.

Gruß

11

Wir reden wohl aneinander vorbei. Das Ziel war, das erste und das letzte Element zu vertauschen. Und ich wollte das, halb-ironisch, darauf runterbrechen, das mit Vertauschungen aufeinanderfolgender Elemente abzubilden. Mit -2 ist dieses Ziel erreicht. Mit -1 nicht. Hm.

12

[QUOTE=Unregistriert]Hallo,
ich habe die Aufgabe bei einem Array die ersten und letzten Inhalte zu tauschen
Ich habe dies jedoch nur bei den benachbarten Stellen gemacht gehabt bisher.
Könnt ihr mir nun eine kleine Hilfe geben?

Der Code von meinem Programm bei dem die benachbarten Stellen getauscht werden ist :

{
  public static void main(String[ ] args)
  { 
    int tausch = 0 ; 
    int zaehler = 0 ;
    int[] noten = {3,5,10,3,1,0,18,34,81,2,15,27};

    for (zaehler=0;zaehler<13;zaehler++)
    {
      tausch = noten[zaehler + 1];
      noten[zaehler+1] = noten[zaehler]; 
      noten[zaehler] = tausch ;
    }
  }
}```

Die Aufgabe sollte in einem ähnlichen Schema gelöst werden :)[/QUOTE]

Du hast da eine AIOOBE, aber, ich denke mal, diese Regelverletzung sei beabsichtigt?

Nach Marco13: ```    public static void main(String... args) {
        int tausch = 0;
        int zaehler = 0;
        int[] noten = {3, 5, 10, 3, 1, 0, 18, 34, 81, 2, 15, 27};

        for (int i = 0; i < 11 /*noten.length - 1*/; i++)
        for (zaehler = 0; zaehler < 11 /*noten.length - 1*/; zaehler++) {
            tausch = noten[zaehler + 1];
            noten[zaehler + 1] = noten[zaehler];
            noten[zaehler] = tausch;
        }
        
        for (int i = 0; i < 12 /*noten.length*/; i++)
        for (zaehler = 1; zaehler < 11 /*noten.length - 1*/; zaehler++) {
            tausch = noten[zaehler + 1];
            noten[zaehler + 1] = noten[zaehler];
            noten[zaehler] = tausch;
        }
        
        System.out.println(Arrays.toString(noten));
    }```

Also ich kenne niemanden, der das wirklich machen würde..

Idee: Nach dem Ausführen einer Schleife steht das vorderste Element hinten, alle anderen Elemente sind um eins auf-/vorgerückt. Dies lässt sich wiederholen, bis das zuerst hinterste Element vorne steht, und dann lässt sich dies auch wieder wiederholen.

*** Edit ***

```    public static void main(String[] args) {
        int tausch = 0;
        int zaehler = 0;
        int[] noten = {3, 5, 10, 3, 1, 0, 18, 34, 81, 2, 15, 27};

        for (int i = 0; i < 11 /*noten.length - 1*/; i++)
        for (zaehler = 0; zaehler < 11 /*noten.length - 1*/; zaehler++) {
            tausch = noten[zaehler + 1];
            noten[zaehler + 1] = noten[zaehler];
            noten[zaehler] = tausch;
        }
        
        //for (int i = 0; i < 12 /*noten.length*/; i++)
        for (zaehler = 1; zaehler < 11 /*noten.length - 1*/; zaehler++) {
            tausch = noten[zaehler + 1];
            noten[zaehler + 1] = noten[zaehler];
            noten[zaehler] = tausch;
        }
        
        System.out.println(Arrays.toString(noten));
    }```
13

Vielen Dank :slight_smile: