I'm getting weird timing results for quicksort with a first element pivot. My code runs quicksort first with an unsorted, non-randomized list of integers. It then sorts the previous sorted list. With my chosen pivot, I expected quicksort to run worst with a sorted list than an unsorted one. I've verified this with the following results:
Quicksort 1st run (unsorted, non-randomized)
# of calls to exch(): 14
# of calls to sort(): 17
# of calls to partition():8
# of calls to less(): 47
Sorted?: true
Time to sort input: 0.004212 secs
Quicksort 2nd run (sorted)
# of calls to exch(): 25
# of calls to sort(): 40
# of calls to partition(): 19
# of calls to less(): 138
Sorted?: true
Time to sort input: 0.000535 secs
Notice the timing doesn't make sense. Quicksort 2nd run should be slower than Quicksort 1st run.
Timing code:
start();
Quick.sort(a);
stop();
private static void start(){
start = System.nanoTime();
}
private static void stop(){
elapsed = (System.nanoTime() - start)/1E9;
}
The quicksort algorithm is correct. So there must be a problem with the way I'm implementing my timer.
Complete Code:
public class Quick {
static int exchCount; //DEBUG
static int sortCount; //DEBUG
static int partitionCount; //DEBUG
static int compareCount; //DEBUG
public static void sort(Comparable[]a){
//StdRandom.shuffle(a);
exchCount=0; //DEBUG
sortCount=0; //DEBUG
partitionCount=0; //DEBUG
compareCount=0; //DEBUG
sort(a, 0, a.length-1);
System.out.printf("# of calls to exch(): %d%n", exchCount); //DEBUG
System.out.printf("# of calls to sort(): %d%n", sortCount); // DEBUG
System.out.printf("# of calls to partition(): %d%n", partitionCount); // DEBUG
System.out.printf("# of calls to less(): %d%n", compareCount); // DEBUG
return;
}
private static void sort(Comparable a[], int lo, int hi){
sortCount++; // DEBUG
if (hi<=lo) return; // base case
int p = partition(a, lo, hi); // select partition
sort(a, lo, p-1); // recursively sort left side of partition
sort(a, p+1, hi); // recursively sort right side of partition
return;
}
private static int partition(Comparable[]a, int lo, int hi){
partitionCount++; //DEBUG
int i = lo, j = hi+1; // set pointers i (left) & j (right)
Comparable p = a[lo]; // select a partition point we'll use lo as default
while (true){
// continue walking right if values are < p
// captures any value < p
while (less(a[++i], p)) if(i==hi)break;
// continue walking left if values are > p
while (less(p, a[--j]));
if(i>=j) break; // has i crossed j?
exch(a, i, j);
}
exch(a, lo, j);
return j;
}
private static boolean less(Comparable a, Comparable b){
compareCount++; //DEBUG
return a.compareTo(b)<0;
}
private static void exch(Comparable[] a, int i, int j){
exchCount++; //DEBUG
Comparable tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
public class SortClient {
static double start=0, elapsed=0;
public static void main(String[] args) {
for(int i=0; i<10; i++){
//Comparable[] a={"K","R","A","T","E","L","E","P","U","I"
// ,"M","Q","C","X","O","S"};
//Comparable[] a = DataReader.readInt("http://algs4.cs.princeton.edu/14analysis/8Kints.txt");
Comparable[] a={8,4,45,23,13,1,65,44,9,8,3,33,21};
start();
Quick.sort(a);
stop();
System.out.printf("Quicksort#1%n");
System.out.printf("Sorted?: %b%n",isSorted(a));
System.out.printf("Time to sort input: %f secs%n%n%n",elapsed);
start();
Quick.sort(a);
stop();
System.out.printf("Quicksort#2%n");
System.out.printf("Sorted?: %b%n",isSorted(a));
System.out.printf("Time to sort input: %f secs%n%n%n",elapsed);
}
}
private static void start(){
start = System.nanoTime();
}
private static void stop(){
elapsed = (System.nanoTime() - start)/1E9;
}
private static boolean isSorted(Comparable[]a){
for(int i=0; i<a.length-2; i++)
if(a[i].compareTo(a[i+1])>0)
return false;
return true;
}
}
Is there a quirk with Java's nanoTime() call I'm unaware of? Any ideas?
