Is Quick Sort Algorithm Adaptive or not

Last Updated : 02 May, 2025

Adaptive sorting algorithms are designed to take advantage of existing order in the input data. This means, if the array is already sorted or partially sorted, an adaptive algorithm will recognize that and sort the array faster than it would for a completely random array.

Quick Sort is not an adaptive algorithm. Let us understand with an example.

arr[] = [1,2,3,4,5];

So in the above example, we can see that the array is sorted, but Quick Sort will sort the array by picking a corner element in every call to partition. In fact, a sorted input causes the worst case of QuickSort because every time the array is going to be partitioned with n-1 elements in one side.

Can we make QuickSort Adaptive?

The following are different ways to make QuickSort perform better for sorted or almost sorted inputs.

1) We can handle the above case by adding a check for sorted before proceeding to partitioning the array. Below is an example code for the same.

C++

#include <iostream>
#include <vector>
using namespace std;

int partition(vector<int>& arr, int low, int high) {

    int pivot = arr[high];
  
    // Index of smaller element and indicates 
    // the right position of pivot found so far
    int i = low - 1;

    // Traverse arr[low..high] and move all smaller
    // elements on left side. Elements from low to 
    // i are smaller after every iteration
    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(arr[i], arr[j]);
        }
    }
    
    // Move pivot after smaller elements and
    // return its position
    swap(arr[i + 1], arr[high]);  
    return i + 1;
}

bool isSorted(vector<int>&arr,int low, int high) {
    for (int i = low; i < high - 1; i++) {
        if (arr[i] > arr[i + 1]) {
            return false;
        }
    }
    return true;
}

void quickSort(vector<int>& arr, int low, int high) {
    
    // If array is already Sorted then it will excecute
    if(isSorted(arr,low,high))
    {
        return;
    }
    
    if (low < high) {
      
        // pi is the partition return index of pivot
        int pi = partition(arr, low, high);

        // Recursion calls for smaller elements
        // and greater or equals elements
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

int main() {
    vector<int> arr = {1, 2, 3, 4, 5};
    int n = arr.size();
    quickSort(arr, 0, n - 1);
  
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

Java

import java.util.Arrays;

public class GfG{

    static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;

        for (int j = low; j <= high - 1; j++) {
            if (arr[j] < pivot) {
                i++;
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;
        return i + 1;
    }

    static boolean isSorted(int[] arr, int low, int high) {
        for (int i = low; i < high - 1; i++) {
            if (arr[i] > arr[i + 1]) {
                return false;
            }
        }
        return true;
    }

    static void quickSort(int[] arr, int low, int high) {
        if (isSorted(arr, low, high)) {
            return;
        }
        if (low < high) {
            int pi = partition(arr, low, high);
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int n = arr.length;
        quickSort(arr, 0, n - 1);
        System.out.println(Arrays.toString(arr));
    }
}

Python

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] < pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1

def is_sorted(arr, low, high):
    for i in range(low, high - 1):
        if arr[i] > arr[i + 1]:
            return False
    return True

def quick_sort(arr, low, high):
    if is_sorted(arr, low, high):
        return
    if low < high:
        pi = partition(arr, low, high)
        quick_sort(arr, low, pi - 1)
        quick_sort(arr, pi + 1, high)

if __name__ == '__main__':
    arr = [1, 2, 3, 4, 5]
    n = len(arr)
    quick_sort(arr, 0, n - 1)
    print(arr)

using System;

class GfG {
    
    // Function to partition the array
    static int Partition(int[] arr, int low, int high) {
        int pivot = arr[high];  
        int i = low - 1; 
        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                // Swap arr[i] and arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // Swap arr[i + 1] and arr[high] (pivot)
        int temp2 = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp2;
        return i + 1;  
    }

    // QuickSort method to sort the array
    static void QuickSortMethod(int[] arr, int low, int high) {
        if (low < high) {
            int pi = Partition(arr, low, high);  
            QuickSortMethod(arr, low, pi - 1);
            QuickSortMethod(arr, pi + 1, high); 
        }
    }

    static void Main() {
        int[] arr = { 1, 2, 3, 4, 5 }; 
        int n = arr.Length;
        
      
        QuickSortMethod(arr, 0, n - 1);
        
        // Output the sorted array
        Console.WriteLine(string.Join(" ", arr));
    }
}

JavaScript

function partition(arr, low, high) {
    let pivot = arr[high];
    let i = low - 1;
    for (let j = low; j < high; j++) {
        if (arr[j] < pivot) {
            i++;
            [arr[i], arr[j]] = [arr[j], arr[i]];
        }
    }
    [arr[i + 1], arr[high]] = [arr[high], arr[i + 1]];
    return i + 1;
}

function isSorted(arr, low, high) {
    for (let i = low; i < high - 1; i++) {
        if (arr[i] > arr[i + 1]) {
            return false;
        }
    }
    return true;
}

function quickSort(arr, low, high) {
    if (isSorted(arr, low, high)) {
        return;
    }
    if (low < high) {
        let pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

const arr = [1, 2, 3, 4, 5];
const n = arr.length;
quickSort(arr, 0, n - 1);
console.log(arr);

Output

Array before sorting : 1 2 3 4 5 
Array after sorting : 1 2 3 4 5

If the array is already sorted, each element is traversed almost once. Therefore, the time complexity becomes O(n) and otherwise, it would have taken O(n²).

2) Instead of choosing a random or first element as pivot, pick the median of the first, middle, and last elements. This reduces the chance of worst-case behavior on nearly sorted arrays.

3) We can switch to Insertion Sort for smaller arrays. Insertion Sort is adaptive and performs very well on nearly sorted data. So many QuickSort implementations switch to Insertion Sort for small partitions (say, size < 10).

Why quicksort is better than mergesort ?

mayank007rawa

Improve

Article Tags :

Practice Tags :

Algorithms

Is Quick Sort Algorithm Adaptive or not

Similar Reads

QuickSort using different languages

Iterative QuickSort

Different implementations of QuickSort

Visualization of QuickSort

Partitions in QuickSort

Some problems on QuickSort

Thank You!

What kind of Experience do you want to share?