Определить все седловые точки

#include <iostream>
#include <cstdlib>
#include <ctime>
 
struct Point
{
    int x;
    int y;
};
 
struct SaddlePoints
{
    unsigned size; // текущее количество седловых точек
    unsigned capacity; // возможное количество седловых точек
    Point *points; // седловые точеки [строка,столбец]
};
 
/* Создает набор седловых точек
    1-й парметр: возможное количество
    Возвращает структуру расположенную в куче
*/
SaddlePoints* initSaddlePoints(const unsigned);
 
/* Освобождение памяти из под набора седловых точек
    1-й параметр: инициализированный набор седловых точек
*/
void freeSaddlePoints(SaddlePoints *(&));
 
/* Создает 2D массив
    1-й параметр: количество строк
    2-й параметр: количество столбцов
*/
int** initMatrix(const unsigned&, const unsigned&);
 
/* Освободить память из под 2D массива
    1-й параметр: инициализированный 2D массив
*/
void freeMatrix(int **(&), unsigned);
 
/* Заполнить 2D массив случайными числами
    1-й параметр: 2D массив
    2-й параметр: количество строк
    3-й параметр: количество столбцов
    4-й параметр: нижняя граница для случайного числа
    5-й параметр: верхняя граница для случайного числа
*/
void fillRandMatrix(int**, const unsigned&, const unsigned&, const int&, const int&);
 
/* Вывести 2D массив
    1-й параметр: 2D массив
    2-й параметр: количество строк
    3-й параметр: количество столбцов
*/
void printMatrix(int ** const, const unsigned&, const unsigned&);
 
/* Поиск седловых точек в 2D массиве
    1-й параметр: 2D массив
    2-й параметр: количество строк
    3-й параметр: количество столбцов
    Возвращает набор седловых точек
*/
SaddlePoints* saddlePointsMatrix(int ** const, const unsigned &, const unsigned &);
 
int main()
{
    std::srand(std::time(0));
 
    const int LowBound = 0, HighBound = 3; // [нижняя, верхняя] границы случайных чисел
    const int Rows = 3, Cols= 2; // количество строк и столбцов
 
    int **matrix = initMatrix(Rows, Cols);
    fillRandMatrix(matrix, Rows, Cols, LowBound, HighBound);
 
    /* -----> тут можешь задать свою последовательность <------ */
 
    printMatrix(matrix, Rows, Cols);
    SaddlePoints *res = saddlePointsMatrix(matrix, Rows, Cols);
    
    std::cout << "Saddle Points: ";
    if (res->size)
    {
        for (unsigned i = 0; i < res->size; ++i)
        {
            std::cout << '[' << (res->points[i].x) << ',' << (res->points[i].y) << ']';
            if ((i + 1) ^ res->size)
            {
                std::cout << ' ';
            }
        }
        std::cout << std::endl;
    }
    else
    {
        std::cout << "<empty>" << std::endl;
    }
    
    freeSaddlePoints(res);
    freeMatrix(matrix, Rows);
}
 
SaddlePoints* initSaddlePoints(const unsigned capacity)
{
    SaddlePoints* data = new SaddlePoints;
    data->size = 0;
    data->capacity = 0;
    data->points = new Point[capacity];
    return data;
}
 
void freeSaddlePoints(SaddlePoints *(&data))
{
    delete[] data->points; 
    delete data;
}
 
int** initMatrix(const unsigned &rows, const unsigned &cols)
{
    int **matrix = new int*[rows];
    for (unsigned i = 0; i < rows; ++i)
    {
        matrix[i] = new int[cols]{};
    }
    return matrix;
}
 
void freeMatrix(int **(&matrix), unsigned rows)
{
    for (unsigned i = 0; i < rows; ++i)
    {
        delete[] matrix[i];
    }
    delete[] matrix;
}
 
void fillRandMatrix(int **matrix, const unsigned &rows, const unsigned &cols, const int &lowBound, const int &highBound)
{
    for (unsigned i = 0; i < rows; ++i)
    {
        for (unsigned j = 0; j < cols; ++j)
        {
            matrix[i][j] = rand() % (highBound - lowBound + 1) + lowBound;
        }
    }
}
 
void printMatrix(int ** const matrix, const unsigned &rows, const unsigned &cols)
{
    for (unsigned i = 0; i < rows; ++i)
    {
        for (unsigned j = 0; j < cols; ++j)
        {
            std::cout << matrix[i][j];
            if ((j + 1) ^ cols)
            {
                std::cout << ' ';
            }
        }
        std::cout << std::endl;
    }
}
 
SaddlePoints* saddlePointsMatrix(int ** const matrix, const unsigned &rows, const unsigned &cols)
{
    SaddlePoints *res = initSaddlePoints(rows);
    for (unsigned i = 0; i < rows; ++i)
    {
        for (unsigned j = 0; j < cols; ++j)
        {
            bool isFlag = true;
            // Проверяем строку
            for (unsigned q = 0; q < cols; ++q)
            {
                if ((q != j) && (matrix[i][j] >= matrix[i][q]))
                {
                    isFlag = !isFlag;
                    break;
                }
            }
            // Проверяем столбец
            if (isFlag)
            {
                for (unsigned p = 0; p < rows; ++p)
                {
                    if ((p != i) && (matrix[i][j] <= matrix[p][j]))
                    {
                        isFlag = !isFlag;
                        break;
                    }
                }
            }
            // Добавляем точку
            if (isFlag)
            {
                res->points[res->size].x = i;
                res->points[res->size].y = j;
                ++res->size;
            }
        }
    }
    return res;
}