Сортировка_Дима

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

    #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]=j+1; //заносим в ячейку номер столбца
            }
            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, k, z; //переменные

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

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

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


    /*============================================*/
    // функция сортировки массива
    struct Arreys Sorting (struct Arreys My_Matr)
    {
        int beginning, ending, i, j, k, Min, jMin;
        // beginning - начало, откуда сортируем
        // ending - конец, до чего сортируем
        // i, j, k - переменные
        // Min, jMin - минимум и номер его столбца


        // сортировка левой верхней части
        for (i=0, ending = My_Matr.n-2; i<My_Matr.n, ending>0 ; i++, ending--) //идём по строкам, конец сдвигается
        {
            for (k=ending; k>0; k--) //докуда ищем миниммум
            {
                jMin=0;
                Min=My_Matr.Matr[i][0]; //считаем минимумом первый элеммент
                for (j=0; j<=k; j++) // идём по столбцам
                {
                    if (My_Matr.Matr[i][j]<=Min) // сравниваем всё с текущим минимумом
                    {
                        Min=My_Matr.Matr[i][j]; // если находим новый минимум - сохраняем
                        jMin=j; // сохраняем номер стобца
                    }
                }
                My_Matr.Matr[i][jMin]=My_Matr.Matr[i][k]; //меняем местами последний элемент
                My_Matr.Matr[i][k]=Min;            // и минимум
            }
        }

        // сортировка правой верхней части
        ending=2*My_Matr.n-1; // это конец
        for (i=0, beginning=My_Matr.n+1; i<My_Matr.n, beginning<2*My_Matr.n; i++, beginning++) // меняются строка и место начала
        {
            for (k=ending; k>=beginning; k--) // докуда ишем минимум
            {
                jMin=0;  // далее всё то же самое
                Min=My_Matr.Matr[i][beginning];
                for (j=beginning; j<=k; j++)
                {
                    if (My_Matr.Matr[i][j]<=Min)
                    {
                        Min=My_Matr.Matr[i][j];
                        jMin=j;
                    }
                }
                My_Matr.Matr[i][jMin]=My_Matr.Matr[i][k];
                My_Matr.Matr[i][k]=Min;
            }
        }

        // сортировка левой нижней части

        for (i = My_Matr.n+2, ending = 1; i<2*My_Matr.n, ending<2*My_Matr.n-1; i++, ending++)
        {
            for (k=ending; k>0; k--)
            {
                jMin=0;
                Min=My_Matr.Matr[i][0];
                for (j=0; j<=k; j++)
                {
                    if (My_Matr.Matr[i][j]<=Min)
                    {
                        Min=My_Matr.Matr[i][j];
                        jMin=j;
                    }
                }
                My_Matr.Matr[i][jMin]=My_Matr.Matr[i][k];
                My_Matr.Matr[i][k]=Min;
            }
        }

        // сортировка правой нижней части
        ending=2*My_Matr.n-1;
        for (i=My_Matr.n+2, beginning=2*My_Matr.n-2; i<2*My_Matr.n, beginning>My_Matr.n; i++, beginning--)
        {
            for (k=ending; k>=beginning; k--)
            {
                jMin=0;
                Min=My_Matr.Matr[i][beginning];
                for (j=beginning; j<=k; j++)
                {
                    if (My_Matr.Matr[i][j]<=Min)
                    {
                        Min=My_Matr.Matr[i][j];
                        jMin=j;
                    }
                }
                My_Matr.Matr[i][jMin]=My_Matr.Matr[i][k];
                My_Matr.Matr[i][k]=Min;
            }
        }


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