C++ Program for Pigeonhole Sort

Pigeonhole sorting is a sorting algorithm that is suitable for sorting lists of elements where the number of elements and the number of possible key values are approximately the same.
It requires O(n + Range) time where n is the number of elements in the input array and ‘Range’ is the number of possible values in the array.

Step-by-step approach:

• Find minimum and maximum values in the array. Let the minimum and maximum values be ‘min’ and ‘max’ respectively. Also, find the range as ‘max-min+1’.
• Set up an array of initially empty “pigeonholes” the same size as the range.
• Visit each element of the array and then put each element in its pigeonhole. An element arr[i] is put in the hole at index arr[i] – min.
• Start the loop all over the pigeonhole array in order and put the elements from non-empty holes back into the original array.

Comparison with Counting Sort : 
It is similar to counting sort, but differs in that it “moves items twice: once to the bucket array and again to the final destination “.

Below is the implementation of the above approach:

C++

/* C++ program to implement Pigeonhole Sort */
#include <bits/stdc++.h>
using namespace std;

/* Sorts the array using pigeonhole algorithm */
void pigeonholeSort(int arr[], int n)
{
    // Find minimum and maximum values in arr[]
    int min = arr[0], max = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] < min)
            min = arr[i];
        if (arr[i] > max)
            max = arr[i];
    }
    int range = max - min + 1; // Find range

    // Create an array of vectors. Size of array
    // range. Each vector represents a hole that
    // is going to contain matching elements.
    vector<int> holes[range];

    // Traverse through input array and put every
    // element in its respective hole
    for (int i = 0; i < n; i++)
        holes[arr[i] - min].push_back(arr[i]);

    // Traverse through all holes one by one. For
    // every hole, take its elements and put in
    // array.
    int index = 0; // index in sorted array
    for (int i = 0; i < range; i++) {
        vector<int>::iterator it;
        for (it = holes[i].begin(); it != holes[i].end();
             ++it)
            arr[index++] = *it;
    }
}

// Driver program to test the above function
int main()
{
    int arr[] = { 8, 3, 2, 7, 4, 6, 8 };
    int n = sizeof(arr) / sizeof(arr[0]);

    pigeonholeSort(arr, n);

    printf("Sorted order is : ");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

Output

Sorted order is : 2 3 4 6 7 8 8 

Time complexity: O(n + range), where n is the number of elements in the array and range is the range of the input data.
Auxiliary space: O(range)

Advantages of Pigeonhole sort:

• It is a non-comparison based sort making it faster in application.
• It is a stable sorting algorithm.
• It performs sorting in linear time.

Disadvantages of Pigeonhole sort:

• It is not easy to know the range of the numbers to sort.
• This number might only work with zero and positive integers.
• Pigeonhole Sort

Please refer to the complete article on Pigeonhole Sort for more details!