Самый эффективный алгоритм сортировки для многих идентичных ключей?

Волшебное слово, которое Вы ищете здесь, является мультимножеством (или сумка). Это не действительно вид вообще, так как Вы не заботитесь о порядке, пока у Вас есть все элементы с равными группировавшимися ключами. Существует несколько консервированных реализаций, доступных, в зависимости от языка, который Вы используете, но в целом хешированная версия выше асимптотически оптимальна, я верю: insert() постоянное время, так как можно вычислить хеш в O (1) и добавить столкновение, вставляет в список в O (1) время; можно получить один элемент от мусорных ведер в O (1) время, Вы просто захватываете первый в мусорном ведре; и можно поэтому собрать всех их в O (n) время, так как Вы получаете n элементы с O (1) для каждого элемента.

QuickSort с 3 путями работает очень хорошо, когда существует большое количество дубликатов.

Быстрая сортировка с объединением, такая как встроенный вид Python (c.f. timsort), имеет хорошую ожидаемую производительность, когда будут большие выполнения уже отсортированных данных (как, в Вашем примере, одинаковых объектах) - Вы пропустите O (журнал (N)) работа на слияние. Можно также распределить сортировку с объединением через несколько ЦП и диски, если набор данных является чрезвычайно большим (это называют "внешним" видом). Однако это будет худший случай O (Nlog (N)).

Единственные виды, которые быстрее, чем Nlog (N), считают виды, то использование некоторая общая собственность ключей. Для использования линейного вида времени (хеш-таблица или основание/блочная сортировка) необходимо будет хешировать структуру для генерации некоторого числового ключа.

Вид основания сделает, несколько проходят через ключи, таким образом, его ожидаемое время будет дольше, чем подход хеш-таблицы; и, так как Вы не заботитесь о лексикографическом порядке, решение для хеш-таблицы звучит лучше для Вас, если можно позволить себе хешировать ключи.

Я думаю, что хеширование в блоки было бы лучшим решением, предположив, что существует хеш, который сохраняет оператор = отображающийся (0.0, не мог бы хешировать к тому же самому-0.0, но они могли быть "равными"). Принятие Вас только имеет равное, и меньше оператор, Вы могли реализовать элементарный алгоритм быстрой сортировки выбора первого элемента как центр, и помещение меньше, чем в одной группе, и больше, чем в другой группе и затем повторении процесса на каждой группе.

Если Вы знаете диапазон возможных значений, и это является маленьким, Вы могли сделать: (код псевдовыхода)

uint[] bucket = new int[10];
foreach(uint val in foo) {
    ++bucket[val];
}

uint bar_i = 0;
uint[] bar = new int[foo.length];
foreach(int val = 0; val < 10; val++) {
    uint occurrences = bucket[val];
    for(int i=0; i < occurrences; i++) {
        bar[bar_i++] = val;
    }
}

Я думаю, что, так как у Вас есть произвольные объекты, которые Вы не хотите копировать вокруг слишком много, Вы могли просто использовать ссылки или указатели для вида, и, в случае необходимости, скопировать объекты в порядке впоследствии.

Простой алгоритм с порядком производительности O (n (n-1) / 2) следующие:

1. Примите входной массив, названный как Вход, имеющий размер как n.
2. Выделите память для возвращаемого массива с тем же размером, названным как Результат
3. Выделите память для булева массива с тем же размером, названным как Посещаемая, и установите весь Visted как ложь
4. Предположите, что существует Равная функция, названная, как Равняется, возвращают true, если оба объекта еще равны ложь.
5. Предположите, что индекс массива запускается от 1 до n
6. См. Псевдо код C ниже:

function groupIdentical(Input) 
{
    k=1;
    for i=1 to n 
    {
        Visited[i]=false ;
    }

    for i=1 to n
    {
        if( !Visited(i) )
        {   
            Result[k++]=Input[i];
            for j= (i+1) to n
            {
                if( Equals(i,j) )
                {
                    Result[k++]=Input[j];
                    Visited[j]=true;
                }   
            }
        }
    }
    return Result;
}

Возможно, R+B или дерево AVL? С другой стороны - это все еще было бы в конечном счете O (NlogN). Мог бы также использовать пирамидальную сортировку - не будет немного хуже и никакое использование дополнительной памяти...