This article needs additional citations for verification. (July 2017)
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."
|Worst-case performance||, where N is the range of key values and n is the input size|
|Worst-case space complexity|
The pigeonhole algorithm works as follows:
- Given an array of values to be sorted, set up an auxiliary array of initially empty "pigeonholes", one pigeonhole for each key in the range of the keys in the original array.
- 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.
- Iterate over the pigeonhole array in increasing order of keys, and for each pigeonhole, put its elements into the original array in increasing order.
Suppose one 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")
- 5: (5, "hello"), (5, "king")
- 8: (8, "apple")
The pigeonhole array is then iterated over in order, and the elements are moved 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
For arrays where N is much larger than n, bucket sort is a generalization that is more efficient in space and time.
from typing import List, Tuple, Any def pigeonhole_sort(lst: List[Tuple[int, Any]]) -> None: """ In-place sorts a list of (key, value) tuples by key. :param lst: A list of tuples, each having a key as a number and a value that can be anything. :return: None """ base = min(key for key, value in lst) size = max(key for key, value in lst) - base + 1 # Create the empty list (of lists) to be filled # It's a list of lists because the key can appear twice pigeonholes: List[List[Tuple[int, Any]]] = [ for _ in range(size)] for key, value in lst: index = key - base pigeonhole = pigeonholes[index] pigeonhole.append((key, value)) lst.clear() # Re-initialize the list: we're going to re-fill it from the pigeonholes for pigeonhole in pigeonholes: lst.extend(pigeonhole)
- NIST's Dictionary of Algorithms and Data Structures: pigeonhole sort
- Black, Paul E. "Dictionary of Algorithms and Data Structures". NIST. Retrieved 6 November 2015.
|The Wikibook Algorithm implementation has a page on the topic of: Pigeonhole sort|