Void BitSort(unsigned int Left, unsigned int Right,

unsigned int Tab[],unsigned int Bit){

// сортировка таблицы Tab на отрезке Left - Right

// по битам, начиная с бита Bit

int k;

if(Left>=Right) return;

k=BitPart(Left,Right,Tab,Bit);

if((Bit>>1)!=0){

BitSort(Left,k,Tab,Bit>>1);

BitSort(k+1,Right,Tab,Bit>>1);

}

}

//-----------------------------------------------------

Void BinarySort(int n,unsigned Tab[], unsigned int keylen){

// прокладка к BitSort, чтобы не пугать пользователя

// аргументами BitSort

unsigned Bit;

Bit=(1<<(keylen-1));

BitSort(0,n-1,Tab,Bit);

}

Рассмотренная сортировка так же, как и следующая, не основана на сравнении ключей. Приблизительную оценку времени работы можно получить из следующих соображений. Пусть длина ключа М битов. Если таблица содержит все возможные ключи, которые можно составить из М битов, то число ключей или . Таким образом, для сортировки нужно пройти все данные столько раз, сколько битов в ключе и время работы пропорционально .

9.2.4.11. Цифровая поразрядная сортировка

Цифровая поразрядная сортировка рассматривает ключ как последовательность цифр в некоторой системе счисления с основанием P. Подсчитаем, сколько имеется в таблице ключей с младшей цифрой d (d=0…P-1). Для этого потребуется P счетчиков С₀, С₁,… С_P-1 и дополнительная область памяти для вывода в нее записей или указателей на записи. После подсчета ясно, что все ключи с младшей цифрой 0 должны размещаться с позиции 0, ключи с цифрой 1 – с позиции С₀, с цифрой 2 – с позиции С₀+С₁ и так далее. Затем та же самая процедура выполняется для последующих цифр. Рис. 38 поясняет процесс сортировки.

Рис.38 Цифровая поразрядная сортировка

Сравнение ключей не производится. Фактически каждый просмотр состоит из 3-х фаз – подсчет, распределение памяти, перемещение. Две из них можно совместить – накапливать значения счетчиков для k+1 просмотра одновременно с перемещением k-го просмотра. В качестве системы счисления естественно выбрать 16-ричную (байт ключа содержит 2 цифры) или систему счисления с основанием 256 (1 байт ключа – 1 цифра). Поскольку алгоритм допускает рас­па­раллеливание, он весьма эффективен для много­процессорных компьютеров. Ниже приведен текст функции, реализующей метод.

const int NDIGIT=256; // основание системы счисления

//----------------------------------------------

Void DigitalSort(byte *t, int n, int KeyLen){

// цифровая поразрядная сортировка

// (основание системы счисления=256)

// t - сортируемый массив ключей

// N - число ключей в массиве

// KeyLen - число цифр в сортируемом ключе

Int *Count;

int i,j,k;

BYTE Dig;

BYTE *b; // буферная область

Int *Pos; // позиции расстановки

Count=new int[NDIGIT]; // память для счетчиков

Pos=new int[NDIGIT]; // текущие позиции при расстановке

b=new BYTE [N*KeyLen]; // буферная область

for(i=0; i<KeyLen; i++){

for(k=0; k<NDIGIT; k++)Count[k]=0; // обнулим счетчики

// подсчет

for(j=0; j<N; j++){

// Dig - i-я цифра в j-м ключе

Dig=*(t+j*KeyLen+KeyLen-i-1);

Count[Dig]++;

}

// расчет позиций

Pos[0]=0;

for(j=1; j<NDIGIT; j++){

Pos[j]=Pos[j-1]+Count[j-1];

}

// расстановка

for(j=0; j<N; j++){

Dig=*(t+j*KeyLen+KeyLen-i-1);

memcpy(b+KeyLen*Pos[Dig]++, t+j*KeyLen, KeyLen);

}

// копируем то, что получилось в исходную область

// хотя можно было бы перекачивать туда-обратно

memcpy(t,b,KeyLen*N);

}

delete [] b;

delete [] Count;

delete [] Pos;

}