Упорядочить элементы матрицы по возрастанию в форме спирали

#include <algorithm>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <utility>
 
template <typename T>
using Row = std::vector<T>;
 
template <typename T>
using Matrix = std::vector<Row<T>>;
 
template <typename T>
class SpirallAccess {
    Matrix<T> &m_matrix;
    std::vector<std::pair<size_t, size_t>> m_pos_list;
 
public:
    SpirallAccess(Matrix<T> &matrix):
        m_matrix(matrix)
    {
        size_t top = 0;
        size_t left = 0;
        size_t bottom = matrix.size();
        size_t right = matrix[0].size();
 
        size_t i = 0;
        size_t j = 0;
 
        while ((left < right) && (top < bottom)) {
            while (i + 1 < bottom) {
                m_pos_list.push_back({i, j});
                ++i;
            }
 
            if (++left == right) break;
 
            while (j + 1 < right) {
                m_pos_list.push_back({i, j});
                ++j;
            }
 
            if (--bottom == top) break;
 
            while (i > top) {
                m_pos_list.push_back({i, j});
                --i;
            }
 
            if (--right == left) break;
 
            while (j > left) {
                m_pos_list.push_back({i, j});
                --j;
            }
 
            if (++top == bottom) break;
        }
 
        m_pos_list.push_back({i, j});
    }
 
    T &operator[](size_t n) {
        return m_matrix[m_pos_list[n].first][m_pos_list[n].second];
    }
 
    size_t size() const {
        return m_pos_list.size();
    }
};
 
template <typename T>
std::string matrixToString(const Matrix<T> &matrix, unsigned field_width = 6) {
    std::stringstream ss;
    for (auto &row : matrix) {
        for (auto &x : row) {
            ss.width(field_width);
            ss << x;
        }
 
        ss << std::endl;
    }
 
    return ss.str();
}
 
template <typename ArrayType>
void bubbleSort(ArrayType &arr) {
    for (size_t i = 0; i < arr.size(); ++i) {
        for (size_t j = 0; j < arr.size() - i - 1; ++j) {
            if (arr[j] > arr[j + 1]) {
                std::swap(arr[j], arr[j + 1]);
            }
        }
    }
}
 
using namespace std;
 
int main() {
    size_t m, n;
    cin >> m >> n;
 
    int counter = 1;
    auto matrix = Matrix<int>(m, Row<int>(n));
    for (auto &row : matrix) {
        for (auto &x : row) {
            x = counter++;
        }
    }
 
    auto spiral_access = SpirallAccess<int>(matrix);
 
    cout << matrixToString(matrix) << endl;
    bubbleSort(spiral_access);
    cout << matrixToString(matrix) << endl;
 
    return 0;
}