Zahlen aus einem Array sortieren

Java-Forum Java-Grundlagen
1

Hallo liebe byte-welt user,
dies hier ist mein erster Post also bitte nicht so hart ran nehmen :wink:
Ich studiere im Moment Wirtschaftsinformatik und habe eine Programmieraufgabe bekommen bei der ich einfach nicht mehr weiter weiß.

Zur Aufgabe: Es soll ein Programm geschrieben werden, dass ein Array der lÀnge n anlegt und mit zufÀlligen Zahlen von -100 bis 100 belegt.
Nun soll der Inhalt des Arrays mit einer vorgegebenen Methode sortiert werden.

„Beim ersten Feldelement beginnend, werden je zwei aufeinanderfolgende Elemente i und i + 1 verglichen. Ist das Element an der Stelle i kleiner als das Element an der Stelle j, werden die Inhalte der Feldelemente i und i + 1 vertauscht.“

Mein Code vergleicht leider immer nur die Stellen i und i+1. Ich weiß nicht wie ich die verglichenen Zahlen nun noch sortieren soll. Meine Überlegung ist, dass man sich die niedrigste Zahl merkt aus allen vergleichen und dann damit weiter macht aber an dieser Stelle komme ich schon nicht weiter.

Hier mein Code (nicht erschrecken):

public class P9 
{

    public static void main(String[] args) 
    {
        
        int n = IOTools.readInteger("Bitte geben Sie die lÀnge des Feldes an: 
");
        n += 1;
        int [] random;
        random = new int [n];
        
        
        for(int i = 0; i+1 < n ;i++)    //In Dieser Schleife werdem dem Array Zufallswerte zugewiesen (von 0 bis n-1)
        {
            random** = (-100 + (int)(Math.random() * ((100 - (-100)) + 1)));
            int a = random**;
        System.out.println("rnd " + a);        //Gibt die fĂŒr random** zugewiesene Zahl aus
            
            
            
            Schleife2:
            while( i>0 && i<n)    //Diese Schleife vergleicht jeweils die Zahlen random[i-1] und random** und gibt die kleinere aus
            {
                if (random[i-1] < random**)
                {
                    System.out.println("Die Zahl " + random[i-1] + " ist niedriger");
                }
                else
                { 
                    System.out.println("Die Zahl " + random** + " ist niedriger");
                }
                break Schleife2;
            }    
        }
    }
}
2

Das FĂŒllen des Arrays mit Zufallszahlen und
Das Sortieren des Arrays
sollten zwei getrennte Operationen sein. Also nicht beides in eine Schleife packen (kann ja auch kaum funktionieren
).

Besonders “aufgerĂ€umt” wĂ€re es, wenn in der main sowas stehen wĂŒrde wie

int n = 10;
int min = -100;
int max = 100;
int array[] = createRandomArray(n, min, max);
System.out.println("Random: "+Arrays.toString(array));

mySortMethod(array);
System.out.println("Sorted: "+Arrays.toString(array));

und es eben die beiden Methoden “createRandomArray” und “mySortMethod” gĂ€be.

Nebenbei: Math.random() hat den Nachteil, dass es immer zufÀllige double-Werte liefert. Mit sowas wie

private static Random random = new Random(0);
...
void foo()
{
    ...
    int randomValue = -100 + random.nextInt(100 - (-100));
}

geht das ganze vielleicht einfacher. (Und in deiner Methode wĂŒrden dort NICHT mehr 100 und -100 stehen!)

Das Sortieren
 vielleicht erĂŒbrigt sich die Frage, wenn du das in eine eigene Methode packst. Und 
 “break mit Label” ist nur in den ALLERseltensten FĂ€llen angebracht. (Ich selbst habe es noch NIE verwendet
)

3

“Arrays.sort()” ist in diesem Fall als Lösungsweg wohl ausgeschlossen, da der Sortieralgorithmus vorgegeben ist.
Eine ineinander geschachtelte Schleife gestaltet sich so, dass die Ă€ussere von 0 bis Anzahl der Elemente -1 und die innere von Ă€usserer ZĂ€hler bis Anzahl der Elemente zĂ€hlt. Ist Element innerer ZĂ€hler grösser (absteigende Reihenfolge) als Element Ă€usserer ZĂ€hler werden die Elemente getauscht. FĂŒr eine aufsteigende Reihenfolge muss nur der Grösser-Operator in einen Kleiner-Operator geĂ€ndert werden.

  for(int i = 0; i < array.length - 1; i++) {
    for(int j = i; j < array.length; j++) {
      if(array** > array[j]) {
        array** += array[j];
        array[j] = array** - array[j];
        array** -= array[j];
      }
    }
  }
}```Das Ganze nennt sich afaik BubbleSort.
4

Oh man
 ich dachte erst der Code von Spacerat hilft mir weiter aber nach Stunden von programmieren und neu versuchen und umschreiben bin ich immer noch nicht weiter
 Ich weiß einfach nicht wie ich die Methode anwenden muss. Is echt dumm wenn man als AnfĂ€nger nichtmal die “Lösung” versteht
 Danke aufjedenfall fĂŒr die Antworten.

5

Äehm



public class Bubblesort {
  static void sort(int[] array) {
    for(int i = 0; i < array.length - 1; i++) {
      for(int j = i; j < array.length; j++) {
        if(array** > array[j]) {
          array** += array[j];
          array[j] = array** - array[j];
          array** -= array[j];
        }
      }
    }
  }

  public static void main(String[] args) {
    int[] demoArray = new int[20];
    for(int n = 0; n < demoArray.length; n++) {
      demoArray[n] = (int) (Math.random() * 201 - 100);
    }
    System.out.println(Arrays.toString(demoArray));
    sort(demoArray);
    System.out.println(Arrays.toString(demoArray));
  }
}```Kannst du in einer IDE ja mal in Einzelschrittsimulation (Debug) starten.
6

FĂŒr einen AnfĂ€nger ist das Bespiel etwas sehr :wink: verwirrend:


 static void sort(int[] array) {
        int temp;
        for(int i = 0; i < array.length - 1; i++)
        ....
        temp = array**;
        array** = array[j];
        array[j] = temp;
        ---
7

DANKE! Hat mir sehr sehr weiter geholfen und so Àhnlich hatte ich es auch gestern schon fast selbst geschafft. Nun sieht mein Code so aus:
Java Code:

[ol]
[li]import java.util.Arrays; [/li][li]public class P9 [/li][li]{ [/li][li] static void sort(int[] array) [/li][li] { [/li][li] for(int i = 0; i < array.length - 1; i++) [/li][li] { [/li][li] for(int j = i; j < array.length; j++) [/li][li] { [/li][li] if(array** > array[j]) [/li][li] { [/li][li] array** += array[j]; [/li][li] array[j] = array** - array[j]; [/li][li] array** -= array[j]; [/li][li] } [/li][li] } [/li][li] } [/li][li] } [/li][li] public static void main(String[] args) [/li][li] { [/li][li] int n = IOTools.readInteger(„Bitte geben Sie die lĂ€nge des Feldes an: [/li]“);
[li] int [] random = new int [n]; [/li][li] for(int a= 0; a < n ;a++) //In Dieser Schleife werdem dem Array Zufallswerte zugewiesen (von 0 bis n-1) [/li][li] { [/li][li] random[a] = (-100 + (int)(Math.random() * ((100 - (-100)) + 1))); [/li][li] System.out.println("ZufĂ€llige Zahl " + random[a]); //Gibt die fĂŒr random zugewiesene Zahl aus** [/li][li] sort(random); [/li][li] System.out.println(Arrays.toString(random)); [/li][li] } [/li][li] } [/li][li]} [/li][/ol]

Es findet aufjedenfall eine Sortierung statt aber es ist komisch, dass bei einem Feld zb der LĂ€nge 7 werden die ersten 4 Zahlen sortiert und dann werden aufeinmal zahlen wieder ĂŒberschrieben bzw das Array nicht gefĂŒllt. Ich wollte den Code nicht direkt ĂŒbernehmen auch wenn ich ihn verstanden habe, mir wĂ€re es lieber wenn ich verstehe wo bei mir im Moment der Fehler liegt.

Danke nochmal fĂŒr die Geduld und hilfe :slight_smile:

8

Soweit ich das bei der fehlenden EinrĂŒckung beurteilen kann sortierst du immernoch wĂ€hrend der Array noch gefĂŒllt wird. Abgesehen vom sĂŒĂŸen Gift der Illusion, zu denken “Genau so hĂ€tte ich es auch gemacht!” wenn man eine Lösung fĂŒr ein Problem sieht, an dem man sich vorher noch die ZĂ€hne ausgebissen hat.