Сортировка ведра в Java

Автор оригинала: Sam Millington.

1. Введение

В этой статье мы погрузимся в ведро сортировать алгоритм. Начнем с быстрой немного теории, прежде чем работать над java реализации наряду с унитарным тестированием нашего решения. Наконец, мы посмотрите на время сложности ведро сортировки.

2. Теория сортировки ковша

Сортировка ведра, иногда известная как сортировка ячеей, является специфическим алгоритмом сортировки. Сорт работает путем распределения элементов, которые мы хотим сортировать в несколько индивидуально отсортированы ведра. Делая это, мы можем уменьшить количество сравнений между элементами и помочь сократить время сортировки.

Давайте кратко рассмотрим шаги, необходимые для выполнения сортировки ведра :

1. Настройка массива наших изначально пустых ведер
2. Распределить наши элементы в соответствующие ведра
3. Сортировать каждое ведро
4. Concatenate отсортированы ведра вместе, чтобы воссоздать полный список

3. Реализация Java

Хотя этот алгоритм не специфичен для языка, мы будем внедрять этот сорт на Java. Давайте рассмотрим вышеуказанный список шаг за шагом и напишем код, чтобы сортировать список интеграторов.

3.1. Настройка ковша

Во-первых, необходимо определить алгоритм хэширования решить, какой из наших элементов помещается в какое ведро:

private int hash(int i, int max, int numberOfBuckets) {
    return (int) ((double) i / max * (numberOfBuckets - 1));
}

С помощью нашего метода хэша мы теперь можем укажите количество ячеев в качестве квадратного корня размера списка входов :

final int numberOfBuckets = (int) Math.sqrt(initialList.size());
List> buckets = new ArrayList<>(numberOfBuckets);
for(int i = 0; i < numberOfBuckets; i++) {
    buckets.add(new ArrayList<>());
}

Наконец, нам нужен короткий метод, чтобы определить максимальный интегратор в нашем списке входных данных:

private int findMax(List input) {
    int m = Integer.MIN_VALUE;
    for (int i : input) {
        m = Math.max(i, m);
    }
    return m;
}

3.2. Распространение элементов

Теперь, когда у нас есть наши ведра определены, мы можем распространять каждый элемент нашего списка входных данных в соответствующее ведро с помощью хэш метод :

int max = findMax(initialList);

for (int i : initialList) {
    buckets.get(hash(i, max, numberOfBuckets)).add(i);
}

3.3. Сортировка отдельных ведер

С нашими ведрами определены и полны интеграторов, Давайте использовать Компаратор сортировать их :

Comparator comparator = Comparator.naturalOrder();

for(List bucket  : buckets){
    bucket.sort(comparator);
}

3.4. Конкатенатирование наших ведер

Наконец, мы должны тянуть наши ведра вместе, чтобы воссоздать единый список. Так как наши ведра отсортированы, нам нужно только цикл через каждое ведро один раз и принести элементы в список мастеров:

List sortedArray = new LinkedList<>();

for(List bucket : buckets) {
    sortedArray.addAll(bucket);
} 

return sortedArray;

4. Тестирование нашего кода

После завершения нашей реализации давайте напишем быстрый унитарный тест, чтобы убедиться, что он работает так, как ожидалось:

BucketSorter sorter = new IntegerBucketSorter();

List unsorted = Arrays.asList(80,50,60,30,20,10,70,0,40,500,600,602,200,15);
List expected = Arrays.asList(0,10,15,20,30,40,50,60,70,80,200,500,600,602);

List sorted = sorter.sort(unsorted);

assertEquals(expected, sorted);

5. Сложность времени

Далее давайте кратко рассмотрим сложность времени выполнения сортировки ведра.

5.1. Наихудший сценарий

В нашем худшем случае, мы найдем все наши элементы в одном ведре и в обратном порядке. Когда этот случай происходит, мы уменьшаем наш сорт ведра до простого вида, в котором каждый элемент сравнивается с каждым другим элементом, что дает время сложности O (n2) .

5.2. Средний сценарий дела

В нашем среднем случае, мы находим, что элементы относительно равномерно распределены между нашими ведрами ввода. Так как каждый из наших шагов требует только одной итерации через наши ведра ввода, мы находим, что наше ведро завершает в O(n) время .

6. Заключение

В этой статье мы увидели, как реализовать сортировку ведра в Java. Мы также рассмотрели сложность алгоритма сортировки ведра.

Как всегда, код, показанный в этой статье, доступен более на GitHub .