using System;


namespace laba4
{
    class Program
    {
        static void Sort1(int[] StartMassive, int SizeMaasive)
        {
            if (MassiveVoid(StartMassive, ref SizeMaasive))
            {
                for (int i = 1; i < StartMassive.Length; i++)
                    for (int j = StartMassive.Length - 1; j >= i; j--)
                        if (StartMassive[j] < StartMassive[j - 1])
                        {
                            int Num = StartMassive[j];
                            StartMassive[j] = StartMassive[j - 1];
                            StartMassive[j - 1] = Num;
                        }
                Console.WriteLine("Сортировка выполнена");
            }
            else
                Console.WriteLine("Сортировка не выполнена, массив пустой");
        }//Сортировка массива
        static void Sort2(int[] StartMassive, ref int SizeMaasive)

        {
            int j, el, i;
            for (i = 1; i < SizeMaasive; i++)
            {
                el = StartMassive[i];
                j = i - 1;
                while (j >= 0 && el < StartMassive[j])
                {
                    StartMassive[j + 1] = StartMassive[j];
                    j--;
                }
                StartMassive[j + 1] = el;
            }
        }//метод включения
        static void quickSort(int[] a, int l, int r)
        {
            int temp;
            int x = a[l + (r - l) / 2];
            int i = l;
            int j = r;
            while (i <= j)
            { while (a[i] < x) i++; while (a[j] > x) j--;
                if (i <= j) { temp = a[i]; a[i] = a[j]; a[j] = temp; i++; j--; }
            }
            if (i < r) quickSort(a, i, r); if (l < j) quickSort(a, l, j);
        }//быстрая сортировка


            static int[] CreateMassiveRandom(out int SizeMassive)
        {
            Console.Clear();
            Console.WriteLine("Введите количество элементов массива");

            int Big, Low; //Количество элементов cлучайного массива, верхняя и нижжняя граница

            while ((!Int32.TryParse(Console.ReadLine(), out SizeMassive)) || (SizeMassive <= 0))
                Console.WriteLine("Ввод неверен! Введите положительное целое значение");

            Console.WriteLine("Введите Верхнюю границу массива (максимально возможное значение случайного числа)");
            while (!Int32.TryParse(Console.ReadLine(), out Big))
                Console.WriteLine("Ввод неверен!");
            Console.WriteLine("Введите Нижнюю границу массива (минимально возможное значение случайного числа)");
            while ((!Int32.TryParse(Console.ReadLine(), out Low)) || (Big < Low))
                Console.WriteLine("Введите число меньше верхней границы");
            int[] StartMassive = new int[SizeMassive];
            Random rand = new Random();
            for (int i = 0; i < StartMassive.Length; i++)
                StartMassive[i] = rand.Next(Low, Big + 1);
            return StartMassive;

        }//Создание массива с помощью ДСЧ
        static int[] CreateMassiveKey(out int SizeMassive)
        {
            Console.Clear();
            Console.WriteLine("Введите количество элементов массива");
            while ((!Int32.TryParse(Console.ReadLine(), out SizeMassive)) || (SizeMassive <= 0))
                Console.WriteLine("Ввод неверен! Введите положительное целое значение");
            int[] StartMassive = new int[SizeMassive];
            for (int i = 0; i < StartMassive.Length; i++)
            {
                Console.WriteLine(string.Format("Введите {0}й элемент массива:", i + 1));
                while (!Int32.TryParse(Console.ReadLine(), out StartMassive[i]))
                    Console.WriteLine("Таких цифр не знаю");  //Ручной ввод элементов массива
            }
            return StartMassive;

        }//Создание массива с клавиатуры
        static void ShowMassive(int[] StartMassive, int SizeMassive)
        {
            Console.Clear();
            if (MassiveVoid(StartMassive, ref SizeMassive))
            {
                foreach (int element in StartMassive)
                {
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    Console.Write(element + " ");
                    Console.ForegroundColor = ConsoleColor.Gray;
                }
            }
            else Console.WriteLine("Массив пустой!");
        }//Печать массива
        static bool MassiveVoid(int[] StartMassive, ref int SizeMassive)
        {

            if (StartMassive.Length == 0)
            {
                if (SizeMassive != 0) SizeMassive = 0;

                return false;
            }

            return true;
        }//Проверка пустоты массива
        static void ShowMenu1(int[] StartMassive, int SizeMassive)
        {
            Console.Clear();
            Console.WriteLine("Меню");
            Console.WriteLine("Выберите способ ввода массива");
            Console.WriteLine("1. Случайная генерация массива");
            Console.WriteLine("2. Ручной ввод массива");
            Console.WriteLine("3. Выход");
            int choose = 0;
            while ((!Int32.TryParse(Console.ReadLine(), out choose)) || (choose > 3) || (choose < 1))
                Console.WriteLine("Таких цифр не знаю");
            switch (choose)
            {
                case 1:
                    StartMassive = CreateMassiveRandom(out SizeMassive);
                    Go(StartMassive, SizeMassive);
                    break;
                case 2:
                    StartMassive = CreateMassiveKey(out SizeMassive);
                    Go(StartMassive, SizeMassive);
                    break;
                case 3: //Выход
                    Environment.Exit(0);
                    break;

            }
            Console.ReadKey();
        }//Выбор способа создания массива
        static void ShowMenu2()
        {
            Console.WriteLine("");
            Console.WriteLine("Выберите действие с массивом");
            Console.WriteLine("1. Печать массива");
            Console.WriteLine("2. Сортировка выбором");
            Console.WriteLine("3. Сортирова методом включения");
            Console.WriteLine("4. Сортирова быстрая");
            Console.WriteLine("5. Назад к созданию массива");
        }//Выбор действия с массивом
        static void InitMassive(out int SizeMassive, out int[] StartMassive)
        {
            SizeMassive = 0;
            StartMassive = null;
        }//Инициализация массива
        static void Go(int[] StartMassive, int SizeMassive)
        {
            ShowMenu2();
            int choose1;
            bool sort = false;
            while ((!Int32.TryParse(Console.ReadLine(), out choose1)) || (choose1 > 8) || (choose1 < 1))
                Console.WriteLine("Таких цифр не знаю");
            switch (choose1)
            {
                case 1:
                    ShowMassive(StartMassive, SizeMassive);
                    Go(StartMassive, SizeMassive);
                    sort = false;
                    break;//Печать массива
                case 2:
                    if (!sort) //не отсортирован
                        Sort1(StartMassive, SizeMassive);
                    sort = true;//Отсортирован
                    ShowMassive(StartMassive, SizeMassive);
                    Go(StartMassive, SizeMassive);
                    break;//Сортировка массива
                case 3:
                    if (!sort) //не отсортирован
                        Sort2(StartMassive, ref SizeMassive);
                    sort = true;//Отсортирован
                    ShowMassive(StartMassive, SizeMassive);
                    Go(StartMassive, SizeMassive);
                    break;
                case 4:
                    quickSort(StartMassive, 0, SizeMassive - 1);
                    ShowMassive(StartMassive, SizeMassive);
                    Go(StartMassive, SizeMassive);
                    break;
                case 5:
                    ShowMenu1(StartMassive, SizeMassive);
                    break;
            }
        }//Вызов функций действия с массивами
        static void Main(string[] args)
        {
            Console.WriteLine("Практическая работа номер 4");
            int SizeMassive;
            int[] StartMassive;
            InitMassive(out SizeMassive, out StartMassive);
            ShowMenu1(StartMassive, SizeMassive);
            Console.ReadKey();
        }

    }
}