# Java Sorting Algorithms: Quick Sort Welcome back to this overview about the Java world! Today, we are going to talk about a renowned sorting algorithm: the Quick Sort.

The Quick Sort is not very suitable for educational purposes because its implementation may not be trivial, but at the performance level it offers some advantages that are not indifferent, unlike the previously trated Bubble Sort.

Let's try to understand better what is Quick Sort.

First of all, let's see an image that gives us an idea of how the algorithm works. ### Foundamental features and description

The Quick Sort is one of the most used algorithms, expecially when huge amounts of data have to be treated. Just like some other algorithms, it is part of the Divide and Conquer family.

It means that the processing is not done on the entire data collection, but it is recursively done on finite subsets of the collection. This feature makes the sorting operations lighter from the moment that the values that have to be compared are two at most.

Let's remember that the Quick Sort is a stable and in-place algorithm. Generally no algorithm is stable, but it can be made stable using indexes as meter of comparison.

These are the main steps of the algorithm.

If the collection is composed of zero or one element, then it is sorted. Otherwise the following steps are performed:

1. A pivot is chosen;
2. The elements of the array are divided into two parts: the one of the elements before the pivot and the one of the elements after the pivot;
3. The elements are sorted recursively repeating the 1 and 2 steps;

### Implementation

```import java.util.*;
public class QuickSort
{
/*
This function takes the last element as pivot,
place the pivot element in its right position
in the sorted array. It also puts every element smaller than the pivot
on the left and every element bigger than the pivot on the right.
*/
private static int partition(int arr[], int low, int high)
{
int pivot = arr[high];
int index = (low-1); // index of the smaller element. -1 at the beginning
for (int j=low; j<high; j++)
{
// if the current element is smaller than pivot
if (arr[j] < pivot)
{
index++;
// swap arr[index] and arr[j]
int temp = arr[index];
arr[index] = arr[j];
arr[j] = temp;
}
}
// swap arr[index+1] and arr[high] (or pivot)
int temp = arr[index+1];
arr[index+1] = arr[high];
arr[high] = temp;
return index+1;
}
/* The main function that implements QuickSort()
arr[] --> array to be sorted,
low --> starting index,
high --> ending index */
public static void sort(int arr[], int low, int high)
{
if (low < high)
{
/* pi is the partitioning index, arr[pi] is now in the right place */
int pi = partition(arr, low, high);
// Recursively order the elements before
// partition and after partition
sort(arr, low, pi-1);
sort(arr, pi+1, high);
}
}
// Driver program.
public static void main(String args[])
{
int arr[] = {10, 7, 8, 9, 1, 5};
int n = arr.length;
QuickSort.sort(arr, 0, n-1);
System.out.println("sorted array");
System.out.println(Arrays.toString(arr));
}
}
```

### Let's understand the code

The most important element is the choice of the pivot. The ideal pivot should be the medium element of the collection but it is too difficult to find in an unsorted collection. The choices can be different. The first element, the last element, the middle element or a random element can be chosen as pivot.

The main method is partition that takes as parameters the collection to sort, that is an array of integer numbers, and the two extremes of the array, low and high.

In this method every swapping operation is done. This is the method that implements the majority of the algorithm.

The method's body contains simply some swapping operations done only under certain conditions. The very easy principle is the one that exchanging two sorted elements is useless, so the current element j is compared to the pivot.

The indexes have the following meanings:

• index stands for the minimum element that has been examined;
• j is the current element;

The sort method is the wrapper for partition. The control on low and high is performed in order to verify that they "make sense" and that situations where low=2 and high=1 don't occurr since inconsistent situations can happen.

The partition index is calculated.

At the end we have the main method, where the array to sort is created. Then the sort method is called on the array with 0 and n-1 as indexes (where n is the array's length).

Must be precised that I chose to make the sort method static. I decided to implement it as a static method because I imagined the code presented above as a part of a bigger class that implements more than one algorithm. Since sort is static, partition must be static.

A non-static method could have been implemented and the effect would have been the same.

Clearly, just like the majority of the situations that happen in Computer Science, there are many different variations of the implementation of the Quick Sort. Every variant has the same final result. The implementation details change.

The time taken from the Quick Sort can be expressed as:

```T(n) = T(k) + T(n-k-1) + (n)
```

The first two terms represent the two recursive calls and k stands for the element "smaller" than the pivot. The effective time depends on the pivot choice. Let's look at some particular cases:

Worst case:

```T(n) = T(n-1) + (n)
```

It happens when the smallest or the biggest element is chosen as pivot.

The complexity can be written as (n2). Notice the exponential growth.

Best case:

```T(n) = 2T(n/2) + (n)
```

The complexity can be written as (nLogn).

Average case:

```T(n) = T(n/9) + T(9n/10) + (n)
```

In order to make an accurate analysis of the complexity in the average case we should calculate every possible permutation of the elements of the collection and it is not easy. We can have an idea of the complexity considering the case where partition puts O(n/9) elements in a subset and O(9n/10) in the other subset.

The complexity can be written as (nLogn) also in this case.

### Curiosity: what is three-way-quick-sort?

Il three-way-quick-sort è una versione del Quick Sort dove la collezione da ordinare viene divisa così come segue:

The three-way-quick-sort is a version of the Quick Sort where the array to sort is divided as shown below:

• array[low...i] is the subset of the elements smaller than the pivot;
• array[i...j-1] is the subset of the element equals to the pivot;
• array[j...high] is the subset of the element bigger than the pivot;

E' evidente che questa versione sia conveniente solo quando ci sono diversi elementi ridondanti nella collezione. In caso contrario sarebbe priva di senso.

Clearly this version has to be used only if there are many redundant element in the collection. In the other case it would not make any sense.

by Alessio Mungelli Date: 14-12-2019 java jdk source code explanation tutorial educational quick sort sortingmethod developing developers hits : 2106 #### Alessio Mungelli

Computer Science student at UniTo (University of Turin), Network specializtion, blogger and writer. I am a kind of expert in Java desktop developement with interests in AI and web developement. Unix lover (but not Windows hater). I am interested in Linux scripting. I am very inquisitive and I love learning new stuffs.

### Related Posts

#### The most popular Array Sorting Algorithms In PHP

There are many ways to sort an array in PHP, the easiest being to use the sort() function built into PHP. This sort function is quick but has it's limitations,…

#### The package managers npm and yarn: main differences

Npm and yarn are package managers that help to manage a project’s dependencies. A dependency is, as it sounds, something that a project depends on, a piece of code that…

#### The Javascript asign() method to merge and clone objects

In this article, we will be covering Object.assign()method in javascript in detail with examples. A javascript object is a collection of key-value pairs. Keys are also known as properties of object. Keys…

#### All the javascript functions and methods to manipulate arrays

This article will show that the prominent JavaScript array functions are .map(), .filter(), and .reduce(), and will then go through examples of instances in which .every() and .some() would save…

#### TypeScript: The evolution of JavaScript

When you're involved in the development of a large project, programming languages like JavaScript don't seem to be the best solution. Their lack of elements such as Language Aids has…

#### Awesome JavaScript Games and Js Software to create Games

Best sites js13kGames 2019 - Highlights from the js13kGames 2019 competition. js13kGames 2018 - 13 Games in ≤ 13kB of JavaScript. js13kGames 2017 - Build a game in 13kB or less with js13kGames. Adventure Triangle:…

#### Is JavaScript good for machine learning?

One of the things you always hear when you are talking to someone related to the M.L. world is that, one must learn Python because the vast majority of the…

#### First steps into JavaScript – a practical guide 3

After we learned the basic ofaccessing DOM elementsandhow to modify them,we are ready for the more exciting parts – handling DOM events. This allows us to make our web way more…

#### JavaScript: Promises explained with simple real life examples

Handling asynchronous data flows is complex, who hasn't faced codes like this one?: checkWeather('palma de mallorca', (error, weather) => { if (error) throw error; if (weather === 'well') { return checkFlights('palma…

#### First steps into JavaScript – a practical guide 2

In the previous aticleFirst steps into JavaScript – a practical guidewe covered the basics of the DOM and its relation to us becoming JS literate. Now that we know how…

#### First steps into JavaScript – a practical guide

For those who are new to web development, surely the amount of new terminology can sometimes be discouraging. But when it comes to learning JS, some of the first new…

#### Linux For Dummies: Permissions

In the previous articles I made a short introduction to the Unix world and in the following article I have dealt with the basic commands for the file system management. Today we are…