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

#include <iostream>
#include <iomanip>
#include <random>
#include <functional>
#include <vector>
#include <algorithm>
#include <iterator>
 
template <typename T> using matrix_t = std::vector<std::vector<T>>;
 
template <typename T>
auto create_matrix(std::size_t row_count, std::size_t col_count)
{
    matrix_t<T> matrix(row_count);
    for (auto& row : matrix) row.resize(col_count);
    return matrix;
}
 
template <typename T, class RandomGenerator>
void fill_matrix(matrix_t<T>& matrix, RandomGenerator&& gen)
{
    for (auto& row : matrix) std::generate(row.begin(), row.end(), gen);
}
 
template <typename T>
void print_matrix(std::ostream& os, const matrix_t<T>& matrix)
{
    int width = matrix[0].size() > 10 ? 4 : 6;
    for (auto& row : matrix)
    {
        for (auto& elem : row) os << std::setw(width) << elem;
        os << std::endl;
    }
}
 
template <typename T>
void transpose_matrix(matrix_t<T>& matrix)
{
    auto transposed_matrix = create_matrix<T>(matrix[0].size(), matrix.size());
    std::size_t i = 0, j = 0;
    for (auto& row : matrix)
    {
        i = 0;
        for (auto& elem : row)
        {
            transposed_matrix[i][j] = elem;
            ++i;
        }
        ++j;
    }
    matrix = std::move(transposed_matrix);
}
 
template <typename T>
void rearrange_matrix(matrix_t<T>& matrix)
{
    transpose_matrix(matrix);
    auto row_comparator = [] (const auto& row1, const auto& row2) { return row1[0] < row2[0]; };
    std::stable_sort(matrix.begin(), matrix.end(), row_comparator);
    transpose_matrix(matrix);
}
 
int main()
{
    std::size_t row_count, col_count;
    do
    {
        std::cout << "Число строк матрицы: ";
        std::cin >> row_count;
        std::cout << "Число столбцов матрицы: ";
        std::cin >> col_count;
    }
    while (row_count < 1 || col_count < 1);
 
    auto matrix = create_matrix<int>(row_count, col_count);
 
    std::random_device rd{};
    std::mt19937 gen(rd());
    std::normal_distribution<> dis{100, 25};
    fill_matrix(matrix, [&dis, &gen] () { return dis(gen); });
 
    std::cout << "Исходная матрица: " << std::endl;
    print_matrix(std::cout, matrix);
 
    rearrange_matrix(matrix);
 
    std::cout << "Отсортированная матрица: " << std::endl;
    print_matrix(std::cout, matrix);
 
    return 0;
}

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
 
int main()
{
    srand((int)time(0));
    int M, N;
    cout << "M="; cin >> M;
    cout << "N="; cin >> N;
    
        int **a = new int*[M];
      for (int i = 0; i < M; i++)
          a[i]=new int[N];        
      
    cout << "Matrix a:\n";  
    for (int i = 0; i < M; i++)
    {
        for (int j = 0; j < N; j++)
        {
            a[i][j]=rand()%9 + 1;        
            cout << a[i][j] << " ";    
        }               
        cout <<"\n";
    }           
    
    for (int j = 1; j < N; j++)    
        for (int k = 0; k < N-j; k++)        
            if (a[0][k]>a[0][k+1])             
                for (int i = 0; i < M; i++)
                swap(a[i][k],a[i][k+1]);             
            
    cout << "Sorted matrix a:\n";        
    for (int i = 0; i < M; i++)
    {
        for (int j = 0; j < N; j++)        
            cout << a[i][j] << " ";        
        cout << "\n";
    }    
    
    for (int i = 0; i < M; i++)
    delete[]a[i];
    delete[]a;    
system("pause");
return 0;
}