My Quicksort - using java

Oke, kali ini kita bertemu dalam permasalahan pemrograman. Kali ini saya akan sedikit membagikan hasil dari "Trial and Error" kelompok saya, hehe.

Oke, langsung saja ke permasalahannya ya, disini kita membuat pengurutan Quicksort yang inputan angkanya di import melalui random file yang dibuat dalam bentuk text file.

Untuk sourcecode-nya :

1. import java.io.BufferedReader;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileReader;  
4. import java.util.ArrayList;  
5. import java.util.Scanner;  
6.   
7. public class KwikSort {  
8.   
9.     static int              elements;  
10.     static ArrayList<Integer>     unsorted;  
11.     static Scanner          scanned;  
12.     final static String         NEWLINE = System.getProperty("line.separator");  
13.   
14.       
15.     public static void main(String[] args) {  
16.         initialize();  
17.         loadToArray("c:\\random.txt");  
18.         quickSort(0, elements-1);  
19.         printList();  
20.     }  
21.           
22.     public static void initialize(){  
23.         elements    = 0;  
24.         unsorted    = new ArrayList<Integer>();  
25.     }  
26.   
27.     public static void loadToArray (String filepath){  
28.         // filling ArrayList<Integer> called 'unsorted' with the numbers from inputfile  
29.           
30.         try {  
31.   
32.             scanned = new Scanner (new BufferedReader(new FileReader(filepath)));  
33.             scanned.useDelimiter(NEWLINE);  
34.   
35.             while (scanned.hasNext())   {             
36.                 elements++;  
37.                 unsorted.add(new Integer(scanned.next()));  
38.             }  
39.               
40.         } catch (FileNotFoundException e){System.out.println("File not Found");}  
41.     }  
42.   
43.   
44.     public static void quickSort (int first, int last){  
45.   
46.         if (!(first < last)) {   return; }  
47.           
48.         int newPivotPosition = splitAroundPivot(first, last);  
49.           
50.         quickSort (first, newPivotPosition - 1);    //recursion to sort left of pivot  
51.         quickSort (newPivotPosition + 1, last); //recursion to sort right of pivot  
52.        }  
53.   
54.     public static int splitAroundPivot (int firstInList, int lastInList){  
55.   
56.         /* choose last element from the given range to be the pivot and 
57.          * then sort all elements <= pivot on its left and >= pivot on its right 
58.          * Once this is done, the new Pivot is set to the last element of the left-part of the list  
59.          */  
60.           
61.         int pivot   = unsorted.get (lastInList);  
62.         int first   = firstInList;  
63.         int last    = lastInList -1;  
64.       
65.         do{  
66.             while ( unsorted.get(first) <= pivot && first < lastInList )  {   first++;    }  
67.             while ( unsorted.get(last)  >= pivot && last > firstInList )  {   last--; }  
68.   
69.             if (first < last) {  
70.                 // swap values because left is bigger than pivot and right smaller than pivot  
71.                   
72.                 int temp = unsorted.get(first);  
73.                 unsorted.set(first, unsorted.get(last));  
74.                 unsorted.set(last, temp);  
75.             }  
76.         } while(first < last);  
77.           
78.         if (unsorted.get(first) > pivot) {  
79.             // swap pivot element with element at index 'first'  
80.               
81.             int temp = unsorted.get(first);  
82.             unsorted.set(first, unsorted.get(lastInList));  
83.             unsorted.set(lastInList, temp);           
84.         }  
85.         return first; //first now represents the new pivot-position  
86.     }  
87.   
88.     public static void printList (){  
89.         for (int i =0 ; i < elements; i++){  
90.             System.out.println (unsorted.get(i));  
91.         }  
92.     }  
93.       
94. }  

Monggo, untuk file text-nya silakan download disini