Сортировка матрицы диагональным зигзагом

#include <cstdio>
#include <cstring>
#include <ctime>
#include <cassert>
 
#define RAND_RANGE(a, b) (rand() % ((b) - (a) + 1) + (a))
#define RANDOM (1.0 * rand() / RAND_MAX) 
#define UNASSIGNED -100500.0
 
 
double** new_matrix(unsigned rows, unsigned cols)
{
  double** x = new double*[rows];
  for (int row = 0; row != rows; row++)
  {
    x[row] = new double[cols];
    for (int col = 0; col != cols; col++)
      x[row][col] = 5 - 10 * RANDOM; //rand() % 100;  
  }
  return x;
}
 
void free_matrix(double** src, unsigned rows)
{
  for (int row = 0; row != rows; row++) delete []src[row];
  delete []src;
}
 
void print_matrix(double** src, unsigned rows, unsigned cols, const char* header)
{
  printf("\n%s [%d x %d]\n", header, rows, cols);
  for (int row = 0; row != rows; row++)
  {
    for (int col = 0; col != cols; col++) printf(" %+6.4lf", src[row][col]);
    printf("\n");  
  }
}
 
bool next(double** x, unsigned rows, unsigned cols, int &row, int &col)
{
  #define bounds(z, max) (0 <= (z) && (z) < (max)) // 0 ≤ z < max
  //#define possible(r, c) (bounds(r, rows) && bounds(c, cols) && !x[r][c])
  #define possible(r, c) (bounds(r, rows) && bounds(c, cols) && x[r][c] < UNASSIGNED)
  
  if (!col)
  {
    if (possible(row - 1, col + 1)) { row--, col++; return true; }    
    if (possible(row + 1, col)) { row++; return true; }    
    if (possible(row, col + 1)) { col++; return true; }    
    return false;                     
  }                                                        
 
  if (!row)
  {
    if (possible(row + 1, col - 1)) { row++, col--; return true; }    
    if (possible(row, col + 1)) { col++; return true; }   
    if (possible(row + 1, col)) { row++; return true; }   
    return false;  
  }
 
  if (1 + col == cols)
  {
    if (possible(row + 1, col - 1)) { row++, col--; return true; }    
    if (possible(row, col + 1)) { col++; return true; }   
    if (possible(row + 1, col)) { row++; return true; }   
    return false;  
  }
 
  if (1 + row == rows)
  {
    if (possible(row - 1, col + 1)) { row--, col++; return true; }    
    if (possible(row + 1, col)) { row++; return true; }    
    if (possible(row, col + 1)) { col++; return true; }    
    return false;  
  }
 
  if (possible(row - 1, col + 1)) { row--, col++; return true; }    
  if (possible(row + 1, col - 1)) { row++, col--; return true; }    
 
  assert(false);  
  return false;  
}
 
// Быстрая сортировка одномерного массива. Спёр отсюдова: 
// https://www.cyberforum.ru/cpp-beginners/thread186552.html#post1085608
template<class T>
void quickSortR(T* a, long N) 
{
  long i = 0, j = N;             
  T temp, p;
  p = a[ N>>1 ];                 
 
  do 
  {
    while (a[i] < p) i++;
    while (a[j] > p) j--;
 
    if (i <= j) 
    {
      temp = a[i]; a[i] = a[j]; a[j] = temp;
      i++; j--;
    }
  } while ( i<=j );
 
  if (j > 0) quickSortR(a, j);
  if (N > i) quickSortR(a + i, N - i);
}
 
// сортировка "змейкой"
void sort_matrix(double** x, unsigned rows, unsigned cols)
{
  double* temp = new double[rows * cols], *ptr = temp;
  
  for (int r = 0; r != rows; r++)
    for (int c = 0; c != cols; c++)
      *ptr++ = x[r][c], x[r][c] = UNASSIGNED - 1.0; // 0.0
      
  quickSortR(temp, rows * cols);    
 
  ptr = temp;
  int row = 0, col = 0; 
  do x[row][col] = *ptr++;
  while (next(x, rows, cols, row, col));
  
  delete[] temp;
}
 
#define ROWS  14
#define COLS  11
 
int main(void)
{
  srand(time(0));
  double** x = new_matrix(ROWS, COLS);
  print_matrix(x, ROWS, COLS, " >> source matrix: ");
  //fill_matrix(x, ROWS, COLS);
  sort_matrix(x, ROWS, COLS);
  print_matrix(x, ROWS, COLS, " >> sorted matrix: ");
  free_matrix(x, ROWS);
  printf("\n ...Press any key to exit...");
  getchar();
  return 0;
}