Wäre nett wenn einer von euch noch mal kurz drüber schaut,
ob ich noch was verbessern kann.
Datei 1
Code:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package bubblesorte4;
/**
*
* @author Eike Ulrichs
*/
public class Main {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Bubblesort1 b1 = new Bubblesort1();// Erstellen eines neuen Objektes von Bubblesort
int[] liste = {1, 3, 2, 6, 4, 5, 7};//Array mit Werten
b1.init(liste.length, liste);
System.out.println("Array vor Bubblesort"); //Ausgabe
b1.display();// Aufrufen der Methode display von Objekt b1 Übergabe der Liste
b1.sortOptimal();//Aufrufen der Methode sortOptimal von Objekt b1 Übergabe der Liste
{System.out.println("Array nach Bubblesort");}
b1.display();// Aufrufen der Methode display von Objekt b1 Übergabe der Liste
b1.initReverse();// Aufrufen der Methode initReverse von Objekt b1 Übergabe der Liste
{System.out.println("Umgekehrter Bubblesort");}
b1.display();// Aufrufen der Methode display von Objekt b1 Übergabe der Liste
b1.while1(); //Aufrufen der Methode While1 von Objekt b1 Übergabe der Liste
{System.out.println("Array nach While-Bubblesort");}
b1.display();// Aufrufen der Methode display von Objekt b1 Übergabe der Liste
}
}
Datei 2
Code:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package bubblesorte4;
/**
*
* @author Eike Ulrichs
*/
public class Bubblesort1 {
static int F[];
static int swap;
static int inner;
void init(int laenge, int X[]) {
F = new int[laenge];
F = X;
swap = 0;
inner = 0;
}
public static void sortOptimal() { //Erzeugen der Methode "sortOptimal"
boolean unsortiert = true;// Boolscher-Wert für die Abbruchbedingung
int temp; //temporäre Variable
while (unsortiert) { //Prüfen der Abbruchbedingung
unsortiert = false; //Setzen des neuen Boolschen-Wertes
for (int i = 0; i < F.length - 1; i++) { //Während I kleiner Array-Länge
if (F[i] > F[i + 1]) {//Wenn Elemant i vom Arrax größer als I+1
temp = F[i];// Kopieren von Wert i in temp
F[i] = F[i + 1];// Kopieren von Wert i+1 in i
F[i + 1] = temp; //Kopieren von Wert temp in i+1
unsortiert = true; //Setzen des neuen Boolschen-Wertes
swap++;
}
}
inner++;
}
}
public static void initReverse() {// Erzeugen der Methode "initReverse"
boolean unsortiert = true;// Boolscher-Wert für die Abbruchbedingung
int temp;// temporäre Variable
swap = 0;
inner = 0;
while (unsortiert) { // Während unsortiert
unsortiert = false;// Boolscher-Wert ist "False"
for (int i = 0; i < F.length - 1; i++) {//Während Element I Des Arrays kleiner Element I-1
if (F[i] < F[i + 1]) {// Wenn Element I von X kleiner Element I+1
temp = F[i];// KOpieren des Wertes XI auf temp
F[i] = F[i + 1];//Kopieren des Wertes XI+1 auf XI
F[i + 1] = temp;//Kopieren des Wertes temp auf XI+1
unsortiert = true;// Wahrheitswert auf "true" setzen
swap++;
}
}
inner++;
}
}
public static void display() { //Erzeugen der Methode "display"
System.out.println(java.util.Arrays.toString(F));
System.out.println("Die Variablen wurden " + swap + " mal vertauscht" );
System.out.println("Die innere Schleife wurde " + inner + " mal durchlaufen");
System.out.println();
}
public static void while1() { // Erzeugen der Methode "While"
int i; // Variable zur abarbeitung der Schleife
swap = 0;
inner = 0;
i = 1; // Deklaration der i variable mit Wert 1
while (i < F.length) { //1. While_Schleife mit Bedingung i kleiner Arraylänge
int j = F.length - 1; //Initialisierung und Deklaration der Variable j mir größe Arraylänge -1
while (j >= i) { // Während j größer gleich i
if (F[j] < F[j - 1]) { // wenn F[j] kleiner F[j-1]
int temp = F[j]; // Initialisierund und Wertezuweisung Variable Temp = F[j]
F[j] = F[j - 1]; //Kopieren von Wert F[j-1] auf Wert F[j]
F[j - 1] = temp; // Kopieren von Wert Temp auf F[j-1]
swap++; //Inkrementieren der Variable swa
}
inner++; //Inkrementieren der Variable inner
j = j - 1; //Dekrementieren der Variable J
}
i = i + 1; //Inkrementieren der Variable I
}
}
}
Habs jetzt mal in Spoiler gepackt damit das nicht die Seite sprengt.
Hybrid-Darstellung
