QuickSort Klassenreferenz

Aufstellung aller Elemente

Ausführliche Beschreibung

Definiert in Zeile 9 der Datei QuickSort.java.

Öffentliche, statische Methoden

static void main (String[] args)
 Hauptprogramm fuer die Anwendung und den Test des Quicksort-Algorithmus.

Statische Paketfunktionen

static boolean isSorted (int[] a)
 Prueffunktion fuer die korrekte aufsteigende Sortierung eines Arrays.
static void swap (int[] a, int i, int j)
 Vertauschung der Werte eines Arrays an den Indexwerten i und j.
static int getPivotIdx (int[] a, int ug, int og)
 Ermittlung eines Pivotelementes in den Grenzen ug.
static void quicksort (int[] a, int ug, int og)
 Hauptfunktion des Quicksort-Algorithmus.
static void fillArray (int[] a)
 Fuelle array a mit Zufallszahlen.
static void printArray (int[] a, String s)
 Drucke den Inhalt von a aus; mit vorangestellter Ueberschrift s.


Dokumentation der Elementfunktionen

static boolean QuickSort.isSorted ( int[]  a  )  [static, package]

Prueffunktion fuer die korrekte aufsteigende Sortierung eines Arrays.

Parameter:
a Zu pruefender Array.
Rückgabe:
true, falls der Array korrekt aufsteigend sortiert ist.
false sonst.

Definiert in Zeile 22 der Datei QuickSort.java.

Wird benutzt von main().

00022                                      {
00023 
00024         for ( int i = 1; i < a.length; i++ ) {
00025             if ( a[i-1] > a[i] ) return false;
00026         }
00027 
00028         return true;
00029 
00030     }

static void QuickSort.swap ( int[]  a,
int  i,
int  j 
) [static, package]

Vertauschung der Werte eines Arrays an den Indexwerten i und j.

Parameter:
a Array, in dem die Werte a[i] und a[j] zu vertauschen sind.
i Erster index; dieser muss im Wertebereich 0..a.length-1 liegen.
j Zweiter index; dieser muss im Wertebereich 0..a.length-1 liegen.

Definiert in Zeile 42 der Datei QuickSort.java.

Wird benutzt von quicksort().

00042                                             {
00043         int aux = a[i];
00044         a[i] = a[j];
00045         a[j] = aux;
00046     }

static int QuickSort.getPivotIdx ( int[]  a,
int  ug,
int  og 
) [static, package]

Ermittlung eines Pivotelementes in den Grenzen ug.

.og des Arrays a, welches NICHT das kleinste Element in diesem Bereich ist.

Parameter:
a Array, in dessen Grenzen ug, og das Pivo-Element zu suchen ist
ug Untergrenze des Suchbereichs Wertebereich 0..a.length-1
og Obergrenze des Suchbereichs Wertebereich 0..a.length-1 Es muss ug <= og gelten.
Rückgabe:
-1 Wenn alle Elemente im Bereich ug..og den selben Wert haben
i Wenn a[i] NICHT den kleinsten Wert von a im Bereich ug..og hat

Definiert in Zeile 69 der Datei QuickSort.java.

Wird benutzt von quicksort().

00069                                                     {
00070         int aux = a[ug];
00071         for ( int i = ug; i <= og; i++ ) {
00072       
00073             // Wenn a[i] nicht das kleinste Element
00074             // ist, wird dessen Index zurueck gegeben.
00075             if ( aux < a[i] ) 
00076                 return i;
00077             else if ( a[i] < aux )
00078                 return ug;
00079         }
00080         return -1;
00081     }

static void QuickSort.quicksort ( int[]  a,
int  ug,
int  og 
) [static, package]

Hauptfunktion des Quicksort-Algorithmus.

Parameter:
a Array, in dessen Grenzen ug..og der Algorithmus anzuwenden ist.
ug Untergrenze des Suchbereichs. Wertebereich 0..a.length-1
og Obergrenze des Suchbereichs. Wertebereich 0..a.length-1. Es muss ug <= og gelten.

Definiert in Zeile 97 der Datei QuickSort.java.

Benutzt getPivotIdx() und swap().

Wird benutzt von main().

00097                                                    {
00098 
00099         // Suche den Index eines geeigneten Pivot-Elementes.
00100         int pIdx = getPivotIdx(a,ug,og);
00101 
00102         // Wenn kein Pivot-Element gefunden wurde, bedeutet dies,
00103         // dass a[ug..og] lauter identische Werte enthaelt. Es ist also
00104         // im Bereich ug..og nichts mehr zu sortieren.
00105         if ( pIdx == -1 ) return;
00106  
00107         // p traegt den Wert des Pivot-Elementes
00108         int p = a[pIdx];
00109 
00110         // lo ist der Index fuer die Suche von links,
00111         // beginnend bei der Untergrenze ug.
00112         int lo = ug;
00113 
00114         // hi ist der Index fuer die Suche von rechts.
00115         int hi = og;
00116  
00117         // Ziel dieser while-Schleife: nach der Terminierung
00118         // der Schleife sind alle Elemente a[ug..lo-1] kleiner
00119         // als das Pivotelement p, und alle Elemengte a[lo..og]
00120         // sind groesser oder gleich p.
00121         while ( lo <= hi ) {
00122 
00123             swap(a,lo,hi);
00124             while ( a[lo] < p ) lo++;
00125             while ( a[hi] >= p ) hi--;
00126 
00127         }
00128 
00129         // Teile-und-herrsche Prinzip: Wende den
00130         // Algorithmus rekursiv auf a[ug..lo-1]
00131         // und a[lo..og] an:
00132         quicksort(a,ug,lo-1);
00133         quicksort(a,lo,og);
00134 
00135     }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static void QuickSort.fillArray ( int[]  a  )  [static, package]

Fuelle array a mit Zufallszahlen.

Definiert in Zeile 140 der Datei QuickSort.java.

Wird benutzt von main().

00140                                    {
00141 
00142         Random r = new Random(17);
00143 
00144         for ( int i = 0; i < a.length; i++ ) {
00145             a[i] = r.nextInt();
00146         }
00147 
00148     }

static void QuickSort.printArray ( int[]  a,
String  s 
) [static, package]

Drucke den Inhalt von a aus; mit vorangestellter Ueberschrift s.

Definiert in Zeile 155 der Datei QuickSort.java.

00155                                               {
00156 
00157         System.out.println(s);
00158 
00159         for ( int i = 0; i < a.length; i++ ) {
00160             System.out.println("a[" + i + "] = " + a[i]);
00161         }
00162 
00163     }

static void QuickSort.main ( String[]  args  )  [static]

Hauptprogramm fuer die Anwendung und den Test des Quicksort-Algorithmus.

Parameter:
args args[0] enthaelt die Groesse des zum Sortieren zu verwendenden Arrays (als String)

Definiert in Zeile 172 der Datei QuickSort.java.

Benutzt fillArray(), isSorted() und quicksort().

00172                                            {
00173 
00174         Integer len = new Integer(args[0]);
00175         int length = len.intValue();
00176         int a[] = new int[length];
00177 
00178         fillArray(a);
00179         // printArray(a,"UNSORTIERT:");
00180 
00181 
00182         quicksort(a,0,length-1);
00183 
00184         // printArray(a,"SORTIERT:");
00185 
00186 
00187         if ( isSorted(a) ) {
00188             System.out.println("PASS.");
00189         }
00190         else {
00191             System.out.println("FAIL.");
00192         }
00193 
00194 
00195     }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:


Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:
Erzeugt am Tue Nov 25 11:59:43 2008 für Imperative Programmierung - Einführung in Java von  doxygen 1.5.0