Question

I have to perform a run time analysis on quicksort by incrementing the size of the array by 100 each time. However when I measure the runtime using System.nanoTime the results aren’t as I expect (my graphs look more like O(2^n)). The time shoots up whenever the array reaches around 800. Could someone please tell me where I’m going wrong with my code.

Also the count part is sort of irrelevant at the moment, since i only want to run the quicksort once at each array size.

import java.util.Random;


public class Quickworking {

public static void main(String[] args) {
    Random rand = new Random();
    int count2;
    long total = 0;
    count2 = 1;
    int [] myArray = new int[1400];   

                //generates random array
    for (int i = 0; i < myArray.length; i++){
        myArray[i] = rand.nextInt(100) + 1;
        //System.out.print(myArray[i] + ", ");
    }

            //loop sort n amount of times
    for (int count = 0; count < count2; count++){

            //calls the sort method on myArray giving the arguments
        long start = System.nanoTime();
        sort( myArray, 0, myArray.length - 1 );
        long end = System.nanoTime();
        System.out.println(end - start );
        total += (end - start);
    }
    //long average = (long) total / (long) count2;

    //System.out.println(average);


    //prints the sorted array
    //for (int i = 0; i <myArray.length; i++){
    //  System.out.print(myArray[i] + ", ");
    //}

}

public static int sort(int myArray[], int left, int right){
    int i = left, j = right;
    int temp;
    int pivot = myArray[(left + right) / 2];
    //System.out.println("here are the pivot numbers " + pivot + ", ");


    if (i <= j){

        while (myArray[i] < pivot) //&& (i<right))  
            i++;
        while (myArray[j] > pivot) //&& (j>left))  
            j--;
        if (i <= j){
            temp = myArray[i];
            myArray[i] = myArray[j];
            myArray[j] = temp;
            i++;
            j--;


        }
    } 

    if (left < j) sort(myArray, left, j);
    if (i < right) sort(myArray, i, right);

    return i;

}
}

Answer 1

Quicksort’s behaviour when sorting already sorted arrays is O(n^2). After the array is sorted the first time in your code you are then sorting the sorted array. That will give you the worst case for quick sort. You need to generate a completely new random array each time to really test this.