int* p=new [256];
for(int i=0; i<max; i++)
{
*p[mass[i]]++;// mass --> массив неотсортированых чисел
}
Всем удачи.
С уважением, Княжев Евгений.

Здравствуйте, Ewgeney, Вы писали:

E>int* p=new [256];
E>for(int i=0; i<max; i++)
E>{
E> *p[mass[i]]++;// mass --> массив неотсортированых чисел
E>}
А можно подробнее как это работает на примере

 int mass[] = {7, 1, 5};
 int max = 3;

Здравствуйте, Ewgeney, Вы писали:

E>int* p=new [256];
E>for(int i=0; i<max; i++)
E>{
E>*p[mass[i]]++;// mass --> массив неотсортированых чисел

Во-первых это не будет компилироваться

a)
int* p=new [256];

нет такого синтаксиса

b)

*p[mass[i]]++;

либо звездочку убери, либо скобки


Во-вторых, не мешало бы массив p занулить. Как-то не очень хорошо делать ++ для мусора.
Во-третьих, это алгоритм подсчета, сколько раз данное число встречается в mass (после исправления). При чем здесь сортировка — не понимаю.
В четветрых, прежде чем постить доморощенные алгоритмы, их стоит проверять на машине.

With best regards
Pavel Dvorkin

Здравствуйте, Pavel Dvorkin, Вы писали:

PD>Во-третьих, это алгоритм подсчета, сколько раз данное число встречается в mass (после исправления). При чем здесь сортировка — не понимаю.
Ну эта... короче это глюкавая часть банального алгоритма сортировки подсчетом.
Если доделать его до конца то будет примерно так(не компилировал)

void counter_sort(unsigned char* arr, int count)
{
    int counters[256];
    for(int i=0; i<256; ++i)
        counters[i] = 0;
    for(int i=0; i<count; ++i)
        ++counters[arr[i]];
    for(int i=0, j=0; i<count; ++i)
    {
        while(counters[j] == 0)
        {
            ++j;
            if(j == 256)
                return;
        }
        arr[i] = j;
        --counters[j];
    }
}

Ну както так...
Есть вариации этого алгоритма для других тапов данных. Искать по словам radix sort
google : Результаты 1 — 10 из примерно 279 000 для radix sort.

WH>

WH>void counter_sort(unsigned char* arr, int count)
WH>{
WH>    int counters[256];
WH>    for(int i=0; i<256; ++i)
WH>        counters[i] = 0;
WH>    for(int i=0; i<count; ++i)
WH>        ++counters[arr[i]];
WH>    for(int i=0, j=0; i<count; ++i)
WH>    {
WH>        while(counters[j] == 0)
WH>        {
WH>            ++j;
WH>            if(j == 256)
WH>                return;
WH>        }
WH>        arr[i] = j;
WH>        --counters[j];
WH>    }
WH>}
WH>

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

Здравствуйте, Ewgeney, Вы писали:

E>мне было лень расписывать все подробно, но нашелся человек который расписал
1)Не ленись
2)Выучи язык
3)Не стоит думать что профессиональных программистов можно удивить алгоритмом который дают в школе на информатике
E>самое главное что от этого алгоритма можно перейти к алгоритмам сортировки чисел больше чем 255 и строк.
Ну так просто к ним не перейти... Radix sort сортирует не значения, а индексы что требует O(N) памяти, а это довольно много. Плюс для него нужно корректировать таблици счетчиков для знаковых чисел и чисел с плавающей точкой... Плюс по полученым индексам надо собрать новый массив...
Короче не все так просто и на практике очень часто рулит банальный QSort, а если его еще и проапгрейдить до IntroSort который для коротких промежутков использует InsertionSort то...
Хотя если не жалко память то можно и к RadixSort присмотрется... но как правило оно того не стоит.

Здравствуйте, WolfHound, Вы писали:

void counter_sort(unsigned char* arr, int count)
{
    int counters[256];
    for(int i=0; i<256; ++i)
        counters[i] = 0;
    for(int i=0; i<count; ++i)
        ++counters[arr[i]];
    
    for(int i=0, k=0; i<256; ++i)
    {
        for(int j=0; j<counters[i]; ++j)
        {
            arr[k++] = i;
        }
    }
    
}

WH>Ну както так...

По-моему так логичнее?