java

import java.util.Scanner;
import java.io.*;

public class Main
{
    public static void printTask()
    {
        System.out.println("Эта программа сортирует массив чисел метод слияния");
    }
    public static Scanner scanner = new Scanner(System.in);
    public static String readPathFile()
    {
        String pathToFile;
        boolean isInCorrect;
        do {
            isInCorrect = false;
            System.out.print("Введите путь к файлу с расширением.txt: ");
            pathToFile = scanner.nextLine();
            if (pathToFile.length() < 5 || !pathToFile.endsWith(".txt")) {
                System.out.println("Расширение файла не .txt!\n");
                isInCorrect = true;
            }
        } while (isInCorrect);
        return pathToFile;
    }

    public static boolean isNotExists(String pathToFile)
    {
        File file = new File(pathToFile);
        return !file.exists();
    }

    public static boolean isNotAbleToReading(String pathToFile)
    {
        File file = new File(pathToFile);
        return !file.canRead();
    }

    public static boolean isNotAbleToWriting(String pathToFile)
    {
        File file = new File(pathToFile);
        return !file.canWrite();
    }

    public static boolean isEmpty(String pathToFile) throws IOException
    {
        boolean isEmpty;

        isEmpty = false;

        try (FileReader fileReader = new FileReader(pathToFile))
        {
            isEmpty = fileReader.read() == -1;
        }
        catch (IOException exception)
        {
            exception.printStackTrace();
        }
        return isEmpty;
    }

    public static String getFileNormalReading() throws IOException
    {
        String pathToFile;
        boolean isInCorrect;
        do
        {
            isInCorrect = false;
            pathToFile = readPathFile();
            if (isNotExists(pathToFile))
            {
                isInCorrect = true;
                System.out.println("Проверьте корректность ввода пути к файлу!\n");
            }
            if (isInCorrect || isNotAbleToReading(pathToFile))
            {
                isInCorrect = true;
                System.out.println("Файл закрыт для чтения!\n");
            }
            if (isInCorrect || isEmpty(pathToFile))
            {
                isInCorrect = true;
                System.out.println("Файл пуст!\n");
            }
        }
        while (isInCorrect);

        return pathToFile;
    }

    public static String getFileNormalWriting() throws IOException
    {
        String pathToFile;
        boolean isInCorrect;
        do
        {
            isInCorrect = false;
            pathToFile = readPathFile();
            if (isNotExists(pathToFile))
            {
                isInCorrect = true;
                System.out.println("Проверьте корректность ввода пути к файлу!\n");
            }
            if (isInCorrect || isNotAbleToWriting(pathToFile))
            {
                isInCorrect = true;
                System.out.println("Файл закрыт для записи!\n");
            }
        }
        while (isInCorrect);

        return pathToFile;
    }

    public static int inputIntFromConsole(int min, int max)
    {
        int inputNumber;
        boolean isInCorrect;

        inputNumber = 0;

        do
        {
            isInCorrect = false;
            try
            {
                inputNumber = Integer.parseInt(scanner.nextLine());
            }
            catch (NumberFormatException exception)
            {
                isInCorrect = true;
            }
            if (isInCorrect || inputNumber < min || inputNumber > max)
            {
                System.out.println("Неверный ввод");
                isInCorrect = true;
            }
        }
        while (isInCorrect);

        return inputNumber;
    }

    public static int inputIntWithText(String message, int min, int max)
    {
        int inputNumber;
        boolean isInCorrect;

        inputNumber = 0;

        do
        {
            System.out.printf(message + " от " + min + " до " + max + ": ");
            isInCorrect = false;
            try
            {
                inputNumber = Integer.parseInt(scanner.nextLine());
            }
            catch (NumberFormatException exception)
            {
                isInCorrect = true;
            }
            if (isInCorrect || inputNumber < min || inputNumber > max)
            {
                System.out.println("Неверный ввод");
                isInCorrect = true;
            }
        }
        while (isInCorrect);

        return inputNumber;
    }

    public static int[] inputArrayOfIntFromConsole(String message, int size, int min, int max)
    {
        boolean isInCorrect;
        int[] array;

        array = new int[size];

        for (int i = 0; i < size; i ++)
        {
            do
            {
                System.out.printf(message + " от " +  min + " до " + max + ": ");
                isInCorrect = false;
                try
                {
                    array[i] = Integer.parseInt(scanner.nextLine());
                }
                catch (NumberFormatException exception)
                {
                    isInCorrect = true;
                }
                if (isInCorrect || array[i] < min || array[i] > max)
                {
                    System.out.println("Неверный ввод");
                    isInCorrect = true;
                }
            }
            while (isInCorrect);
        }

        return array;
    }

    public static int[] ReadInputArray(int choose, int minSize, int maxSize, int min, int max)
    {
        String pathToFile = " ";
        int[] inputArray = new int[1];
        if(choose == 2)
        {
            String[] s;
            int[]array = new int[1];
            int size = 0;
            int counter = 0;
            boolean isInCorrect;
            try
            {
                pathToFile = getFileNormalReading();
            }
            catch (IOException exception)
            {
                exception.printStackTrace();
            }

            try (BufferedReader reader = new BufferedReader(new FileReader(pathToFile)))
            {
                isInCorrect = false;
                try
                {
                    size = Integer.parseInt(reader.readLine());
                }
                catch (NumberFormatException exception)
                {
                    isInCorrect = true;
                }
                if (isInCorrect || size < minSize || size > maxSize)
                {
                    System.out.println("Неверно введено количество точек первой числовой последовательности, введите через консоль: ");
                    size = inputIntFromConsole(minSize, maxSize);
                }

                inputArray = new int[size + 1];
                inputArray[0] = size;
                s = reader.readLine().split(" ");
                if(s.length == size)
                {
                    for (int i = 0; i < size; i ++)
                    {
                        isInCorrect = false;
                        try
                        {
                            inputArray[i + 1] = Integer.parseInt(s[i]);
                        }
                        catch (NumberFormatException exception)
                        {
                            isInCorrect = true;
                        }
                        if (isInCorrect || inputArray[i + 1] < min || inputArray[i + 1] > max)
                        {
                            System.out.println("Неверный ввод элемента первой числовой последовательности, введите через консоль: ");
                            array[i] = inputIntFromConsole(min, max);
                        }
                    }
                    isInCorrect = false;
                }

                if(s.length < size)
                {
                    int diver = size - s.length;
                    for (int i = 0; i < size - diver; i ++)
                    {
                        isInCorrect = false;
                        try
                        {
                            inputArray[i + 1] = Integer.parseInt(s[i]);
                        }
                        catch (NumberFormatException exception)
                        {
                            isInCorrect = true;
                        }
                        if (isInCorrect || inputArray[i + 1] < min || inputArray[i + 1] > max)
                        {
                            System.out.println("Неверный ввод элемента первой числовой последовательности, введите через консоль: ");
                            inputArray[i + 1] = inputIntFromConsole(min, max);
                        }
                    }
                    isInCorrect = false;
                    System.out.println("В файле не хватает элеметнов для массива");
                    for(int i = 0; i < diver; i ++)
                    {
                        System.out.print("Введите " + (i + s.length + 1) + " элемент массива: ");
                        inputArray[i + s.length + 1] = inputIntFromConsole(min, max);
                    }
                }
            }
            catch (IOException exception)
            {
                exception.printStackTrace();
            }
        }
        return inputArray;
    }

    public static int inputInt(int choose, int[] inputArray)
    {
        int inputNum = 0;
        if(choose == 1)
        {
            inputNum = inputIntWithText("Введите количество элементов числовой последовательности",1, 100);
        }
        else
        {
            inputNum = inputArray[0];
        }
        return inputNum;
    }

    public static int[] inputArrayOfInt(int choose, int[] inputArray, int size, int period)
    {
        int[] array = new int[size];
        if(choose == 1)
        {
            array = inputArrayOfIntFromConsole("Введите члены числовой последовательности",size, -10000, 10000);
        }
        else
        {
            if(period == 1)
            {
                for(int i = 0; i < size; i ++)
                    array[i] = inputArray[i + 2];
            }
            else
            {
                for(int i = 0; i < size; i ++)
                    array[i] = inputArray[i + 1];
            }

        }
        return array;
    }

    public static void printArray(int[] array)
    {
        for(int i = 0; i < array.length; i++)
        {
            System.out.print(array[i] + " ");
        }
    }

    public static void writeSolveToFile(String pathToFile, int[] array)
    {
        System.out.println("Полученная числовая последовательность записана в файл и равна: ");
        printArray(array);
        try (BufferedWriter fileWriter = new BufferedWriter(new FileWriter(pathToFile)))
        {
            fileWriter.write("Полученная числовая последовательность: ");
            for(int i = 0; i < array.length; i++)
            {
                fileWriter.write(array[i]);
            }
            fileWriter.close();
        }
        catch (IOException exception)
        {
            exception.printStackTrace();
        }
    }

    public static void output(int outputChoice, int[] array)
    {
        if (outputChoice == 1)
        {
            System.out.print("Полученная последовательность: ");
            printArray(array);
        }
        else if (outputChoice == 2)
        {
            String pathToFile = " ";
            try
            {
                pathToFile = getFileNormalWriting();
                writeSolveToFile(pathToFile, array);
            }
            catch (IOException exception)
            {
                exception.printStackTrace();
            }
        }
    }

    public static void merge(int[] arr, int left, int mid, int right) {
        int sizeL = mid - left + 1;
        int sizeR = right - mid;

        int[] leftArray = new int[sizeL];
        int[] rightArray = new int[sizeR];

        for (int i = 0; i < sizeL; i++)
            leftArray[i] = arr[left + i];
        for (int i = 0; i < sizeR; i++)
            rightArray[i] = arr[mid + 1 + i];

        int indexL = 0, indexR = 0, index = left;

        while (indexL < sizeL && indexR < sizeR) {
            arr[index++] = (leftArray[indexL] <= rightArray[indexR]) ? leftArray[indexL++] : rightArray[indexR++];
        }

        while (indexL < sizeL) {
            arr[index++] = leftArray[indexL++];
        }

        while (indexR < sizeR) {
            arr[index++] = rightArray[indexR++];
        }
    }

    public static void mergeSort(int[] arr, int size) {
        for (int currentSize = 1; currentSize < size; currentSize *= 2) {
            for (int leftStart = 0; leftStart < size - 1; leftStart += 2 * currentSize) {
                int mid = Math.min(leftStart + currentSize - 1, size - 1);
                int rightEnd = Math.min(leftStart + 2 * currentSize - 1, size - 1);

                merge(arr, leftStart, mid, rightEnd);
            }
        }
    }

    public static int chooseTheInput()
    {
        System.out.print("Выберите ввод из консоли(1) или из файла(2): ");
        return inputIntFromConsole(1, 2);
    }

    public static int chooseTheOutput()
    {
        System.out.print("Выберите вывод в консоль(1) или в файл(2): ");
        return inputIntFromConsole(1, 2);
    }

    public static void main(String[] args)
    {
        int size = 0;
        int inputChoose = 0;
        int outputChoose = 0;
        int[] array = new int[1];
        int[] inputArray = new int[1];

        printTask();
        inputChoose = chooseTheInput();
        inputArray = ReadInputArray(inputChoose, 2, 10, -10000, 10000);
        size = inputInt(inputChoose, inputArray);
        array = inputArrayOfInt(inputChoose, inputArray, size, 10000);
        mergeSort(array, size);
        outputChoose = chooseTheOutput();
        output(outputChoose, array);
        scanner.close();
    }
}