DSA using Java - Quick Sort

Overview

Quick sort is a highly efficient sorting algorithm and is based on partitioning of array of data into smaller arrays. A large array is partitioned into two arrays one of which holds values smaller than specified value say pivot based on which the partition is made and another array holds values greater than pivot value.

The quick sort partitions an array and then calls itself recursively twice to sort the resulting two subarray. This algorithm is quite efficient for large sized data sets as its average and worst case complexity are of O(nlogn) where n are no. of items.

Pseudocode

A : array of items 

procedure quickSort(left, right)
   if right-left <= 0
      return
   else     
      pivot = A[right]
      partition = partitionFunc(left, right, pivot)
      quickSort(left,partition-1)
      quickSort(partition+1,right)    
   end if		
end procedure

function partitionFunc(left, right, pivot)
   leftPointer = left -1
   rightPointer = right

   while True do
      while A[++leftPointer] < pivot do
         //donothing            
      end while
      while rightPointer > 0 && A[--rightPointer] > pivot do
         //donothing         
      end while
      if leftPointer >= rightPointer
         break
      else                
         swap leftPointer,rightPointer
      end if
   end while      
   swap leftPointer,right
   return leftPointer
end function

procedure swap (num1, num2)
   temp = A[num1]
   A[num1] = A[num2]
   A[num2] = temp;
end procedure

Demo Program

package com.tutorialspoint.advancedsort;

import java.util.Arrays;

public class QuickSortDemo {
   private static int[] intArray = {4,6,3,2,1,9,7};

   public static void main(String[] args){      
      QuickSortDemo quickSortDemo = new QuickSortDemo();
      System.out.println("Input Array: " +Arrays.toString(intArray));
      printline(50);   
      quickSortDemo.quickSort(0, intArray.length-1);
      System.out.println("Output Array: " + Arrays.toString(intArray));
      printline(50);        
   }    

   public static void printline(int count){
      for(int i=0;i <count-1;i++){
         System.out.print("=");
      }
      System.out.println("=");
   }   

   private int partition(int left, int right, int pivot){
      int leftPointer = left -1;
      int rightPointer = right;

      while(true){
            while(intArray[++leftPointer] < pivot){
            //do nothing
         }
         while(rightPointer > 0 && intArray[--rightPointer] > pivot){
            //do nothing
         }

         if(leftPointer >= rightPointer){
            break;
         }else{
            System.out.println(" item swapped :" 
            + intArray[leftPointer]+","+intArray[rightPointer]);
            swap(leftPointer,rightPointer);
         }
      }
      System.out.println(" pivot swapped :" 
      + intArray[leftPointer]+","+intArray[right]);
      swap(leftPointer,right);
      System.out.println("Updated Array: " 
      + Arrays.toString(intArray));       
      return leftPointer;
   }

   private void swap(int num1, int num2){
      int temp = intArray[num1];
      intArray[num1] = intArray[num2];
      intArray[num2] = temp;
   }

   public void quickSort(int left, int right){        
      if(right-left <= 0){
         return;
      }else{
         int pivot = intArray[right];
         int partition = partition(left, right, pivot);
         quickSort(left,partition-1);
         quickSort(partition+1,right);
      }        
   }   
}

If we compile and run the above program then it would produce following result −

Input Array: [4, 6, 3, 2, 1, 9, 7]
==================================================
 pivot swapped :9,7
Updated Array: [4, 6, 3, 2, 1, 7, 9]
 pivot swapped :4,1
Updated Array: [1, 6, 3, 2, 4, 7, 9]
 item swapped :6,2
 pivot swapped :6,4
Updated Array: [1, 2, 3, 4, 6, 7, 9]
 pivot swapped :3,3
Updated Array: [1, 2, 3, 4, 6, 7, 9]
Output Array: [1, 2, 3, 4, 6, 7, 9]
==================================================