Laba_Den

// Сортировка по возрастанию методом обмена без флага перестановки
// Язык реализации - С++

#include <iostream>

#define PARAMETER 50 //константа

using namespace std;

//создаём структуру "Массив"
//для объявления массива это вовсе не обязательно
//но всё равно делаем так
struct Arreys
{
    int Matr [PARAMETER] [PARAMETER]; //массив
    int n; //число используемых строк и столбцов
};

// объявляем функции, которые будем использовать
struct Arreys Create (struct Arreys My_Matr);
void Browse (struct Arreys My_Matr);
struct Arreys Nulling (struct Arreys My_Matr);
struct Arreys Sorting (struct Arreys My_Matr);

/*============================================*/
/*============тело главной функции============*/
/*============================================*/
int main ()
{
    struct Arreys My_Matr; //создаём экземпляр структуры "Массив"
    cout<<"  Select 1/2 the width of the square: ";
    cin>>My_Matr.n; //находим n
    cout<<endl;

    My_Matr=Create(My_Matr); //заполняем
    cout<<"  Array:"<<endl;
    Browse(My_Matr); //выводим на экран

    My_Matr=Sorting(My_Matr); //сортируем
    cout<<"  Sorting:"<<endl;
    Browse(My_Matr); //выводим на экран

    My_Matr=Nulling(My_Matr); //обнуляем
    cout<<"  Nulling:"<<endl;
    Browse(My_Matr); //выводим на экран

    cin.sync(); //удерживаем экран до нажатия клавиши
    cin.get();
    return 0;
}
/*============================================*/
// функция заполнения массива
// принимает экзмепляр стуктуры "Массив"
struct Arreys Create (struct Arreys My_Matr)
{
    int i, j; //переменные счётчика
    for (i=0; i<(2*My_Matr.n); i++) //до последней строки
    {
        for (j=0; j<(2*My_Matr.n); j++) //до последнего столбца
            My_Matr.Matr[i][j]=2*My_Matr.n - i; //заносим в ячейку общее число строк - номер текщей строки
    }
    return My_Matr; //возвращаем массив
}
/*============================================*/
// функция просмотра массива
void Browse (struct Arreys My_Matr)
{
    int i, j; //переменные
    cout<<endl;
    for (i=0; i<(2*My_Matr.n); i++) //по строкам
    {
        cout<<"  ";
        for (j=0; j<(2*My_Matr.n); j++) //по столбцам
        {
            cout<<My_Matr.Matr[i][j]; //выводим инфу на экран
        }
        cout<<endl;
    }
    cout<<endl;
}

/*============================================*/
// функция обнуления массива
struct Arreys Nulling (struct Arreys My_Matr)
{
    int i, j; //переменные

    //обнуление верхней половины матрицы
    for (i=1; i<My_Matr.n; i++)
    {
        // обнуление левой части
        for (j=0; j<i; j++)
        {
            My_Matr.Matr[i][j] = 0; //обнуляем
        }

        // обнуление правой части
        for (j=2*My_Matr.n-1; j>=2*My_Matr.n-i; j--)
        {
            My_Matr.Matr[i][j] = 0; // обнуляем
        }
    }

    // обнуление нижней части
    for (i=My_Matr.n; i<2*My_Matr.n; i++)
    {
        // обнуление левой части
        for (j=0; j<2*My_Matr.n-i-1; j++)
        {
            My_Matr.Matr[i][j] = 0; // обнуляем
        }

        // обнуление правой части
        for (j=2*My_Matr.n-1; j>i; j--)
        {
            My_Matr.Matr[i][j] = 0; // обнуляем
        }

    }

    return My_Matr; //возвращаем массив
}


/*============================================*/
// функция сортировки массива
struct Arreys Sorting (struct Arreys My_Matr)
{
    int i, j, k, s, z; //куча переменных
    i=0;
    //сортировка левой половины матрицы
    for (j=0; ((j<=i)&&(j<My_Matr.n-1)); j++) //по столбцам
    {
        for (k=0; k<=(2*j); k++) //перестановки
        {
            for (i=0; ((i<=j)&&(i<2*My_Matr.n-1)); i++) //строки
            {
                if (My_Matr.Matr[i-1][j]>My_Matr.Matr[i][j])
                {
                    //если выполняется условие
                    //меняем местами инфу в ячейках
                    z=My_Matr.Matr[i-1][j];
                    My_Matr.Matr[i-1][j]=My_Matr.Matr[i][j];
                    My_Matr.Matr[i][j]=z;
                }
            }
            for (i=0, s=2*My_Matr.n-1; ((i<=j)||(s>=2*My_Matr.n-2*j)); i++, s--)
            {
                //сравниваем верх с низом
                if (My_Matr.Matr[i][j]>My_Matr.Matr[s][j])
                {
                    z=My_Matr.Matr[i][j];
                    My_Matr.Matr[i][j]=My_Matr.Matr[s][j];
                    My_Matr.Matr[s][j]=z;
                }
                //и приводим в порядок низ
                if (My_Matr.Matr[s-1][j]>My_Matr.Matr[s][j])
                {
                    z=My_Matr.Matr[s-1][j];
                    My_Matr.Matr[s-1][j]=My_Matr.Matr[s][j];
                    My_Matr.Matr[s][j]=z;
                }
            }
        }
    }

    //сортируем два средних столбца

    for (j=My_Matr.n-1; j<=My_Matr.n; j++)
    {
        for (k=0; k<=(2*j); k++)
        {
            for (i=0; i<2*My_Matr.n; i++)
            {
                if (My_Matr.Matr[i-1][j]>My_Matr.Matr[i][j])
                {
                    //если выполняется условие
                    //меняем местами инфу в ячейках
                    z=My_Matr.Matr[i-1][j];
                    My_Matr.Matr[i-1][j]=My_Matr.Matr[i][j];
                    My_Matr.Matr[i][j]=z;
                }
            }
        }
    }
    //===============================================

    //сортировка правой половины матрицы
    for (j=My_Matr.n+1; j<2*My_Matr.n; j++)
    {
        for (k=0; k<=(2*j+1); k++)
        {

            //сравниваем верх с низом

            for (i=0, s=2*My_Matr.n-1; ((i<2*My_Matr.n-j)||(s>2*My_Matr.n-j)); i++, s--)
            {
                //сравниваем верх с низом
                if (My_Matr.Matr[i][j]>My_Matr.Matr[s][j])
                {
                    z=My_Matr.Matr[i][j];
                    My_Matr.Matr[i][j]=My_Matr.Matr[s][j];
                    My_Matr.Matr[s][j]=z;
                }
                //и приводим в порядок низ
                if (My_Matr.Matr[s-1][j]>My_Matr.Matr[s][j])
                {
                    z=My_Matr.Matr[s-1][j];
                    My_Matr.Matr[s-1][j]=My_Matr.Matr[s][j];
                    My_Matr.Matr[s][j]=z;
                }
            }


            //сортируем верхнюю часть
            for (i=1; i<2*My_Matr.n-j; i++)
            {
                z=My_Matr.Matr[i-1][j];
                My_Matr.Matr[i-1][j]=My_Matr.Matr[i][j];
                My_Matr.Matr[i][j]=z;
            }


        }
    }

    return My_Matr; //возвращаем то, что получилось
}