Stable QuickSort

Last Updated : 06 Aug, 2024

A sorting algorithm is said to be stable if it maintains the relative order of records in the case of equality of keys.

Input : (1, 5), (3, 2) (1, 2) (5, 4) (6, 4)
We need to sort key-value pairs in the increasing order of keys of first digit
There are two possible solution for the two pairs where the key is same i.e. (1, 5) and (1, 2) as shown below:
OUTPUT1: (1, 5), (1, 2), (3, 2), (5, 4), (6, 4)
OUTPUT2: (1, 2), (1, 5), (3, 2), (5, 4), (6, 4)
A stable algorithm produces first output. You can see that (1, 5) comes before (1, 2) in the sorted order, which was the original order i.e. in the given input, (1, 5) comes before (1, 2).
Second output can only be produced by an unstable algorithm. You can see that in the second output, the (1, 2) comes before (1, 5) which was not the case in the original input.

Some sorting algorithms are stable by nature like Insertion sort, Merge Sort, Bubble Sort, etc. And some sorting algorithms are not, like Heap Sort, Quick Sort, etc.
QuickSort is an unstable algorithm because we do swapping of elements according to pivot's position (without considering their original positions).

How to make QuickSort stable?

Quicksort can be stable but it typically isn’t implemented that way. Making it stable either requires order N storage (as in a naive implementation) or a bit of extra logic for an in-place version.
In below implementation, we use extra space.

The idea is to make two separate lists:

First list contains items smaller than pivot.
Second list contains items greater than pivot.

Implementation:

C++

// C++ code to implement Stable QuickSort.
// The code uses middle element as pivot.
#include <bits/stdc++.h>
using namespace std;

vector<int> quickSort(vector<int> &ar)
{
    // Base case
    if (ar.size() <= 1)
        return ar;

    // Let us choose middle element as pivot
    int mid = ar.size() / 2;
    int pivot = ar[mid];

    // key element is used to break the array
    // into 2 halves according to their values
    vector<int> smaller;
    vector<int> greater;

    // Put greater elements in greater list,
    // smaller elements in smaller list. Also,
    // compare positions to decide where to put.
    for (int ind = 0; ind < ar.size(); ind++)
    {
        int val = ar[ind];
        if (ind != mid)
        {
            if (val < pivot)
                smaller.push_back(val);
            else if (val > pivot)
                greater.push_back(val);
            else
            {
                // If value is same, then considering
                // position to decide the list.
                if (ind < mid)
                    smaller.push_back(val);
                else
                    greater.push_back(val);
            }
        }
    }

    vector<int> ans;
    vector<int> sa1 = quickSort(smaller);
    vector<int> sa2 = quickSort(greater);

    // add all elements of smaller list into ans list
    for (int val1 : sa1)
        ans.push_back(val1);

    // add pivot element into ans list
    ans.push_back(pivot);

    // add all elements of greater list into ans list
    for (int val2 : sa2)
        ans.push_back(val2);

    // return ans list
    return ans;
}

// Driver code
int main()
{
    vector<int> al = {10, 7, 8, 9, 1, 5};
    vector<int> sortedAr = quickSort(al);

    for (int x : sortedAr)
        cout << x << " ";
   
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

void stableQuickSort(int *arr, int size) {
    // Base case
    if (size <= 1)
        return;

    // Let us choose the middle element as pivot
    int mid = size / 2;
    int pivot = arr[mid];

    // Key element is used to break the array
    // into 2 halves according to their values
    int *smaller = (int *)malloc(size * sizeof(int));
    int *greater = (int *)malloc(size * sizeof(int));
    int smallerCount = 0, greaterCount = 0;

    // Put greater elements in the greater list,
    // smaller elements in the smaller list. Also,
    // compare positions to decide where to put.
    for (int i = 0; i < size; i++) {
        if (i != mid) {
            int val = arr[i];
            if (val < pivot)
                smaller[smallerCount++] = val;
            else if (val > pivot)
                greater[greaterCount++] = val;
            else {
                // If value is the same, then considering
                // position to decide the list.
                if (i < mid)
                    smaller[smallerCount++] = val;
                else
                    greater[greaterCount++] = val;
            }
        }
    }

    stableQuickSort(smaller, smallerCount);
    stableQuickSort(greater, greaterCount);

    // Combine the results
    for (int i = 0; i < smallerCount; i++)
        arr[i] = smaller[i];
    arr[smallerCount] = pivot;
    for (int i = 0; i < greaterCount; i++)
        arr[smallerCount + 1 + i] = greater[i];

    free(smaller);
    free(greater);
}

// Function to print an array
void printArray(int *arr, int size) {
    for (int i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

// Driver code
int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);

    stableQuickSort(arr, n);

    printf("Sorted array:\n");
    printArray(arr, n);

    return 0;
}

Java

import java.util.ArrayList;
import java.util.List;

public class GfG {

    public static List<Integer> quickSort(List<Integer> ar) {
        // Base case
        if (ar.size() <= 1) {
            return ar;
        }

        // Let us choose the middle element as pivot
        int mid = ar.size() / 2;
        int pivot = ar.get(mid);

        // Key element is used to break the array
        // into 2 halves according to their values
        List<Integer> smaller = new ArrayList<>();
        List<Integer> greater = new ArrayList<>();

        // Put greater elements in the greater list,
        // smaller elements in the smaller list. Also,
        // compare positions to decide where to put.
        for (int i = 0; i < ar.size(); i++) {
            if (i != mid) {
                int val = ar.get(i);
                if (val < pivot) {
                    smaller.add(val);
                } else if (val > pivot) {
                    greater.add(val);
                } else {
                  
                    // If value is the same, then considering
                    // position to decide the list.
                    if (i < mid) {
                        smaller.add(val);
                    } else {
                        greater.add(val);
                    }
                }
            }
        }

        List<Integer> ans = new ArrayList<>();
        ans.addAll(quickSort(smaller));
        ans.add(pivot);
        ans.addAll(quickSort(greater));

        // Return ans list
        return ans;
    }

    // Driver code
    public static void main(String[] args) {
        List<Integer> al = new ArrayList<>();
        al.add(10);
        al.add(7);
        al.add(8);
        al.add(9);
        al.add(1);
        al.add(5);

        List<Integer> sortedAr = quickSort(al);

        for (int x : sortedAr) {
            System.out.print(x + " ");
        }
    }
}

Python

# Python code to implement Stable QuickSort.
# The code uses middle element as pivot.
def quickSort(ar):
     
    # Base case
    if len(ar) <= 1:
        return ar

    # Let us choose middle element a pivot
    else:
        mid = len(ar)//2
        pivot = ar[mid]

        # key element is used to break the array
        # into 2 halves according to their values
        smaller,greater = [],[]
 
        # Put greater elements in greater list,
        # smaller elements in smaller list. Also,
        # compare positions to decide where to put.
        for indx, val in enumerate(ar):
            if indx != mid:
                if val < pivot:
                    smaller.append(val)
                elif val > pivot:
                    greater.append(val)

                # If value is same, then considering
                # position to decide the list.
                else:
                    if indx < mid:
                        smaller.append(val)
                    else:
                        greater.append(val)
        return quickSort(smaller)+[pivot]+quickSort(greater)
    
# Driver code to test above 
ar = [10, 7, 8, 9, 1, 5] 
sortedAr = quickSort(ar) 
print(sortedAr)

using System;
using System.Collections.Generic;

class GfG
{
    public static List<int> QuickSort(List<int> ar)
    {
        // Base case
        if (ar.Count <= 1)
            return ar;

        // Let us choose the middle element as pivot
        int mid = ar.Count / 2;
        int pivot = ar[mid];

        // Key element is used to break the array
        // into 2 halves according to their values
        List<int> smaller = new List<int>();
        List<int> greater = new List<int>();

        // Put greater elements in the greater list,
        // smaller elements in the smaller list. Also,
        // compare positions to decide where to put.
        for (int ind = 0; ind < ar.Count; ind++)
        {
            int val = ar[ind];
            if (ind != mid)
            {
                if (val < pivot)
                    smaller.Add(val);
                else if (val > pivot)
                    greater.Add(val);
                else
                {
                    // If value is the same, then considering
                    // position to decide the list.
                    if (ind < mid)
                        smaller.Add(val);
                    else
                        greater.Add(val);
                }
            }
        }

        List<int> ans = new List<int>();
        List<int> sa1 = QuickSort(smaller);
        List<int> sa2 = QuickSort(greater);

        // Add all elements of the smaller list into the ans list
        ans.AddRange(sa1);

        // Add pivot element into the ans list
        ans.Add(pivot);

        // Add all elements of the greater list into the ans list
        ans.AddRange(sa2);

        // Return ans list
        return ans;
    }

    // Driver code
    static void Main()
    {
        List<int> al = new List<int> { 10, 7, 8, 9, 1, 5 };
        List<int> sortedAr = QuickSort(al);

        foreach (int x in sortedAr)
            Console.Write(x + " ");
    }
}

JavaScript

function quickSort(arr) {
    // Base case
    if (arr.length <= 1) {
        return arr;
    }

    // Let us choose the middle element as pivot
    const mid = Math.floor(arr.length / 2);
    const pivot = arr[mid];

    // Key element is used to break the array
    // into 2 halves according to their values
    const smaller = [];
    const greater = [];

    // Put greater elements in the greater list,
    // smaller elements in the smaller list. Also,
    // compare positions to decide where to put.
    for (let i = 0; i < arr.length; i++) {
        if (i !== mid) {
            const val = arr[i];
            if (val < pivot) {
                smaller.push(val);
            } else if (val > pivot) {
                greater.push(val);
            } else {
            
                // If value is the same, then considering
                // position to decide the list.
                if (i < mid) {
                    smaller.push(val);
                } else {
                    greater.push(val);
                }
            }
        }
    }

    // Recursively sort the smaller and greater lists
    const sortedSmaller = quickSort(smaller);
    const sortedGreater = quickSort(greater);

    // Concatenate the results:
    return [...sortedSmaller, pivot, ...sortedGreater];
}

// Driver code
const arr = [10, 7, 8, 9, 1, 5];
const sortedArr = quickSort(arr);
console.log("Sorted array:");
console.log(sortedArr.join(' '));

Output

[1, 5, 7, 8, 9, 10]

In above code, we have intentionally used middle element as a pivot to demonstrate how to consider a position as part of the comparison. Code simplifies a lot if we use last element as pivot. In the case of last element, we can always push equal elements in the smaller list.

Auxiliary Space : O(n) for the auxiliary arrays that we create. Recursion might also take upto O(n) time if one part is empty in every recursive call.

Dual pivot Quicksort

shefali163

Improve

Article Tags :

Sorting
DSA

Practice Tags :

Sorting

Stable QuickSort

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?