# Zufällige Zahlen in Array sortieren



## bvdcomp (24. Sep 2010)

Hallo zusammen,

Ich lerne gerade JAVA und möchte gerne folgendes machen:
Es sollen 20 zufällig generierte Zahlen sortiert werden.

Ich habe folgendes gemacht: 



```
import java.util.Random;
import java.util.Arrays;

public class Sortieren {

    public static void main(String[] args) {
		private int[20] zahlen;
		private Random zufallsZahl;

		public void main(strg[])
		{
			private Sortieren()
			{
		  		zahlen = new int[];
		  		int zahl = 0;
		  		while(zahl.site[zahlen]){
					zufallsZahl = new Random();
		  			zahl= zahl+1;
		  			Arrays.sort(zahlen);
		  			System.out.println("Nr "+ zahl +": " + zahlen);
		  		}

		  	}
		}
    }
}
```

Ich weis nicht ob es daran liegt das es spät ist, aber irgendwie komme ich nicht weiter ;(;(;(;(

Kann mir da jemand weiterhelfen?

Danke im voraus


----------



## Gast2 (24. Sep 2010)

Also der Code ist ziemlich murks :/

1. zwei main Methoden
2. Methode in Methode in Methode
3. 
	
	
	
	





```
private int[20] zahlen
```
 <-- so definiert man keine variable
4. 
	
	
	
	





```
zahl.site[zahlen]
```
 <-- was soll das sein?

Das sind wirklich basics die du da verhaust. 
Du solltest dir vllt nochmal die grundlagen zu gemüte führen.

Jetzt zu deinem Problem:
Du nutzt schon die Methode Arrays.sort(...); Warum setzt du da nochmal ne Schleife drumrum, damit kannst du doch schon nen ganzes array sortieren.


----------



## ARadauer (24. Sep 2010)

Ist das eine Hausübung?
Arrays.sort(zahlen); denke nicht dass du das verwenden darfst ;-)


----------



## truesoul (24. Sep 2010)

Wenn es eine Hausaufgabe ist, dann möchte der Lehrer sicherlich sowas wie Bubblesort sehen  
Naja und schau mal unbedingt in Galileo Computing :: Java ist auch eine Insel (8. Auflage) rein.


----------



## Quaxli (24. Sep 2010)

Wenn ARadauer Recht hat, guck' z. B. mal hier: Bubblesort ? Wikipedia

<edit>
 Da war truesoul etwa schneller...
</edit>


----------



## ARadauer (24. Sep 2010)

Lehrer: Programmieren sie eine verkettete Liste

Schüler: LinkedList linkedList = new LinkedList();


----------



## faetzminator (24. Sep 2010)

Es sei noch erwähnt, dass Bubblesort eigentlich sch**** ist (Laufzeit) und ich gerne den Quicksort präsentiere: Quicksort ? Wikipedia


----------



## Quaxli (24. Sep 2010)

Ich hab' mal Deinen Code etwas angepaßt:


```
import java.util.*;

public class Sortieren {

    private int[]        zahlen;

    public static void main(String[] args) {
    new Sortieren();
    }
 
  public Sortieren()            {
    zahlen = new int[20];
    erzeugeZufallszahlen();
    sortiereArray();
  }
  
  private void erzeugeZufallszahlen(){
        Random zufallsZahl = new Random();
      for(int i=0;i<zahlen.length;i++){
          zahlen[i] = zufallsZahl.nextInt();
      }
  }
  
  private void sortiereArray(){
      //Du bist dran....
  }
  
}
```


----------



## bvdcomp (25. Sep 2010)

Hallo

Danke für eure Breiträge.

ich habe mir bei Ausgabe sowas gedacht:


```
......
      private void sortiereArray(){
      //Du bist dran....
      int i = 0;
      while(i == zahlen.size[i]){ //Hier erhalte ich ein Problem und komme nicht mehr weiter!!
      	System.out.println(zahlen[i]);
      	i++;
      }
```
}


----------



## Landei (25. Sep 2010)

Arrays lassen sich ganz einfach so ausgeben:


```
System.out.println(java.util.Arrays.toString(meinArray));
```


----------



## faetzminator (25. Sep 2010)

bvdcomp hat gesagt.:


> Hallo
> 
> Danke für eure Breiträge.
> 
> ich habe mir bei Ausgabe sowas gedacht:



Normalerweise macht man das mit einer for-Schleife:

```
for (int i = 0; i < array.length; i++) {
    System.out.println(array[i]);
}
```
oder mit einer "foreach" Schleife (wie heisst die?):

```
for (int item : array) {
    System.out.println(item);
}
```
Ausser natürlich mit Landei's Methode


----------



## bvdcomp (25. Sep 2010)

hallo zusammen

ich glaub ich habs langsam. Aber ich kann nun nicht eingrenzen.
Ich habe folgendes gelesen und umgesetzt zum eingrenzen von Zufallszahlen:


```
zahlen[i] = zufallsZahl.nextInt(1, 99);
```

Es geht aber nicht, ich erhalten folgenden Fehler:

```
cannot find symbol
symbol  : method nextInt(int,int)
```

Geht es nicht so das ich zwei int werte mitgeben kann?


----------



## Gast2 (25. Sep 2010)

Nö geht nicht 


```
zahlen[i] = zufallsZahl.nextInt(98) + 1;
```
So in etwa müsste das aussehn


----------



## bvdcomp (25. Sep 2010)

OK, ich sehe in diesem Forum lerne ich mehr als im Buch :rtfm:

Das ist nun mein Quellcode:

```
import java.util.Random;
import java.util.Arrays;

/**
 * @(#)Sortieren.java
 *
 * Sortieren application
 *
 * @author
 * @version 1.00 2010/9/23
 */

public class Sortieren {

    private int[] zahlen;

    public static void main(String[] args) {
    new Sortieren();
    }

  public Sortieren()            {
    zahlen = new int[20];
    erzeugeZufallszahlen();
    sortiereArray(int[]);
  }

  private void erzeugeZufallszahlen(){
        Random zufallsZahl = new Random();
      for(int i=0;i<zahlen.length;i++){
          zahlen[i] = zufallsZahl.nextInt(98)+1;
      }
  }

  private void sortiereArray(int [] nr){
      //Du bist dran....
      int zahl = nr.lenght;
      for (int wieviel = 1; wieviel < zahl; wieviel++){
      	  for(int ubrigeZahlen = 0; ubrigeZahlen < zahl - wieviel; ubrigeZahlen++){
      	  		if(nr[ubrigeZahlen] > nr [ubrigeZahlen+1]){
      	  			int temp = nr[ubrigeZahlen];
      	  			nr[ubrigeZahlen] = nr [ubrigeZahlen+1];
      	  			nr[ubrigeZahlen+1] = temp;
      	  			}
      	  }
      	}
    	System.out.println(zahlen[i]);
  }
}
```

Auf der Zeile 24 erhalte ist ein 
	
	
	
	





```
'.class' expected
```
. 
Ich hab schon folgendes versucht:

```
sortiereArray(int[] zahlen);
```
 Geht nicht...

Was kann es sein'??


----------



## Gast2 (25. Sep 2010)

```
public Sortieren()            {
    zahlen = new int[20];
    erzeugeZufallszahlen();
    sortiereArray(zahlen);
  }
```


----------



## ARadauer (25. Sep 2010)

> Was kann es sein'??


frag ich mich auch öfters....


----------



## bvdcomp (26. Sep 2010)

Ein ganz komisches Phänomen:

Es scheint als würde die Sortierung erst bei der 10ten Stelle losgehen!
Ich habe in der Sortier-Methode folgendes angegeben:

```
private void sortiereArray(int[] nr){
    	int zahl = nr.length;
      	for (int wieviel = 1; wieviel < zahl; wieviel++){
      		for(int ubrigeZahlen = 0; ubrigeZahlen < zahl - wieviel; ubrigeZahlen++){
      	  		if(nr[ubrigeZahlen] > nr [ubrigeZahlen+1]){
      	  			int temp = nr[ubrigeZahlen];
      	  			nr[ubrigeZahlen] = nr [ubrigeZahlen+1];
      	  			nr[ubrigeZahlen+1] = temp;
      	  		}
      	  	}
      	  	System.out.println("Nr "+ wieviel + ": " +zahlen[wieviel]);
      	}
  	}
```

Ich sehe aber nicht den Fehler!!


----------



## Landei (26. Sep 2010)

Der klassische Bubblesort sieht in etwa so aus:


```
private void sortiereArray(int[] nr){
        for (int letzter = nr.length-1; letzter > 1; letzter--){
            for(int aktuell = 0; aktuell < letzter; aktuell++){
                if(nr[aktuell] > nr[aktuell + 1]){
                    int temp = nr[aktuell];
                    nr[aktuell] = nr [aktuell+1];
                    nr[aktuell+1] = temp;
                }
            }
        }
    }
```

Dabei werden immer nur benachbarte Array-Elemente miteinander verglichen. Da der größte Wert beim ersten Durchlauf ganz ans Ende bubbelt, braucht man ihn beim zweiten Durchlauf nicht mehr zu berücksichtigen. Genauso für den zweitgrößten Wert im zweiten Durchlauf u.s.w. Aus diesem Grund die absteigende äußere Schleife.

Eine mögliche Optimierung ist, sich mit einer booleschen Variable zu merken, ob in einem Durchlauf überhaupt einmal getauscht worden ist. Falls nicht, kann man sofort aufhören. Damit hat z.B. eine bereits sortierte Liste nur die Laufzeit O(n).


----------



## bvdcomp (27. Sep 2010)

Nun ist es gut. 

```
private void sortiereArray(int[] nr){
        for (int letzter = nr.length-1; letzter > 1; letzter--){ // Ist Absteigend sortiert. Aufsteigend: int letzter = nr.length-1; letzter < 1; letzter++
            for(int aktuell = 0; aktuell < letzter; aktuell++){
                if(nr[aktuell] > nr[aktuell + 1]){
                    int temp = nr[aktuell];
                    nr[aktuell] = nr [aktuell+1];
                    nr[aktuell+1] = temp;
                }
            }
        }
```

Ich danke allen die mir beim Lösen meines Problems geholfen haben.:applaus::applaus::applaus::applaus::applaus::toll::toll:


----------

