Подкорректировать код (сортировка распределением)

 while (j > (l[k] - 1))

 //FlashSort, применив которую получим
    //почти упорядоченный массив
 void FlashSort(int *a , int size)  {
    
        //int n = a.length; //Размерность массива
        int m = size * 0.42; //Количество классов
        int  *l  = new int[m]; //Вспомогательный массив
        
        int i = 0, j = 0, k = 0; //Счётчики в циклах
        for (i = 0; i< size; i++)
        l[i]= 0;
        int anmin = a[0]; //Минимальный элемент
        int nmax = 0; //Индекс максимального элемента
        cout<<" 1 \n";
        //Ищем минимальный и максимальный элементы
        for (i = 1; i < size; i++) {
            if (a[i] < anmin)
                anmin = a[i];
            if (a[i] > a[nmax])
                nmax = i;
        }
        
        //Минимум = максимум? Тогда массив
        //состоит из одинаковых элементов.
        //А значит, он отсортирован!
        if (anmin == a[nmax])
            return;
        cout<<" 2 \n";
        //Неизменяемая часть квантиля
        double c1 = ( m - 1) / (a[nmax] - anmin);
        cout<<" 3 \n";
        //Заполняем массив распределения
        //Каждый элемент вспомогательного массива -
        //это количество чисел соответствующего класса
        for (i = 0; i < size; i++) {
            k = (c1 * (a[i] - anmin));
            l[k]++;
        }
        cout<<" 4 \n";
        //Во вспомогательном массиве каждый элемент
        //(начиная со 2-го)увеличим на величину предыдущего.
        //После этого каждый элемент вспомогательного массива
        //это индекс элемента в основном массиве на котором 
        //должны заканчиваются числа соответсвующего класса
        for (k = 1; k < m; k++){
            l[k] += l[k - 1];
            cout<<"l[k] = "<< l[k];
        }
        cout<<" 5 \n";
        //Меняем местами первый и максимальный элемент в массиве
        //Это делается для того чтобы в основном цикле алгоритма
        //максимальный элемент сразу поставить на своё место
        int hold = a[nmax];
        a[nmax] = a[0];
        a[0] = hold;
    
        //Основной алгоритм
        cout<<" 6 \n";
        //Количество элементов, перемещённых
        // в их правильные классы
        int nmove = 0; 
        
        //Временный контейнер, в которую будем помещать элементы
        //на чьи места только что вставили "правильные" элементы
        int flash;
        
        //Индекс неупорядоченного элемента 
        //начинающего новый класс, элементы которого ещё
        //не перемещены
        j = 0;
        
        //Класс очередного перемещаемого элемента
        //это число всегда в пределах от 1..m-1
        k = m - 1;      
     
        int o = 0;
        while (nmove < size - 1) 
        {       
            cout<<" j = "<< j << "(l[k]-1) ="<< (l[k]-1)<<endl;
            while (j > (l[k] - 1)) 
                {
                j++;
                cout<< "c1 = "<<c1<<endl;
                k = (c1 * (a[j] - anmin));
             
            }
            flash = a[j];
            cout<< " j = "<< j << "  l[k] ="<< l[k]<<endl;
            while (!(j == l[k])) {
                
            //  cout<<o++<<endl;
                hold = a[l[k] - 1];
                a[l[k] - 1] = flash;
                flash = hold;
                
                l[k]--;
                nmove++;
               
            }           
        }
         
  //     for (i = 0; i < size; i ++)
   //     cout<<a[i]<<" ";
    }
 
    //Финальная сортировка простыми вставками
    //Досортировывает то что не отсортировало FlashSort
void InsertionSort(int *a, int size)  
    {
        int i, j, hold;
        for (i=size-3; i>=0; i--) { 
            if (a[i+1] < a[i]) {
                hold = a[i];
                j=i;
                while (a[j+1] < hold) {
                    a[j] = a[j+1];
                    j++;
                }
                a[j] = hold;            
            }
        }
    }

 void sort(int *a , int size)  {
        FlashSort(a,size);
        InsertionSort(a,size);
 }

InsertionSort(int *a, int size)

FlashSort(int *a , int size)

...
          //А значит, он отсортирован!
          if (anmin == a[nmax])
              return;
          cout<<" 2 \n";
          //Неизменяемая часть квантиля
// !!!!!!!!!!!!!!!!!!!!! строка 30 из первого сообщения !!!!!!!!!
         double c1 = ( (double) m - 1) / (a[nmax] - anmin); // вместо double c1 = ( m - 1) / (a[nmax] - anmin);
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
          cout<<" 3 \n";
          //Заполняем массив распределения
          //Каждый элемент вспомогательного массива -
          //это количество чисел соответствующего класса
          for (i = 0; i < size; i++) {
...
              flash = a[j];
              cout<< " j = "<< j << "  l[k] ="<< l[k]<<endl;
              while (!(j == l[k])) {
                  
              //  cout<<o++<<endl;
// !!!!!!!!!!!!!!!!!!!!! строка 90 из первого сообщения !!!!!!!!!
                k = (int) (c1 * (flash - anmin));           // Из java-кода
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                  hold = a[l[k] - 1];
                  a[l[k] - 1] = flash;
                  flash = hold;
                  
                  l[k]--;