Нажатие сортировки Radix (и python) до ее пределов

я был очень разочарован многими реализациями python radix сортировать там в интернете.

они последовательно используют радиус 10 и получают цифры чисел, которые они перебирают, деля на степень 10 или принимая log10 числа. Это невероятно неэффективно, так как log10 не является особенно быстрой операцией по сравнению с Бит-сдвигом, который почти в 100 раз быстрее!

гораздо более эффективная реализация использует radix 256 и сортирует число байт за байтом. Это позволяет выполнять все "получение байтов" с помощью смехотворно быстрых битовых операторов. К сожалению, кажется, что абсолютно никто не реализовал сортировку radix в python, которая использует битовые операторы вместо логарифмов.

Итак, я взял дело в свои руки и придумал этого зверя, который работает примерно с половиной скорости сортировки на небольших массивах и работает почти так же быстро на больших (например,len вокруг 10,000,000):

import itertools

def radix_sort(unsorted):
    "Fast implementation of radix sort for any size num."
    maximum, minimum = max(unsorted), min(unsorted)

    max_bits = maximum.bit_length()
    highest_byte = max_bits // 8 if max_bits % 8 == 0 else (max_bits // 8) + 1

    min_bits = minimum.bit_length()
    lowest_byte = min_bits // 8 if min_bits % 8 == 0 else (min_bits // 8) + 1

    sorted_list = unsorted
    for offset in xrange(lowest_byte, highest_byte):
        sorted_list = radix_sort_offset(sorted_list, offset)

    return sorted_list

def radix_sort_offset(unsorted, offset):
    "Helper function for radix sort, sorts each offset."
    byte_check = (0xFF << offset*8)

    buckets = [[] for _ in xrange(256)]

    for num in unsorted:
        byte_at_offset = (num & byte_check) >> offset*8
        buckets[byte_at_offset].append(num)

    return list(itertools.chain.from_iterable(buckets))

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

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

под управлением cProfile на это говорит мне, что много времени тратится на append метод для списков, что заставляет меня думать, что этот блок:

    for num in unsorted:
        byte_at_offset = (num & byte_check) >> offset*8
        buckets[byte_at_offset].append(num)

на radix_sort_offset ест много времени. Это также блок, который, если вы действительно посмотрите на него, делает 90% работы для всего сорта. Этот код выглядит так, как будто это может быть numpy - ized, что, я думаю, приведет к довольно повышение производительности. К сожалению, я не очень хорошо с numpyболее сложные функции, поэтому не смогли понять это. Помощь будет очень признательна.

в настоящее время я использую itertools.chain.from_iterable разогнуть buckets, но если у кого-то есть более быстрое предложение, я уверен, что это также поможет.

первоначально у меня был get_byte функция, которая вернула nTh байт числа, но встраивание кода дало мне огромное ускорение скорости, поэтому я сделал это.

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