Pigeonhole Sort Algorithm Implementation in Java

Pigeonhole Sort Algorithm-

Pigeonhole sorting is a sorting algorithm that is suitable for sorting lists of elements where the number of elements (n) and the length of the range of possible key values (N) are approximately the same. It requires O(n + N) time. 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 [whereas] counting sort builds an auxiliary array then uses the array to compute each item's final destination and move the item there.

It requires O(n + Range) time where n is number of elements in input array and ‘Range’ is number of possible values in array.

The pigeonhole algorithm works as follows:

1)Given an array of values to be sorted, set up an auxiliary array of initially empty "pigeonholes," one pigeonhole for each key through the range of the original array.

2)Going over the original array, put each value into the pigeonhole corresponding to its key, such that each pigeonhole eventually contains a list of all values with that key.

3)Iterate over the pigeonhole array in order, and put elements from non-empty pigeonholes back into the original array.

                                                       

Example:

Suppose we were sorting these value pairs by their first element:

(5, "hello")
(3, "pie")
(8, "apple")
(5, "king")

For each value between 3 and 8 we set up a pigeonhole, then move each element to its pigeonhole:

3: (3, "pie")
4:
5: (5, "hello"), (5, "king")
6:
7:
8: (8, "apple")

We then iterate over the pigeonhole array in order and move them back to the original list.

The difference between pigeonhole sort and counting sort is that in counting sort, the auxiliary array does not contain lists of input elements, only counts:

3: 1
4: 0
5: 2
6: 0
7: 0
8: 1

Using this information we can perform a series of exchanges on the input array that puts it in order, moving items only once.

For arrays where N is much larger than n, bucket sort is a generalization that is more efficient in space and time.

Code Example implementation in Java:

import java.util.Arrays;
/**
 * @author Abhinaw.Tripathi
 *
 */
public class PigeonholeSortApp
{

public static void pigeonholesort(int arr[],int n)
{
int min=arr[0];
int max=arr[0];

for(int a=0;a<n;a++)
{
if(arr[a]>max)
max=arr[a];
if(arr[a]<min)
min=arr[a];
}

int range=max-min+1;
int[] phole=new int[range];
Arrays.fill(phole, 0);

for(int i=0;i<n;i++)
phole[arr[i]-min]++;

int index=0;

for(int j=0;j<range;j++)
while(phole[j]-->0)
arr[index++]=j+min;

}

public void printArray(int arr[])
{
        int n = arr.length;
        for(int i=0 ; i<n ; i++)
            System.out.print(arr[i]+" ");
    }
   
@SuppressWarnings("static-access")
public static void main(String[] args)
{
   PigeonholeSortApp sort = new PigeonholeSortApp();
          int[] arr = {82,37,61,21,34,92,12,19,42,37,55,72,86};
          System.out.println("Before : ");
          sort.printArray(arr);
          System.out.println("\nAfter : ");
          sort.pigeonholesort(arr,arr.length);
          sort.printArray(arr);
}

}

Result:

Before :
82 37 61 21 34 92 12 19 42 37 55 72 86
After :
12 19 21 34 37 37 42 55 61 72 82 86 92

Pigeonhole sort has limited use as requirements are rarely met. For arrays where range is much larger than n, bucket sort is a generalization that is more efficient in space and time.