SelectionSort.java Donnerstag, 3.

Februar 2022, 20:06

1 package sortieren;
2
3 public class SelectionSort {
4
5 // Der SelectionSort arbeitet nach folgendem Prinzip:
6 // Es wird immer die erste Zahl mit allen anderen verglichen.
7 // Findet sich eine Zahl, die kleiner ist als die erste, so werden
8 // diese zwei Zahlen getauscht. Somit steht die kleinste Zahl nun
9 // am Anfang. Da wir am Anfang schon die kleinste Zahl haben, müssen
10 // wir nun die zweite Zahl mit allen anderen vergleichen. Dies gibt
11 // uns die zweitkleinste Zahl und somit sind die ersten zwei Zahlen
12 // sortiert. Dies führen wir nun so lange fort, bis wir bei der
13 // vorletzten Zahl sind, da man die letzte Zahl nicht mit der nächsten
14 // Zahl vergleichen kann, da es keine nächste Zahl gibt.
15
16 private int[] zahlen = new int[20];
17
18 // Konstruktor
19 public SelectionSort() {
20 fuellen(zahlen, 50);
21 ausgabe(zahlen); // Wir geben das Feld vor der Sortierung aus.
22 sort(zahlen);
23 ausgabe(zahlen);
24 }
25
26 // Feld mit zufälligen Zahlen von 1 bis max füllen
27 public void fuellen(int[] feld, int max) {
28 for(int i = 0; i < feld.length; i++) {
29 feld[i] = (int) (Math.random() * max + 1);
30 // Math.random() gibt eine Zahl als double (Dezimalzahl)
31 // zwischen 0.0 und kleiner als 1.0 an. Um diesen Wert
32 // größer zu bekommen, multipliziert man diese Zahl mit
33 // dem Wert von max, der die größtmögliche Zahl angibt.
34 // Am Ende addiert man 1, damit die kleinste Zahl nur
35 // eine 1 sein kann.
36 //
37 // Das (int) vor dem (Math.random() * max + 1) konvertiert
38 // Das Ergebnis in einen Integer, also eine Ganzzahl. Dies
39 // müssen wir machen, da Math.random() ein double ausgibt,
40 // unser Feld jedoch den Typ int[] und nicht double[] hat.
41 }
42 }
43
44 public void ausgabe(int[] feld) {
45 for(int i = 0; i < feld.length; i++) {
46 System.out.println("feld[" + i + "] = " + feld[i]);
47 // Damit wird für den Index i der jeweilige Wert feld[i]
48 // ausgegeben. Die Ausgabe vom Index 1 wäre zum Beispiel:
49 // "feld[1] = 21", wobei die 21 eine zufällig gewählte
50 // Zahl ist, da der Wert der Zahl mit dem Index 1 im Feld
51 // immer variieren kann.
52 }
53 }
54
55 public void sort(int[] feld) {
56 int start = 1;
57 // Wir legen einen Wert start fest, welcher immer um 1 erhöht
58 // wird nach jedem Durchgang, da die Zahl auf der Position von
59 // start die Zahl ist, die zuerst verglichen wird. Da wir die
60 // sortierten Zahlen an den Anfang bringen, muss zum Beispiel
61 // nicht mehr die Zahl mit dem Index 0 und die Zahl mit dem
62 // Index 1 verglichen werden, sondern die Zahl mit dem Index

Page 1
SelectionSort.java Donnerstag, 3. Februar 2022, 20:06

63 // 1 und die Zahl mit dem Index 2.

64 for(int x = 0; x < feld.length - 1; x++) {
65 // Wir lassen die erste Schleife laufen, die uns die erste Zahl
66 // angibt. Diese Zahl wird immer mit allen anderen verglichen
67 // und muss demnach nach der Sortierung der ersten Zahl immer
68 // um eins steigen, um die nächstkleinere Zahl herrauszufinden.
69 // Die Schleife läuft nur bis feld.length - 1, da man die letzte
70 // Zahl nicht mit den nächsten Zahlen vergleichen kann, da keine
71 // weiteren Zahlen folgen.
72 for(int i = start; i < feld.length; i++) {
73 // Die zweite Schleife gibt den Index für die zu vergleichende
74 // Zahl an. Wir starten bei 1, da wir nicht die erste Zahl mit
75 // der ersten Zahl vergleichen wollen (kurze Wiederholung:
76 // In Java zählt man ab 0, nicht ab 1). Diese Schleife läuft
77 // durch, bis alle Zahlen, mit der Zahl, die vorher in der
78 // anderen Schleife bestimmt wird, verglichen wurden und ein
79 // neues Minimum entdeckt wird.
80 if(feld[i] < feld[x]) {
81 tausche(feld, i, x);
82 // Hier wird geprüft, ob die folgenden Zahlen kleiner
83 // sind als der Vergleichswert. Der Vergleichswert ist
84 // Die Zahl mit dem Index x. Ist die Zahl mit dem Index
85 // i kleiner, so werden die Positionen von beiden Zahlen
86 // im Feld getauscht. Damit wird immer die kleinste Zahl
87 // nach vorne geschoben. Die Methode tausche() ist dabei
88 // eine selbst erstellte Methode die untern erläutert wird.
89 }
90 }
91 start++;
92 // Wir erhöhen den Startwert der zweiten Schleife, da wir die
93 // bereits sortierten Zahlen, die pro Durchgang um 1 steigen,
94 // nicht erneut vergleichen wollen.
95 }
96 }
97
98 public void tausche(int[] feld, int pos1, int pos2) {
99 int hilfsvariable = feld[pos1];
100 feld[pos1] = feld[pos2];
101 feld[pos2] = hilfsvariable;
102 // Wir speichern den Wert auf der Position pos1 in dem
103 // angegebenen Feld, da dieser im nächsten Schritt überschrieben
104 // wird. Dann tauschen wir den Wert auf der Position pos1 mit
105 // dem Wert auf der Position pos2 und ersetzen den Wert auf der
106 // Position pos2 mit der hilfsvariable, also mit unserem alten
107 // Wert auf der Position pos1.
108 }
109 }

Page 2