# Elemente in array umkehren



## agent0013 (19. Apr 2011)

Hallo,
ich habe so eine aufgabe:

Vervollständigen Sie das folgende Programm, so dass es die Reihenfolge der Werte in array umkehrt und sie ausgibt.
Im Programms gibt es nur ein Array und seine Werte werden durch eine etwas trickreiche Programmierung umgekehrt.

class ArrayUmkehren1
{

  public static void main ( String[] args )
  {
    int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};

    // Daten umkehren
    for ( int j = 0; j < seien Sie vorsichtig hier; j++)
    {

    }

    // neuen Daten ausgeben
    for ( int j = 0; j < array.length; j++)
    {

    }
  }
}

ich weiß nur 2 möglichkeiten:


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

und


```
for (int j = array.length - 1; j >= 0; j++)
```
aber die aufgabenstellung verlangt etwas anderes und ich komme irgendwie nicht drauf.. könnte mir jemand ein tipp geben?
danke


----------



## Guardi (19. Apr 2011)

Mein Tipp:
Schaue dir die gängigen Sortier-Algorithmen an, z.B. den BubbleSort.
Damit lässt sich die Aufgabe einfach lösen.


----------



## Final_Striker (19. Apr 2011)

Du läufst über das Array und vertauscht 1 und 14, 2 und 13, 3 und 12 usw. Wenn du bei der Mitte angekommen bist, hast du das Array umgedreht.


----------



## agent0013 (19. Apr 2011)

normalerweise müsste es so funktionieren oder?


```
for (int j = 0; j < array.length - 1; j++)
{
	if (array[j] < array[j + 1])
	{
		temp = array[j + 1];
		array[j + 1] = array[j];
		array[j] = temp;
	}
}
```

aber als ausgabe bekomme ich:

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1

was fählt da?


----------



## Dekker (19. Apr 2011)

agent0013 hat gesagt.:


> normalerweise müsste es so funktionieren oder?
> 
> 
> ```
> ...



Du willst den Array auf jeden fall umdrehen, wofür also die if?


```
for (int j = 0; j < array.length/2; j++)
{
	temp = array[j];
	array[j] = array[(array.length - (1+j))];
	array[(array.length - (1+j))] = temp;
	
}
```

Jetzt nicht ausprobiert aber so in der art sollte es funktionieren. 

Edit: Schleifenbedingung war bs, jetzt stimmts.


----------



## Final_Striker (19. Apr 2011)

Du musst die 1 und die 14 vertauschen.

[c]if (array[j] < array[j + 1])
{
 ...
}[/c]

Hier vertauscht du 1 und 2.


----------



## Nightmares (20. Apr 2011)

```
int[] b = new int[5];
		b[0] = 0;
		b[1] = 1;
		b[2] = 2;
		b[3] = 3;
		b[4] = 4;

		// test ausgabe
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}

		int left = 0;
		int right = b.length - 1;
		int temp;

		// zwei zähler
		// solange links kleiner als rechts ist rückst du von beiden 
		// seiten weiter zur mitte und vertauscht
		while (left < right) {
			temp = b[left];
			b[left] = b[right];
			b[right] = temp;
			left++;
			right--;
		}

		// test ausgabe
		for (int i = 0; i < b.length; i++) {
			System.out.println(b[i]);
		}
```

Best regards
Nightmares


----------



## Crian (20. Apr 2011)

Alternativ kopierst du rückwärts in ein zweites Array.


----------



## Nightmares (20. Apr 2011)

Geht auch, is aber wahrscheinlich weniger effizient...


----------



## agent0013 (20. Apr 2011)

hallo,
das hab ich jetzt so hingekriegt:


```
int temp;
		
for (int j = 0; j < array.length; j++)
{
	temp = array.length;
	array[j] = temp - j;
}

//  test ausgabe
for (int j = 0; j < array.length; j++)
{
	System.out.println(array[j]);
}
```

ich hoffe,daß es richtig ist und verbirgt dahinten nichts,was ich nicht sehen kann..  
danke trotzdem für eure hilfe!


----------



## AmunRa (20. Apr 2011)

Ich weis nicht was du jetzt machen willst, aber der Code vertuscht nicht die Element im Array


Dein Code aus einem deiner Vorherigen post war ja eh richtig, nur die if Bedingung hättest du entfernen müssen


----------



## agent0013 (20. Apr 2011)

ich will nur die elemente rückwerts ausgeben,mehr nichts


----------



## AmunRa (20. Apr 2011)

ein Array rückwerts ausgeben:


```
for (int i= array.length-1;i>=0;i++){
   System.out.println(array[i]);
}
```

Ein Array umkehren:


```
for (int i = 0; i < array.length/2; i++)
{
    temp = array[i];
    array[i] = array[(array.length - 1-i)];
    array[(array.length - 1-i)] = temp;
    
}
```


----------



## agent0013 (20. Apr 2011)

gut,danke, aber wie heist jetzt der code,was ich geschrieben habe?


----------



## AmunRa (20. Apr 2011)

nimmst den Startwert des Arrays, = der ist die Länge des Arrays und zähst dann Rückwärts und speicherst diese Werte ins Array.

Also wenn du ein Array der Länge 5 hast speicherst du die Wert 5,4,3,2,1


----------



## agent0013 (20. Apr 2011)

übrigens,ich hab hier zweite aufgabe:

Schreiben Sie jetzt ein weiteres Programm, das zwei Arrays verwendet. Das erste Array array wird nicht geändert. Das zweite Array ziel bekommt die Elemente von array in umgekehrter Reihenfolge. 

class ArrayUmkehren2
{

  public static void main ( String[] args )
  {
    int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
    int[]  ziel =

    // die Daten von array in umgekehrter Reihenfolge nach ziel kopieren
    for ( int j = 0; j < be careful here; j++)
    {

    }

    // Ergebnis ausgeben
    for ( int j = 0; j < ziel.length; j++)
    {

    }

  }
}

und das hab ich so gemacht:

```
int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
		int[] ziel = {14,13,12,11,10,9,8,7,6,5,4,3,2,1};
		
		for (int j = 0; j < array.length; j++)
		{
			array[j] = ziel[j];
		}
		for (int j = 0; j < ziel.length; j++)
		{
			System.out.println(array[j]);
		}
```

ich will nur sicher gehen,daß ich wenigstens das richtig gemacht habe.


----------



## AmunRa (20. Apr 2011)

Leider hast du diese auch nicht korrekt gemacht.

du gibst ja die Werte deines Arrays ziel bereits vor. daher muss man nichts mehr einfügen.


betrachten wir jetzt mal gemeinsam das ganze von Vorne.

du bekommst ein Array vorgegeben bei 

und sollst nun ein Array ziel erzeugen bei dem Alle Elemente des ersten arrays platz haben.


Wie kann man das wohl machen? (SChreib mal nur für dieses Problem eine Lösung, die sowohl für das 
	
	
	
	





```
Array array= {1,2,3,4};
```
als auch für das 
	
	
	
	





```
Array array= {3,5,2,1,5,4,2,1,4,6,3,1};
```


----------



## chalkbag (20. Apr 2011)

agent0013 hat gesagt.:


> Das erste Array array wird nicht geändert. Das zweite Array ziel bekommt die Elemente von array in umgekehrter Reihenfolge.



Also eher nein.
das Zielarray ist leer und wird nur mit der Länge von dem ersten array angelegt, also


```
int[] ziel = int[array.length];
```

Und dann befüllt du das ziel-array mit den Daten, wie du es eigentlich bei der vorangegangen Aufgabe schon gemacht hast.

[edit] zu langsam


----------



## agent0013 (20. Apr 2011)

ich probiere erstmal!! :rtfm:


----------



## Dekker (20. Apr 2011)

Nur mal so als Frage, warum führst du die Programme eigentlich nicht selbst aus anstatt immer zu fragen ob das jetzt richtig ist? Das dürftest du mit deiner Ausgabe ja selbst erkennen können, dafür sind die System.out.println(blub) ja im Endeffekt da in deinen Aufgaben.


----------



## BigBiber89 (20. Apr 2011)

Was mir als erstes in den Sinn kommen würde:


```
Integer[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};

List<Integer> temp = new LinkedList<Integer>(Arrays.asList(array));

Collections.reverse(temp);

array = temp.toArray(new Integer[0]);
```


----------



## Dekker (20. Apr 2011)

Ich glaube solche Lösungen sind in diesen Fällen für den Allerwertesten. Es ist offensichtlich, dass er die Aufgabe anhand des Codegerüstes das ihm gegeben wurde und das er in seinen Posts mit angegeben hat lösen soll.


----------



## Firephoenix (20. Apr 2011)

agent0013 hat gesagt.:


> übrigens,ich hab hier zweite aufgabe:
> 
> Schreiben Sie jetzt ein weiteres Programm, das zwei Arrays verwendet. Das erste Array array wird nicht geändert. Das zweite Array ziel bekommt die Elemente von array in umgekehrter Reihenfolge.
> 
> ...



Hi,
hast du dich vor dem schreiben der 1. Zeile eigentlich länger als 10 Sekunden mit dem Problem beschäftigt?
Die Lösung sieht eher so aus wie "ich werf einfach Code der richtig aussieht an irgendwelche Stellen und frag dannach ob es passt solange bis am Ende alles gut ist".

Und der Code ist wirklich noch in einer Kategorie bei der ich von jemandem komplett ohne Java-Kenntnisse davon ausgehen kann, dass er mir folgende Fragen beantworten kann:
-Was macht die Zeile

```
array[j] = ziel[j];
```
du weißt dem array an Position j den Wert von ziel an Position j zu.
Drehst du damit das Array um und speicherst du die Werte in Ziel????
-Was gibt diese Zeile aus?

```
System.out.println(array[j]);
```
Richtig, dein array. Wo sollen deine Ergebnisse stehen? in ziel.

Von daher bringt dein


> ich probiere erstmal!!


dir garnichts, auch wenn du Jahrelang weiterprobierst, eher wirft nen Affe ein Puzzel in die Luft und setzt es dabei perfekt zusammen...

Mach dir klar wie Arrays funktionieren, wo genau die Werte stehen, wie du wo rankommst, wie man Variablen Werte zuweist.
Und bevor du dann die erste Zeile Code schreibst überleg dir erstmal was du eigentlich machen willst.
Dann kannst du nämlich auch selbst mal deine Ergebnisse prüfen (Testen gehört zum Programmieren dazu). Und wenn sie nicht passen schaust du dir nochmal deinen Code an und überlegst was der eigentlich macht und ob es das ist was du haben willst (Code im Kopf durchlaufen ist auch eine Grundfertigkeit die man sich aneignen sollte). Und erst wenn du dann nichts findest macht es wirklich Sinn hier nachzufragen, ansonsten wirst du nie etwas dazulernen sondern das hier wird immer auf dem Niveau so weitergehen.
Gruß


----------



## agent0013 (20. Apr 2011)

> Mach dir klar wie Arrays funktionieren, wo genau die Werte stehen, wie du wo rankommst, wie man Variablen Werte zuweist.


hi, ich bin relativ anfänger.ich lerne von java-tutorial,aber entweder verstehe ich nicht richtig gut oder steht es dort nicht ausreichend,wie arrays funktionieren.. auf jeden fall,ich muss von der andere literatur auch mal was lesen.



> Nur mal so als Frage, warum führst du die Programme eigentlich nicht selbst aus anstatt immer zu fragen ob das jetzt richtig ist? Das dürftest du mit deiner Ausgabe ja selbst erkennen können, dafür sind die System.out.println(blub) ja im Endeffekt da in deinen Aufgaben.


ich hab  es natürlich probiert und hab auch gedacht,daß es richtig ist,aber ist eben nicht.wenn ich es hier nicht geschrieben hätte,hätte ich es auch vllt nie erfahren.. 
danke trotzdem für eure komentare und kritik und was auch immer....


----------



## Firephoenix (20. Apr 2011)

Hi,
hier ein Link wie Arrays aufgebaut sind:
Tutorial / Java Grundlagen / Arrays

Dann zu der Aufgabe:


> Schreiben Sie jetzt ein weiteres Programm, das zwei Arrays verwendet. Das erste Array array wird nicht geändert. Das zweite Array ziel bekommt die Elemente von array in umgekehrter Reihenfolge.



Du hast also ein Array namens "array" und ein Array namens "ziel".
Deine Aufgabe ist es, die elemente aus array in ziel zu packen.
Da beide arrays gleich viele Elemente enthalten sind sie logischerweise gleich lang (genauer gesagt ist Ziel exakt so lang wie array.
Ein int-Array einer bestimmten größe erzeugt man mit new int[größe] und die länge eines Arrays fragt man mit array.length ab.
Du kannst also mit

```
int[] ziel = new int[array.length];
```
Ein Array erzeugen, das soviel Speicherfelder bereitstellt wie array hat.

Dann musst du die Elemente übertragen, dazu bietet sich eine Schleife an.
Der Schleifenzähler fängt bei 0 an.
Du willst das erste Element von Array an die letzte Position von ziel verfrachten.
Die erste Position ist 0, die Zielposition wäre länge-1 (da das array auch bei 0 anfängt).
Im zweiten Schritt ist der Schleifenzähler 1
und du willst Position 1 aus array in ziel an länge-1-1 packen (das erste in das vorletzte)
dann bei Schritt 2 Position 2 aus array in ziel an Position länge-1-2 usw.

Abstrakt kannst du also einen Schritt so formulieren:
Bei Schritt i Speichere Position i aus array an Position array.length-1-i in ziel.
die Zuweisung dabei sieht so aus:

```
ziel[array.length]-1-i = array[i];
```

Jetzt noch eine Schleife außenrum und du erhälst

```
for(int i = 0; i < array.length; i++){
ziel[array.length]-1-i = array[i];
}
```

Zu der Ausgabe habe ich dir ja den Ansatz im vorigen Post schon gegeben.
Die Schleife läuft einmal über das ziel-array, was liegt also näher als jedes Element aus dem ziel-array auszugeben?

Ich hab das ganze hier mal eingesetzt (die Schleifenvariablen heißen hier zwar j, aber das ändert am Programmablauf nichts)


```
public static void main ( String[] args )
{
	int[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
	int[] ziel = new int[array.length];

		// die Daten von array in umgekehrter Reihenfolge nach ziel kopieren
		for ( int j = 0; j < array.length; j++)
		{
			ziel[array.length-1-j] = array[j];
		}

	// Ergebnis ausgeben
	for ( int j = 0; j < ziel.length; j++)
	{
		System.out.println(ziel[j]);
	}

}
```
Gruß


----------



## happen (21. Apr 2011)

ich gebe auch noch meine zum Besten:


```
int[] array = {1, 2, 3, 4, 5, 6, 7};
        for (int i = 0; i < array.length / 2; i++) {
            final int j = array.length - 1 - i;
            array[i] -= array[j];
            array[j] += array[i];
            array[i] = array[j] - array[i];
        }
        System.out.println(Arrays.toString(array));
```

..und warum funktionierst?


----------



## Firephoenix (21. Apr 2011)

happen hat gesagt.:


> ich gebe auch noch meine zum Besten:
> 
> 
> ```
> ...



Hi,
keine uninteressante Lösung für das Archiv, ich kann mir allerdings nicht vorstellen, das du damit dem TO wirklich helfen wirst, da die Methode schwerer nachzuvollziehen ist und vor allen Dingen nicht innerhalb der Vorgegebenen Schleifen seiner Übung arbeitet.

Funktionieren tut das ganze deswegen:
seinen i,j die Werte zum tauschen:
nehmen wir 
i = i - j
j = j + i - j = i
i = j - i = (i)-(i-j) = j
und wir haben getauscht.

Gruß


----------



## Dekker (21. Apr 2011)

agent0013 hat gesagt.:


> ich hab  es natürlich probiert und hab auch gedacht,daß es richtig ist,aber ist eben nicht.wenn ich es hier nicht geschrieben hätte,hätte ich es auch vllt nie erfahren..
> danke trotzdem für eure komentare und kritik und was auch immer....



Und genau da liegt ein ganz anderes Problem. Wie kann man etwas Programmieren wenn man nicht mal weiß wie das Ergebnis am Ende aussehen sollte? Ich wollte dich damit weder beleidigen noch sonst etwas, aber nachdem was du hier schreibst war meine Frage doch garnicht mal so unötig.

Merk dir eins, beim programmieren sollte man niemals einfach mal so anfangen und bissle Code hinklatschen und kucken was am Ende rauskommt.

1. Problem verstehen
2. Auf Papier schrittweise überlegen wie das Problem gelöst werden kann (gerade als Anfänger besser als direkt los zu programmieren; es geht dabei nicht darum den Code auf Papier zu schreiben sondern wirklich in Stichpunkten Schritt für Schritt den Ablauf des gewünschten Programmes aufschreiben) 
3. Lösung nach den Überlegungen aus Schritt 2 Programmieren
4. Testen: falls Ergebnis nicht das erwartete ist -> wieder zu Schritt 2, andern falls bist du fertig.

Bei dir hat es hier aber dann wohl schon bei Schritt 1 gehapert, wie also soll da was vernünftiges rauskommen?


----------



## Landei (21. Apr 2011)

Was ist an einem Array schwer zu verstehen? Im Prinzip nichts weiter als eine Reihe Spinde mit Nummern ("Indexe") drauf, angefangen bei 0. Und da kann man Zeugs reinstopfen und wieder herausholen. Wenn du ein Array mit Zahlen hast, darfst du natürlich die "reingestopfte" Zahl nicht mit der "Spindnummer" verwechseln. Man muss noch aufpassen, dass man nichts überschreibt (wenn man etwas in einen bereits belegten Spind legt, landet das alte Zeug im Müll), was man später noch braucht. Das sind aber schon alle "Schwierigkeiten" hier.

So, nun stell dir vor da sind zehn Spinde mit der Nummer 0 bis 9, wie vertauschst du die Inhalte, dass sie eine umgekehrte Reihenfolge bekommen? Wie genau läuft eine Vertauschung ab, ohne dass man etwas überschreibt?


----------



## Crian (21. Apr 2011)

Und man muss vorher genug Spinde aufstellen.

Wenn da zehn Spinde stehen und man das Glas in den elften stellt, fällt es zu Boden und geht kaputt.


----------



## Landei (21. Apr 2011)

Dann kommt der Hausmeister mit dem komischen Namen ArrayOutOfBoundsException und wischt es weg...


----------



## 2XS (21. Apr 2011)

@Firephoenix: Für die tolle und ausführliche Lösung musste ich Dir einfach auch ein "Danke" spendieren, obwohl ich mit dem Problem überhaupt gar nichts am Hut habe.


Grüße,

Andy


----------



## happen (21. Apr 2011)

Firephoenix hat gesagt.:


> Hi,
> keine uninteressante Lösung für das Archiv, ich kann mir allerdings nicht vorstellen, das du damit dem TO wirklich helfen wirst, da die Methode schwerer nachzuvollziehen ist und vor allen Dingen nicht innerhalb der Vorgegebenen Schleifen seiner Übung arbeitet.
> 
> Funktionieren tut das ganze deswegen:
> ...



Es funktioniert auch mit dem ^-Operator: java - question on reverse array - Stack Overflow
(noch eine Lösung)


----------

