QuickSort.java

gehe zur Dokumentation dieser Datei
00001 
00007 import java.util.Random;
00008 
00009 class QuickSort {
00010 
00011 
00012 
00022     static boolean isSorted(int[] a) {
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     }
00031 
00042     static void swap(int[] a, int i, int j) {
00043         int aux = a[i];
00044         a[i] = a[j];
00045         a[j] = aux;
00046     }
00047 
00069     static int getPivotIdx(int[] a, int ug, int og) {
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     }
00082 
00083 
00097     static void quicksort(int[] a, int ug, int og) {
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     }
00136 
00140     static void fillArray(int[] a) {
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     }
00149 
00150     
00155     static void printArray(int[] a, String s) {
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     }
00164 
00172     public static void main(String[] args) {
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     }
00196 
00197 
00198 }

Erzeugt am Tue Nov 25 11:59:43 2008 für Imperative Programmierung - Einführung in Java von  doxygen 1.5.0