Сравнение двумерных матриц - разобрать код

int** create_matrix(int n, int m,int tip)
{
    int**variable= NULL; //переменная
    variable = (int**)malloc(sizeof(int*)*n);
    for(int i=0;i<n;i++)
        variable[i]=(int*)malloc(sizeof(int)*m);
    printf("Matrix_successfully_created\n",n,m);//матрицу успешно созданно
    rand_value(variable,n,m); //рандомное значение
    return variable;
}
//----------------------------------------------------------------------------------
void free_memory(int*** matrix,int n)
{
    if((*matrix==NULL) || (matrix == NULL))
    {
        printf("memory_deleted");
    }else
    {
        for(int i=0;i < n;i++)
        {
            free(matrix[i]);
        }
        free(*matrix);
        *matrix=NULL;
    }
}
//----------------------------------------------------------------------------------
int** rand_value(int** matrix, int n, int m)
{
    srand(time(NULL));
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            matrix[i][j]=rand()%20;
    check (matrix,n,m);
    return matrix;
}
//----------------------------------------------------------------------------------
int* find_max_min(int** matrix,int n,int m)
{
    if((matrix==NULL)||(n==0)||(m==0))
    {
        printf("First_create_a_matrix");// сначала создайте матрицу
        return NULL;
    } else
    {
        int max=matrix[0][0];
        int max_k_n=0,max_k_m=0;
        int min=matrix[0][0];
        int min_k_n=0,min_k_m=0;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(matrix[i][j] > max)
                {
                    max = matrix[i][j];
                    max_k_n=i;
                    max_k_m=j;
                }
                if(matrix[i][j] < min)
                {
                    min = matrix[i][j];
                    min_k_n=i;
                    min_k_m=j;
                }
            }
        }
        int *return_matrix = (int*)malloc(sizeof(int)*4);
        return_matrix[0]=max_k_n;
        return_matrix[1]=max_k_m;
        return_matrix[2]=min_k_n;
        return_matrix[3]=min_k_m;
        return return_matrix;
    }
}
//----------------------------------------------------------------------------------
void find_value(int** matrix, int n, int m, int value)
{
    if((matrix==NULL)||(n==0)||(m==0))
    {
        printf("First_create_a_matrix");
    } else
    {
        int find=0;
        int index=0;
        int** variable;
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                if(matrix[i][j] == value)
                    find++;
        variable = (int**)malloc(sizeof(int*)*find);
        for(int i=0;i<find;i++)
            variable[i]=(int*)malloc(sizeof(int)*2);
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
                if(matrix[i][j] == value)
                {
            variable[index][0]=i;
            variable[index][1]=j;
            index++;
        }
        for(int i=0;i<find;i++)
            printf("n=%d,m=%d\n",variable[i][0],variable[i][1]);
    }
}
//----------------------------------------------------------------------------------
int** compare(int** matrix,int** matrix2,int n,int m)
{
    if((matrix==NULL)||(n==0)||(m==0))
    {
        printf("First_create_a_matrix");
        return NULL;
    } else
    {
        int** matrix3 = create_matrix(n,m,1);
        printf("First_matrix:\n");//первая
        check(matrix,n,m);
        printf("second:\n");//вторая
        check(matrix2,n,m);
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
            {
            if(matrix[i][j] > matrix2[i][j])
            {
                matrix3[i][j]=matrix[i][j];
            }else
            {
                matrix3[i][j]=matrix3[i][j];
            }
        }
        printf("The_compare_is_successful\n"); //Сравнение прошло успешно.
        return matrix3;
    }
}

int** create_matrix(int n, int m, int tip)
{
  int**variable= NULL; //переменная    --объявляем переменную под наш двумерный массив
  variable = (int**)malloc(sizeof(int*)*n); // динамически выделяем память под массив строк
for (int i=0; i<n; i++) //в этом цикле выделяем память под каждую строку (массив ячеек)
    variable[i]=(int*)malloc(sizeof(int)*m); 
    printf("Matrix_successfully_created\n",n,m);//матрицу успешно созданно
   rand_value(variable,n,m); //рандомное значение
return variable;
}

//===================================  1  =====================================
// Определение функции create_matrix(). Функция принимает три аргумента
// целочисленного типа и возвращает указатель на указатель на тип int.
// Переменные int n и int m задают размерность матрицы.
int** create_matrix(int n, int m, int tip)
{
    int**variable = NULL;   // создаётся указатель на указатель на int с именем
                            // variable и ему присваивается значение NULL
                            
// Функция malloc() возвращает указатель на первый байт области памяти размером
// size, которая была выделена из динамически распределяемой области памяти.
// Для определения размера используется sizeof - унарный оператор, возвращающий
// длину в байтах переменной или типа, помещенных в скобки (результат приводится
// к типу указатель на указатель на int). Как написал выше Algoritmer,
// двумерный массив - это одномерный массив одномерных массивов. Если
// рассматривать двумерный массив как таблицу, то можно представить, что сначала
// мы создаем массив строк (рядов) - у нас количество строк это значение переменной
// int n, а потом создаем в цикле массив ячеек (колонок) - за количество колонок 
// у нас отвечает переменная int m:                          
    variable = (int**)malloc(sizeof(int*)*n); // для variable выделяется память
 
// Выделение памяти для всех элементов матрицы пошагово - элемент за элементом
// при помощи цикла for, функции malloc() и унарного оператора sizeof:
    for (int i=0; i<n; i++)
        variable[i]=(int*)malloc(sizeof(int)*m);
        
// Вывод в поток (чаще всего - на экран монитора) строкового литерала
// "Matrix_successfully_created" при помощи функции printf(); в конце строкового
// литерала имеется управляющая последовательность \n - эти два символа
// трактуются как один символ и обозначают перевод строки:
    printf("Matrix_successfully_created\n", n, m);  // матрица успешно создана
    
// Вызов функции rand_value(), генерирующей случайное значение:
    rand_value(variable, n, m);     // рандомное значение
 
// Функция create_matrix() заканчивает все вычисления, возвращая в вызвавшую её
// функцию (например, в функцию main) значение variable при помощи оператора
// return:
    return variable;
}

//===================================  2  ======================================
// Определение (иногда вместо термина "определение" используют термин
// "реализация") функции free_memory(). Функция принимает два аргумента.
// В качестве первого аргумента - указатель третьего уровня (указатель на
// указатель на указатель) на тип int, в качестве второго - целочисленную
// переменную. Функция не возвращает никаких значений в вызывающую функцию,
// о чём свидетельствует тип возвращаемого значения void (от англ. "void" -
// пустой).
void free_memory(int*** matrix, int n)
{
// Функция выполняет проверку матрицы на предмет занимаемой ею памяти.
    if ((*matrix==NULL) || (matrix == NULL)) // если матрица не занимает памяти
        printf("memory_deleted");   // вывести сообщение "память очищена"
        
    else    // иначе
    {
        for (int i=0; i<n; i++) // элемент за элементом удалить из памяти
            free(matrix[i]);    // вызов функции free(), освобождающей память
            
// Функция free() возвращает память, на которую указывает параметр ptr (в нашем
// случае, в качестве такого параметра выступает указатель matrix[i] записанный в
// нотации массивов - то есть, синтаксис как у массивов, а на самом деле это
// указатель на первый элемент массива), назад в кучу (heap).
// В результате эта память может выделяться снова.
// Обязательным условием использования функции free() является то, что
// освобождаемая память должна была быть предварительно выделена с использованием
// одной из следующих функций: malloc(), realloc() или calloc().
// Прототип функции free() находится в заголовочном файле <stdlib.h>
                    
        free(*matrix);  // освободить память, на которую указывает matrix
        *matrix = NULL; // присвоить указателю matrix значение NULL
    }
}

//===================================  3  ======================================
// Определение функции rand_value(). Функция принимает три аргумента - 
// указатель на указатель на тип int и две переменных типа int. Функция
// возвращает указатель на указатель на тип int.
 
// Функция srand выполняет инициализацию генератора случайных чисел rand.
// Генератор псевдо-случайных чисел инициализируется с помощью аргумента seed, 
// который играет роль зерна. В нашем случаем таким аргументом выступает
// значение, возвращаемое функцией time().
// Для того, чтобы генерировать случайные числа, функция srand обычно
// инициализируется некоторыми различными значения, например, такие значения
// генерируются функцией time. Значение, возвращенное функцией time (объявлена
// в заголовке <ctime>) отличается каждую секунду, что дает возможность получать
// совершенно случайные последовательности чисел, при каждом новом вызове
// функции rand.
int** rand_value(int** matrix, int n, int m)
{
    srand(time(NULL));  // запускаем генератор псевдо-случайных чисел
    
// Проходим по всей матрице элемент за элементом при помощи двух вложенных
// циклов for, инициализируя каждый элемент матрицы matrix случайными
// числами в диапазоне от 0 до 20:
    for (int i=0; i<n; i++)
        for (int j=0; j<m; j++)
            matrix[i][j] = rand()%20;   // диапазон значений от 0 до 20
 
    check(matrix, n, m);    // какая-то функция проверки - хз чё за хреновина
    
    return matrix;  // возвращаем matrix
}

//===================================  4  ======================================
// Определение функции find_max_min(). Назначение функции - искать минимальные и
// максимальные значения в матрице. Функция принимает три аргумента - 
// указатель на массив указателей на тип int и две целочисленные переменные,
// задающие размерность матрицы. Возвращаемое значение - указатель на тип int.
int* find_max_min(int** matrix, int n, int m)
{
// Если память под матрицу не выделена или если матрица не заполнена значениями:
    if ((matrix==NULL)||(n==0)||(m==0))
    {   // Вывести на экран сообщение "сначала создайте матрицу":
        printf("First_create_a_matrix");
            
// В завсисмости от реализации компилятора вернуть 0, либо вернуть "мусор":            
        return NULL;    // Плохой стиль программирования! Лучше так не делать!
    }
    
    else    // иначе
    {
        // Присвоить переменной max значение, хранящееся в первом элементе
        // массива matrix:
        int max = matrix[0][0];
        
        // Создать две целочисленные перменные для максимальных значений
        // и пока что присвоить им нулевые значения:
        int max_k_n = 0, max_k_m = 0;
        
        // Присвоить переменной min значение, хранящееся в первом элементе
        // массива matrix:
        int min = matrix[0][0];
        
        // Создать две целочисленные перменные для минимальных значений
        // и пока что присвоить им нулевые значения:
        int min_k_n = 0, min_k_m = 0;
        
        // ЦИкл пошагово проверяет все элементы матрицы:
        for (int i=0; i<n; i++)
            for (int j=0; j<m; j++)
                
// Если значение, хранящееся в текущем элементе массива больше, чем то, которое
// на данный момент хранится в переменной max, то
                if (matrix[i][j]>max) 
                {
                    max = matrix[i][j]; // присвоить переменной max это значение
                    
// "Запомнить" в какой ячейке массива найдено максимальное значение (в отдельные
// переменные сохраняются индексы ячейки):                 
                    max_k_n = i;
                    max_k_m = j;
                }
 
 // Если значение, хранящееся в текущем элементе массива меньше, чем то, которое
// на данный момент хранится в переменной min, то               
                if (matrix[i][j]<min)
                {
                    min = matrix[i][j]; // присвоить переменной min это значение
                    
// "Запомнить" в какой ячейке массива найдено миниимальное значение (в отдельные
// переменные сохраняются индексы ячейки): 
                    min_k_n = i;
                    min_k_m = j;
                }
            }
        }
// Создание массива int return_matrix[4]. Выделение памяти для 4 интов:
        int *return_matrix = (int*)malloc(sizeof(int)*4);
        
// Инициализация элементов массива значениями:
        return_matrix[0] = max_k_n;
        return_matrix[1] = max_k_m;
        return_matrix[2] = min_k_n;
        return_matrix[3] = min_k_m;
 
// Вернуть в вызывающую функцию указатель на массив return_matrix:    
        return return_matrix;
    }
}

//===================================  5  ======================================
// Определение функции find_value(). Назначение функции - искать заданное
// значение в матрице. Функция принимает четыре аргумента -
// указатель на матрицу типа int, две целочисленные переменные,
// задающие размерность матрицы и переменную int value, с помощью которой
// в функцию передаётся значение, которое и будем искать.
// Возвращаемое значение отсутствует.
void find_value(int** matrix, int n, int m, int value)
{
// Если память для матрицы не выделена (матрица не существует) или если
// в матрице нет значений (точнее, если вместо значений - нули), то
    if ((matrix==NULL)||(n==0)||(m==0))
        printf("First_create_a_matrix");    //вывести на экран сообщение
        
    else    // иначе
    {
        int find = 0;   // создаём счётчик "найдёнышей"
        
        int index = 0;  // индекс "рядов" (rows) матрицы variable
        
        int** variable; // создаём матрицу, которая будет хранить индексы
                        // найденных совпадений с нашим "поисковым запросом"
                        
    // Пробегаем по матрице matrix двумя вложенными циклами for:
        for (int i=0; i<n; i++)
            for (int j = 0; j<m; j++)
    // Если какое-то значение совпадает с нашим "поисковым запросом" (то есть
    // с значением переменной value)               
                if (matrix[i][j] == value)
                    find++; // то увеличить счётчик найденных совпадений
 
    // Создадим матрицу, в которую сложим всех найдёнышей. Размер матрицы
    // будет завязан, соответственно, на количество найденных совпадений (то
    // есть, на значение переменной find. Выделяем память под массив variable:
        variable = (int**)malloc(sizeof(int*)*find);
        
    // А раз у нас variable - это массив массивов (матрица), выделяем память
    // под каждый так сказать "субмассив":
        for (int i=0; i<find; i++)
            variable[i] = (int*)malloc(sizeof(int)*2);
            
    // Складываем всех найдёнышей в матрицу variable:
        for (int i=0; i<n; i++)
            for (int j=0; j<m; j++)
                if (matrix[i][j] == value)
                {
                    variable[index][0] = i;
                    variable[index][1] = j;
                    index++;
                }
    // Выводим на экран результаты поиска (всех "найдёнышей"):
        for (int i=0; i<find; i++)
            printf("n=%d,m=%d\n",variable[i][0],variable[i][1]);
    }
}

//===================================  6  ======================================
// Определение функции compare(). Назначение функции - сравнивать две матрицы
// и возвращать болшую из них. Функция принимает четыре аргумента -
// указатель на первую матрицу типа int, указатель на вторую матрицу типа int,
// и две целочисленные переменные, задающие размер матриц.
//
// Возвращаемое значение - указатель на указатель на тип int (иными словами,
// указатель на массив указателей). Хитрый трюк, позволяющий, по сути, сделать
// возвращаемым значением матрицу.
//==============================================================================
int** compare(int** matrix, int** matrix2, int n, int m)
{
    // Если память для матрицы не выделена (матрица не существует) или если
    // в матрице нет значений (точнее, если вместо значений - нули)
    if ((matrix==NULL)||(n==0)||(m==0))
    {
        // то вывести на экран сообщение "First_create_a_matrix"
        printf("First_create_a_matrix");
        return NULL;    // Гррррррр >:(
    }
    
    else    // иначе
    {
        // Вызвать функцию create_matrix() и результат её работы присвоить
        // указателю второго уровня matrix3. Проще говоря, создаём третью
        // матрицу (то есть matrix3[n][m]):
        int** matrix3 = create_matrix(n,m,1);
        printf("First_matrix:\n");  // вывод на экран сообщения "Первая матрица:"
        check(matrix,n,m);  // какая-то функция (судя по названию, проверяющая
                            // матрицы по каким-то своим критериям)
        printf("second:\n");    // вывод на экран сообщения "Вторая матрица:"
        check(matrix2,n,m); // проверяем вторую матрицу
        
        // Пробегаем по матрицам двумя вложенными циклами for:
        for (int i=0; i<n; i++)
            for (int j=0; j<m; j++)
            {
                // Если первая матрица больше второй
                if (matrix[i][j] > matrix2[i][j])
                // то копируем первую матрицу в третью 
                    matrix3[i][j] = matrix[i][j]; 
                else
                // иначе,
                    matrix3[i][j] = matrix3[i][j]; // тут ошибка, судя по всему.
                // Скорее всего, должно быть так:
                //  matrix3[i][j] = matrix2[i][j];
            }
        // Вывести сообщение ""The_compare_is_successful"
        printf("The_compare_is_successful\n"); //Сравнение прошло успешно.
        
        // Вернуть указатель на массив указателей matrix3 (то есть 
        // вернуть бОльшую матрицу):
        return matrix3; 
    }
}

//===================================  1  =====================================
int** create_matrix(int n, int m, int tip)
{
    int**variable = NULL;   //переменная
    variable = (int**)malloc(sizeof(int*)*n);
    
    for (int i=0; i<n; i++)
        variable[i] = (int*)malloc(sizeof(int)*m);
    printf("Matrix_successfully_created\n", n, m); //матрица успешно создана
    rand_value(variable, n, m); //рандомное значение
    
    return variable;
}

int** create_matrix(int row, int col, int** matrix);

//===================================  1  =====================================
int** create_matrix(int n, int m, int** variable)
{
    int** variable = NULL;
    variable = (int**)malloc(sizeof(int*)*n);
    
    for (int i=0; i<n; i++)
        variable[i] = (int*)malloc(sizeof(int)*m);
    printf("Matrix_successfully_created\n", n, m); //матрица успешно создана
    rand_value(variable, n, m); //рандомное значение
    
    return variable;
}