Lab.5.2.Full(Java)

//Main

import java.util.Scanner;
import java.io.*;
import java.util.concurrent.atomic.AtomicInteger;

public class Main
{
    private static final int MIN_SIZE = 2;
    private static final int MAX_SIZE = 10;
    private static final int MIN_VALUE = -99;
    private static final int MAX_VALUE = 99;
    private static final Scanner scan = new Scanner(System.in);
    static Tree binaryTree = new Tree();

    public static void outputTaskInfo() {
        System.out.println("Данная программа находит путь максимальной длины в бинарном дереве" + "\n" +
                "между вершинами с разным числом потомков." + "\n" +
                "Диапазон ввода значений размера последовательности: " + MIN_SIZE + "..." + MAX_SIZE + ". \n" +
                "Диапазон для ввода чисел: " + MIN_VALUE + "..." +  MAX_VALUE + ". \n" +
                "При подсчете максимального пути все ребра являются равновесными и равны 1.");
    }

    public static int getVerificationOfChoice() {
        int choice = 0;
        boolean isIncorrect;

        do {
            isIncorrect = false;
            try {
                choice = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Проверьте корректность ввода данных!");
                isIncorrect = true;
            }
            if (!isIncorrect && (choice != 0 && choice != 1)) {
                System.out.println("Для выбора введите 0 или 1!");
                isIncorrect = true;
            }
        } while (isIncorrect);

        return choice;
    }

    public static String inputPathToFile() {
        boolean isIncorrect;
        String path;

        System.out.println("Укажите путь к файлу: ");

        do {
            isIncorrect = false;
            path = scan.nextLine();
            File file = new File(path);

            if (!file.exists()) {
                System.out.println("По указанному пути файл не найден! Укажите правильный путь: ");
                isIncorrect = true;
            }
        } while (isIncorrect);

        return path;
    }

    public static int readSizeFromConsole(){
        int size = 0;
        boolean isIncorrect;

        System.out.println("Введите количество элементов дерева: ");

        do {
            isIncorrect = false;
            try {
                size = Integer.parseInt(scan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Проверьте корректность ввода данных!");
                isIncorrect = true;
            }
            if (!isIncorrect && (size < MIN_SIZE || size > MAX_SIZE)) {
                System.out.println("Введите число от " + MIN_SIZE + " до " + MAX_SIZE + "! \n");
                isIncorrect = true;
            }
        } while (isIncorrect);

        return size;
    }

    public static int readSizeFromFile(final String path) {
        int size;

        System.out.println("Происходит чтение количества элементов дерева... ");

        try (BufferedReader br = new BufferedReader(new FileReader(path))) {
            size = Integer.parseInt(br.readLine());
        } catch (Exception e) {
            System.out.println("Ошибка при чтении данных! Введите количество с консоли!");
            size = readSizeFromConsole();
        }

        return size;
    }

    public static void outputSizeInConsole(int size) {
        System.out.println("Количество элементов дерева равно: " + size + ".");
    }

    public static void outputSizeInFile(int size, String path) {
        boolean isIncorrect;
        System.out.println("Вывод количества элементов дерева в файл...");

        do {
            isIncorrect = false;
            try {
                FileWriter writer = new FileWriter(path);
                writer.write("Количесство элементов дерева: " + size + "\n");
                writer.close();
            } catch (IOException e) {
                isIncorrect = true;
                System.out.println("Ошибка! Измените параметры файла или укажите новую ссылку!");
                path = inputPathToFile();
            }
        } while (isIncorrect);

        System.out.println("Данные успешно записаны в файл!");
    }

    public static int[] fillSequenceFromConsole(final int size) {
        int[] sequence = new int[size];
        boolean isIncorrect;

        for (int i = 0; i < size; i++) {
            System.out.print("Введите значение " + (i + 1) + "-го элемента: ");

            do {
                isIncorrect = false;
                try {
                    sequence[i] = Integer.parseInt(scan.nextLine());
                } catch (NumberFormatException e) {
                    System.out.println("Проверьте корректность ввода данных!");
                    isIncorrect = true;
                }

                if (!isIncorrect && (sequence[i] < MIN_VALUE || sequence[i] > MAX_VALUE)) {
                    isIncorrect = true;
                    System.out.println("Введите число от " + MIN_VALUE + " до " + MAX_VALUE + "!");
                }
            } while (isIncorrect);
        }

        return sequence;
    }

    public static int[] fillSequenceFromFile(final int size, final String path) {
        int[] sequence = new int[size];
        System.out.println("Происходит чтение последовательности элементов...");

        try (BufferedReader fReader = new BufferedReader(new FileReader(path))){
            fReader.readLine();
            String[] integerInString = fReader.readLine().split(" ");
            for (int j = 0; j < size; j++)
                sequence[j] = Integer.parseInt(integerInString[j]);
        } catch (Exception e) {
            System.out.println("Ошибка при чтении последовательности! Введите последовательность с консоли!");
            sequence = fillSequenceFromConsole(size);
        }
        for (int j = 0; j < size; j++) {
            if (sequence[j] < MIN_VALUE || sequence[j] > MAX_VALUE) {
                System.out.println("Ошибка при считывании последовательности из файла!\nВведите последовательности с консоли!");
                sequence = fillSequenceFromConsole(size);
            }
        }

        return sequence;
    }

    public static void outputSequenceInConsole(final int[] sequence, final int size) {
        System.out.println("Вывод начальной последовательности элементов: ");
        for (int i = 0; i < size; i++)
            System.out.print(sequence[i] + " ");
        System.out.print("\n");
    }

    public static void outputSequenceInFile(String path, final int[] sequence, final int size){
        boolean isIncorrect;
        System.out.println("Вывод начальной последовательности элементов в файл...");

        do {
            isIncorrect = false;
            try {
                FileWriter writer = new FileWriter(path, true);
                BufferedWriter bufferWriter = new BufferedWriter(writer);

                bufferWriter.write("Начальная последовательность: ");
                for (int i = 0; i < size; i++)
                    bufferWriter.write(sequence[i] + " ");
                bufferWriter.write("\n");

                bufferWriter.close();
                writer.close();
            } catch (IOException e) {
                isIncorrect = true;
                System.out.println("Ошибка! Измените параметры файла или укажите новую ссылку!");
                path = inputPathToFile();
            }
        } while (isIncorrect);

        System.out.println("Данные успешно записаны в файл!");
    }

    private static void CreateTree(Tree tree, final int[] sequence) {
        for (int j : sequence) {
            tree.insertNode(j);
        }
    }

    public static int findMaxSumPath(Node root, AtomicInteger max_sum)
    {
        if (root == null) {
            return 0;
        }

        int left = findMaxSumPath(root.left, max_sum);

        int right = findMaxSumPath(root.right, max_sum);

        if (root.left == null) {
            return right + 1;
        }

        if (root.right == null) {
            return left + 1;
        }

        int cur_sum = left + right + 1;

        max_sum.set(Math.max(cur_sum, max_sum.get()));

        return Math.max(left, right) + 1;
    }

    public static int countNodes(Node root, int counter) {
        if (root != null) {
            counter = countNodes(root.left, counter) + 1 + countNodes(root.right, counter);
        }
        return counter;
    }
    public static int findMaxWay(Node root)
    {
        AtomicInteger max_sum = new AtomicInteger(Integer.MIN_VALUE);
        findMaxSumPath(root, max_sum);

        if (max_sum.get() != Integer.MIN_VALUE) {
            return max_sum.get() - 2;
        } else {
            return countNodes(root, 0) - 1;
        }
    }

    public static void outputMaxLengthInConsole(int maxLength) {
        System.out.println("Длина максимального пути равна: " + maxLength + ".");
    }

    public static void outputMaxLengthInFile(String path, int maxLength) {
        boolean isIncorrect;
        System.out.println("Вывод длины максимального пути в файл...");

        do {
            isIncorrect = false;
            try {
                FileWriter writer = new FileWriter(path, true);
                writer.write("Максимальный путь: " + maxLength + "\n");
                writer.close();
            } catch (IOException e) {
                isIncorrect = true;
                System.out.println("Ошибка! Измените параметры файла или укажите новую ссылку!");
                path = inputPathToFile();
            }
        } while (isIncorrect);

        System.out.println("Данные успешно записаны в файл!");
    }

    public static int[] processUserInput() {
        int size;
        int[] sequence = new int[0];
        int choiceForInput;
        String pathToIn;

        System.out.println("Вы желаете ввести данные с консоли(0) или взять данные из файла(1)?");
        choiceForInput = getVerificationOfChoice();

        if (choiceForInput == 0) {
            size = readSizeFromConsole();
            sequence = fillSequenceFromConsole(size);
        }
        if (choiceForInput == 1) {
            pathToIn = inputPathToFile();
            size = readSizeFromFile(pathToIn);
            sequence = fillSequenceFromFile(size, pathToIn);
        }

        return sequence;
    }

    public static void processUserOutput(final int size, final int[] sequence, final int maxLength) {
        int choiceForOutput;
        String pathToOut;

        System.out.println("Вы желаете получить результат в консоли(0) или в файле(1)?");
        choiceForOutput = getVerificationOfChoice();

        if (choiceForOutput == 0) {
            outputSizeInConsole(size);
            outputSequenceInConsole(sequence, size);
            outputMaxLengthInConsole(maxLength);
        }
        if (choiceForOutput == 1) {
            pathToOut = inputPathToFile();
            outputSizeInFile(size, pathToOut);
            outputSequenceInFile(pathToOut, sequence, size);
            outputMaxLengthInFile(pathToOut, maxLength);
        }
    }

    public static void main(String[] args)
    {
        outputTaskInfo();
        int[] sequence = processUserInput();
        CreateTree(binaryTree, sequence);
        int maxLength = findMaxWay(binaryTree.root);
        processUserOutput(sequence.length, sequence, maxLength);

        scan.close();
    }
}

//Tree

class Tree {
    public Node root;

    public Tree() {
        root = null;
    }

    public void insertNode(int value) {
        Node newNode = new Node();
        newNode.setValue(value);
        if (root == null) {
            root = newNode;
        } else {
            Node currentNode = root;
            Node parentNode;
            while (true) {
                parentNode = currentNode;
                if (value == currentNode.getValue()) {
                    return;
                } else if (value < currentNode.getValue()) {
                    currentNode = currentNode.getLeft();
                    if (currentNode == null) {
                        parentNode.setLeft(newNode);
                        return;
                    }
                } else {
                    currentNode = currentNode.getRight();
                    if (currentNode == null) {
                        parentNode.setRight(newNode);
                        return;
                    }
                }
            }
        }
    }
}

//Node

class Node {
    public int data;
    public Node left;
    public Node right;

    public Node() {
        right = null;
        left = null;
    }
    public int getValue() {
        return this.data;
    }

    public void setValue(final int value) {
        this.data = value;
    }

    public Node getLeft() {
        return this.left;
    }

    public void setLeft(final Node leftChild) {
        this.left = leftChild;
    }

    public Node getRight() {
        return this.right;
    }

    public void setRight(final Node rightChild) {
        this.right = rightChild;
    }
}