鸽眼排序

Pigeonhole排序是一种排序算法，适用于排序元素数量和可能的键值数量大致相同的元素列表。
它需要O( n + Range )时间，其中n是输入数组中元素的数量，而’Range’是数组中可能值的数量。
算法工作：

1. 在数组中找到最小值和最大值。令最小值和最大值分别为“ min”和“ max”。还可以找到“ max-min + 1”的范围。
2. 设置一系列初始为空的“鸽子洞”，其大小与范围相同。
3. 访问数组的每个元素，然后将每个元素放入其鸽子洞中。将元素arr [i]放在索引为arr [i]-min的孔中。
4. 按顺序在鸽孔阵列上开始循环，然后将非空孔中的元素放回原始阵列中。

与计数排序的比较：
它类似于计数排序，但不同之处在于它“两次移动项目：一次到存储桶数组，再一次到最终目的地”。

C++

/* C program to implement Pigeonhole Sort */
#include 
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 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::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;
}

Java

/* Java program to implement Pigeonhole Sort */
 
import java.lang.*;
import java.util.*;
 
public class GFG
{
    public static void pigeonhole_sort(int arr[],
                                           int n)
    {
        int min = arr[0];
        int max = arr[0];
        int range, i, j, index;
 
        for(int a=0; a max)
                max = arr[a];
            if(arr[a] < min)
                min = arr[a];
        }
 
        range = max - min + 1;
        int[] phole = new int[range];
        Arrays.fill(phole, 0);
 
        for(i = 0; i0)
                arr[index++]=j+min;
 
    }
 
    public static void main(String[] args)
    {
        GFG sort = new GFG();
        int[] arr = {8, 3, 2, 7, 4, 6, 8};
 
        System.out.print("Sorted order is : ");
 
        sort.pigeonhole_sort(arr,arr.length);
         
        for(int i=0 ; i

Python3

# Python program to implement Pigeonhole Sort */
 
# source code : "https://en.wikibooks.org/wiki/
#   Algorithm_Implementation/Sorting/Pigeonhole_sort"
def pigeonhole_sort(a):
    # size of range of values in the list
    # (ie, number of pigeonholes we need)
    my_min = min(a)
    my_max = max(a)
    size = my_max - my_min + 1
 
    # our list of pigeonholes
    holes = [0] * size
 
    # Populate the pigeonholes.
    for x in a:
        assert type(x) is int, "integers only please"
        holes[x - my_min] += 1
 
    # Put the elements back into the array in order.
    i = 0
    for count in range(size):
        while holes[count] > 0:
            holes[count] -= 1
            a[i] = count + my_min
            i += 1
             
 
a = [8, 3, 2, 7, 4, 6, 8]
print("Sorted order is : ", end = ' ')
 
pigeonhole_sort(a)
         
for i in range(0, len(a)):
    print(a[i], end = ' ')

C#

// C# program to implement
// Pigeonhole Sort
using System;
 
class GFG
{
public static void pigeonhole_sort(int []arr,
                                   int n)
{
    int min = arr[0];
    int max = arr[0];
    int range, i, j, index;
 
    for(int a = 0; a < n; a++)
    {
        if(arr[a] > max)
            max = arr[a];
        if(arr[a] < min)
            min = arr[a];
    }
 
    range = max - min + 1;
    int[] phole = new int[range];
     
    for(i = 0; i < n; i++)
    phole[i] = 0;
 
    for(i = 0; i < n; i++)
        phole[arr[i] - min]++;
 
     
    index = 0;
 
    for(j = 0; j < range; j++)
        while(phole[j] --> 0)
            arr[index++] = j + min;
 
}
 
// Driver Code
static void Main()
{
    int[] arr = {8, 3, 2, 7,
                 4, 6, 8};
 
    Console.Write("Sorted order is : ");
 
    pigeonhole_sort(arr,arr.Length);
     
    for(int i = 0 ; i < arr.Length ; i++)
        Console.Write(arr[i] + " ");
}
}
 
// This code is contributed
// by Sam007

Javascript

 
// JavaScript program to implement
// Pigeonhole Sort
 
function pigeonhole_sort(arr, n)
{
    let min = arr[0];
    let max = arr[0];
    let range, i, j, index;
   
    for(let a = 0; a < n; a++)
    {
        if(arr[a] > max)
            max = arr[a];
        if(arr[a] < min)
            min = arr[a];
    }
   
    range = max - min + 1;
    let phole = [];
       
    for(i = 0; i < n; i++)
    phole[i] = 0;
   
    for(i = 0; i < n; i++)
        phole[arr[i] - min]++;
   
       
    index = 0;
   
    for(j = 0; j < range; j++)
        while(phole[j] --> 0)
            arr[index++] = j + min;
   
}
 
// Driver Code
 
    let arr = [8, 3, 2, 7,
                 4, 6, 8];
   
    document.write("Sorted order is : ");
   
    pigeonhole_sort(arr,arr.length);
       
    for(let i = 0 ; i < arr.length ; i++)
        document.write(arr[i] + " ");
     
    // This code is contributed by target_2.

输出：

Sorted order is : 2 3 4 6 7 8 8 

由于很少满足要求，鸽孔分类的用途受到限制。对于范围远大于n的数组，存储桶排序是一种在空间和时间上更有效的概括。

GeeksforGeeks / GeeksQuiz上的其他排序算法
选择排序，气泡排序，插入排序，合并排序，堆排序，快速排序，基数排序，计数排序，桶排序，ShellSort，梳状排序，