Упорядочить строки матрицы по убыванию наибольших элементов

#include <iostream>
#include <random>
#include <iomanip>
 
void printMatrix(double **matrix, std::size_t height, std::size_t width) {
    for (std::size_t i = 0; i < height; ++i) {
        for (std::size_t j = 0; j < width; ++j) {
            std::cout << std::fixed << std::setprecision(2) << std::setw(6) << matrix[i][j];
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
}
 
template<typename Generator>
void fillMatrix(double **matrix, std::size_t height, std::size_t width, Generator generator) {
    for (std::size_t i = 0; i < height; ++i) {
        for (std::size_t j = 0; j < width; ++j) {
            matrix[i][j] = generator();
        }
    }
}
 
double max(double *begin, double *end) {
    double result = *begin++;
    for (; begin != end; ++begin) {
        if (*begin > result) {
            result = *begin;
        }
    }
    return result;
}
 
template<typename T>
void swap(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}
 
void trickySort(double **matrix, std::size_t height, std::size_t width) {
    double *maxes = new double[height];
    for (std::size_t i = 0; i < height; ++i) {
        maxes[i] = max(matrix[i], matrix[i] + width);
    }
    for (std::size_t i = 0; i < height - 1; ++i) {
        for (std::size_t j = i + 1; j < height; ++j) {
            if (maxes[i] < maxes[j]) {
                swap(matrix[i], matrix[j]);
                swap(maxes[i], maxes[j]);
            }
        }
    }
    delete[] maxes;
}
 
double **newMatrix(std::size_t height, std::size_t width) {
    double **matrix = new double *[height];
    for (std::size_t i = 0; i < height; ++i) {
        matrix[i] = new double[width];
    }
    return matrix;
}
 
void deleteMatrix(double **matrix, std::size_t height) {
    for (std::size_t i = 0; i < height; ++i) {
        delete[] matrix[i];
    }
    delete[] matrix;
}
 
int main() {
    std::random_device randomDevice;
    std::mt19937 randomGenerator(randomDevice());
    std::uniform_int_distribution<unsigned int> matrixSizeDistribution(3, 5);
    std::uniform_real_distribution<double> matrixElementsDistribution(-3, 3);
 
    std::size_t height = matrixSizeDistribution(randomGenerator);
    std::size_t width = matrixSizeDistribution(randomGenerator);
 
    double **matrix = newMatrix(height, width);
 
    fillMatrix(matrix, height, width, [&]() { return matrixElementsDistribution(randomGenerator); });
    printMatrix(matrix, height, width);
 
    trickySort(matrix, height, width);
    printMatrix(matrix, height, width);
 
    deleteMatrix(matrix, height);
    return 0;
}