Всем доброе время суток!

Заранее извиняюсь, если чтото не так пишу,т.к. я в программирование ничего не понимаю.   
А надо сделать лабораторную работу,очень надо... Вот наткнулась в поисковеке на фаш форум. Может ктонить здесь мне поможет...   

Вот что надо сделать:

1.Описать работу алгоритма сортировки. Проверить правильность работы алгоритма сортировки распечаткой ключей отсортированного массива. 
2.  Проверить правильность работы алгоритма сортировки программно.
3.  Проверить устойчивость алгоритма сортировки многократной сортировкой массивов с 
     различным расположением дублированных (т.е. одинаковых) ключей и распечаткой 
    отсортированного массива (функция prn_struct, файл funcsort.h).
4. Проверить устойчивость работы алгоритма сортировки программно.

Алгоритм сортировки: Поразрядная распределяющая сортировка для целочисленных ключей, начиная с младших цифр ключей 
Имя сортирующей  функции: RadixLSDsort
Функия:
Файл LSD.H
// вспомогательные функции для поразрядной (по младшей цифре)распределяющей сортировки
//возвращает число цифр в максимальном по модулю числе массива целых
// чисел
template <class T>
int far MaxDigitCountU (T*a,unsigned radix,long lft,long rgt)
 { Key max =absolute( a[lft]);
  for(long j=lft+1;j<=rgt;j++)
        {Key work = absolute(a[j]);
         if (max < work) max = work;
        }
  int cd =log(max)/log(radix);
  return cd+1;
 }
//возвращает число , равное radix - ичной цифре положительного
//числа |val|  №num_dig cправа
template <class T>
int far get_digitU(T val,        //анализируемое целое  число (любого типа)
              unsigned radix,  //основание системы счисления
              int num_dig     //номер цифры справа (1-ая -№1)
             )
    {int sgn =1;
     if (val<0) {val =-val;sgn=-1;}
     Key t;
     for(int j =1;j<=num_dig;j++)
        { t=val % radix;  //получить последнюю  radix- ичную цифру числа val
          val =val/radix; //отбросить последнюю  radix- ичную цифру числа val
        }

     return t*sgn;
    }


//распределяющая поразрядная сортировка для целочисленных ключей по
// nd - той цифре ключа
//DistribSortBaseU по возрастанию и убыванию
template <class T>
void far DistribSortBaseU (T a[], //обрабатываемый массив
     T b[],                     //вспомогательный массив
     int * counter,          //счетчик числа ключей (ключ = 0,-1,1,-2,2 ... 9)
     unsigned radix,          //основание системы счисления
     int nd,                 //номер цифры в a[index], считая справа
     long lft,               //левая граница массива a[]
     long rgt,                //правая граница массива a[]
     int down  )            //по возрастанию или убыванию
{  //обнулить  массив счетчиков
 long j =0;
 for (; j <= 2*radix; j++) counter[j] = 0;
 //подсчитать, сколько раз встречался ключ   путем
 //суммирования элемента массива counter, индекс которого
 //полностью определен значением разряда ключа.
 //сдвиг индекса на 1 для того, чтобы counter[0]==0
 long i=lft;
 if(!down)
     {for (; i <=rgt ; i++) counter[radix + get_digitU(a[i],radix,nd) +1]++;
      //определение накопленных значений счетчиков с целью найти
      //местo элементов с данным значением ключа в отсортированном массиве
      for (j = 1; j < 2*radix; j++) counter[j] += counter[j-1];
      //создание вспомогательного отсортированного массива b
      //оператор ++ увеличивает counter для того, чтобы дублированный
      //ключ поместился на новое место массива b[]
      for (i = lft; i <= rgt ; i++)
                  b[lft+counter [radix + get_digitU(a[i],radix,nd)]++] = a[i];
     }
  else
     { for (; i <=rgt ; i++) counter[radix + get_digitU(a[i],radix,nd)-1]++;
       //определение накопленных значений счетчиков с целью найти
       //местo элементов с данным значением ключа в отсортированном массиве
       //накопление в обратном порядке для реализации сортировки по убыванию
       for (j = 2*radix-1; j >0; j--) counter[j-1] += counter[j];
       //создание вспомогательного отсортированного массива b
       //оператор ++ увеличивает counter для того, чтобы дублированный
       //ключ поместился на новое место массива b[]
       for (i = lft; i <= rgt ; i++)
             b[counter [radix+get_digitU(a[i],radix,nd)]++] = a[i];
      }
 //копирование  b в a
 for (i = lft; i <=rgt; i++) a[i]= b[i];
}
//распределяющая поразрядная сортировка для целочисленных ключей
template <class T>
void far radixLSDsort(T*a,T*b,unsigned radix ,long lft,long rgt,int down =0)
    {int *cr = new [2*radix]; //массив для счетчика ключей
     //максимальное число radix - ичных цифр в элементе массива а
     int cd= MaxDigitCountU (a,radix,lft,rgt);
     //вызовы сортирующей функции с ключем - j-той цифрой элемента массива а
     for (int j=1;j<=cd;j++)
               {DistribSortBaseU ( a, b,cr,radix,j, lft,rgt,down);
//     prn(a,rgt+1)            //для лекции
               ;}
     delete [] cr;
    }
#endif

Целая эпопея  , напиши в центр помощи.