Quicksort Array in Java

Quicksort is a divide and conquer algorithm. It first divides a large list into two smaller sub-lists and then recursively sort the two sub-lists. If we want to sort an array without any extra space, quicksort is a good option. On average, time complexity is O(n log(n)).

The basic step of sorting an array are as follows:

  • Select a pivot, normally the middle one
  • From both ends, swap elements and make left elements < pivot and all right > pivot
  • Recursively sort left part and right part

Here is a very good animation of quicksort.

public class QuickSort {
	public static void main(String[] args) {
		int[] x = { 9, 2, 4, 7, 3, 7, 10 };
		System.out.println(Arrays.toString(x));
 
		int low = 0;
		int high = x.length - 1;
 
		quickSort(x, low, high);
		System.out.println(Arrays.toString(x));
	}
 
	public static void quickSort(int[] arr, int low, int high) {
		if (arr == null || arr.length == 0)
			return;
 
		if (low >= high)
			return;
 
		// pick the pivot
		int middle = low + (high - low) / 2;
		int pivot = arr[middle];
 
		// make left < pivot and right > pivot
		int i = low, j = high;
		while (i <= j) {
			while (arr[i] < pivot) {
				i++;
			}
 
			while (arr[j] > pivot) {
				j--;
			}
 
			if (i <= j) {
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
				i++;
				j--;
			}
		}
 
		// recursively sort two sub parts
		if (low < j)
			quickSort(arr, low, j);
 
		if (high > i)
			quickSort(arr, i, high);
	}
}

Output:

9 2 4 7 3 7 10
2 3 4 7 7 9 10
Category >> Algorithms  
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:
<pre><code> 
String foo = "bar";
</code></pre>

  1. kd on 2014-4-17

    Just a little hint: (low + high) / 2 = low + (high – low) / 2.

  2. Ashish Thakran on 2014-7-24

    Quicksort is slightly sensitive to input that happens to be in the right order, in which case it can skip some swaps. Mergesort doesn’t have any such optimizations, which also makes Quicksort a bit faster compared to Mergesort.

    To know more about quicksort and mergesort, below link can be useful

    Why Quick sort is better than Merge sort

  3. Govind on 2014-7-25

    Good tutorial, but it’s important to note that it’s not stable. If you have same numbers they will not retain their places after sorting. By the way you can also use following quicksort algorithm to sort it in-place.

  4. Pravesh Jain on 2014-12-21

    Just a little problem with your statement. You mean to say they will not retain their *order* after sorting. Not places.

  5. crackerplace on 2015-2-8

    I just wanted to understand one point.The above quickSort method excluding the recursion part modifies the array such that all elements less than pivot are on left side and all elements greater than pivot are on right side.Is this correct.My point is that the pivot will not be at the boundary but it will be somewhere in the right part ?

  6. theLastUnicorn on 2015-2-17

    ah no? He’s referring to get the difference first: (high – low), then use this divided by 2, then add to the starting position, which “low+” will be the last operation.

  7. JavaPrograms on 2015-8-20

    check this program with explanation http://goo.gl/6d529h

  8. Elver on 2015-10-13

    shouldn’t “if(i <= j)" just be "if(i < j)"? What is the point to swap i and j if both index where equal?

  9. u2 on 2015-11-5

    2(low)/2+(high-low)/2 = (2low-low+high)/2 = (low+high)/2.

  10. Dylan Yiyang Qiu on 2015-12-11

    In recursively sort two sub parts, it seems you don’t need to check relationship between low and j (high and i) before you call quickSort. Since you define a stop condition of low>=high at the beginning.

  11. Nanda firizki on 2015-12-22

    i like this program and i understand it , thanks bro

  12. Anirudh Mathad on 2016-4-19

    Can we remove the if conditions here :

    if (low i)

    quickSort(arr, i, high);

    Inside the function we are again checking the same.

  13. kk on 2016-5-27

    I could be wrong but I think the running time for the partition part could be O(n^2) so this Quicksort does not have O(nlgn) running time.

  14. Sergey Dinamik on 2016-6-28

    I’m thinking about it 30 mins already ) voting for “yes, we can”

  15. Nate Neu on 2016-11-11

    Just a real hint ( low + high ) >> 1 is even faster

  16. Zinga Zee on 2016-12-22

    try this

    public void quickSort(int[] arr, int p, int r){

    if(p < r) {

    int q = partition(arr, p, r);

    quickSort(arr, p, q-1);

    quickSort(arr, q+1, r);

    }

    }

    public int partition(int arr[], int p, int r)

    {

    int i = p-1;

    int pivot = arr[r];

    for (int j = p; j <= r; j++) {

    if(arr[j] <= pivot){

    i++;

    //do the swap

    if(i!=j){

    arr[i] = arr[i] ^ arr[j];

    arr[j] = arr[i] ^ arr[j];

    arr[i] = arr[i] ^ arr[j];

    }

    }

    }

    return i;

    }

  17. Jack on 2016-12-27

    Doesn’t one of the pivot conditionals need to have an equals, such as =, instead of ? Otherwise, what happens if the pivot value occurs multiple times in the array?

  18. Christopher Angulo Avila on 2017-4-20

    Hmm, I feel bad for not being able to implement this myself ,,,, 🙁

  19. Gilador on 2017-7-21

    Running time is N log N for the average input.
    Each recursion runs log N (average) times, and each run is bounded to N

  20. sorter on 2017-11-5

    Instead of the first line in your quickSort:
    if (arr == null || arr.length == 0)
    return;
    i would write in main:
    if( x.length != 0 )
    {
    quickSort(x, low, high);
    System.out.println(Arrays.toString(x));
    }

  21. sorter on 2017-11-5

    And instead of:
    int middle = low + (high – low) / 2;
    int pivot = arr[middle];
    i would write:
    int pivot = arr[ (high + low ) / 2];

    Because i have knowledge in math, i can make your math expression less complicate for you:
    low + (high – low) / 2
    = low + high/2 – low/2
    = ( low – low/2 ) + high/2
    = low/2 + high/2
    = (low + high) / 2

  22. sorter2 on 2017-11-5

    And instead of:
    int middle = low + (high – low) / 2;
    int pivot = arr[middle];
    i would write:
    int pivot = arr[ (high + low ) / 2];

    Because i have knowledge in math, i can make your math expression less complicate for you:
    low + (high – low) / 2
    = low + high/2 – low/2
    = ( low – low/2 ) + high/2
    = low/2 + high/2
    = (low + high) / 2

Leave a comment

*