Lab5.2Java

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.util.NoSuchElementException;
import java.util.Scanner;

class List {
    List next;
    Node record;

    public List(Node record) {
        this.record = record;
    }
}
class Node {
    public int data;
    public Node nextLeft;
    public Node nextRight;

    public Node(int n){
        this.data = n;
        this.nextLeft = null;
        this.nextRight = null;
    }

}

class Trunk {
    Trunk prev;
    String str;

    Trunk(Trunk prev, String str) {
        this.prev = prev;
        this.str = str;
    }
}

public class Main {
    private static List reversedPath = null, leftPathList = null, rightPathList = null, normalMaxPath = null, currList = null;
    private static final Scanner consoleScan = new Scanner(System.in);
    static Node treeFirst = null;

    static int maxLength = 0, counter = 0;

    public static void showTrunks(Trunk trunk)
    {
        if (trunk == null) {
            return;
        }

        showTrunks(trunk.prev);
        System.out.print(trunk.str);
    }
    public static void printTree(Node root, Trunk prev, boolean isLeft)
    {
        if (root == null) {
            return;
        }

        String prev_str = "    ";
        Trunk trunk = new Trunk(prev, prev_str);

        printTree(root.nextRight, trunk, true);

        if (prev == null) {
            trunk.str = "———";
        }
        else if (isLeft) {
            trunk.str = ".———";
            prev_str = "   |";
        }
        else {
            trunk.str = "`———";
            prev.str = prev_str;
        }

        showTrunks(trunk);
        System.out.println(" " + root.data);

        if (prev != null) {
            prev.str = prev_str;
        }
        trunk.str = "   |";

        printTree(root.nextLeft, trunk, false);
    }

    public static void outputInFile(File outputFile) {
        boolean isFileIncorrect = false;
        String res = treeToString(treeFirst);
        res = res.substring(0,res.length() - 2);
        do {
            try {
                if (outputFile.isFile()) {
                    if (outputFile.canWrite()) {
                        try (FileWriter writer = new FileWriter(outputFile)) {
                            if (treeFirst != null) {
                                writer.write(res);
                            } else {
                                writer.write("Пустое дерево\n");
                            }
                        }
                    } else {
                        System.out.println("В файл не возможно записать");
                        isFileIncorrect = true;
                    }
                } else {
                    outputFile.createNewFile();
                    try (FileWriter writer = new FileWriter(outputFile)) {
                        writer.write("Результат:\n");
                        if (treeFirst != null) {
                            writer.write(treeToString(treeFirst));
                        } else {
                            writer.write("Пустое дерево\n");
                        }
                    }
                }
            } catch (IOException e) {
                System.out.println("Не удалось вывести в файл");
            }
        } while (isFileIncorrect);
    }


    public static boolean checkFile(File file) {
        final int MIN_VALUE = 1, MAX_VALUE = 20;
        int n, i;
        boolean isFileIncorrect = false;
        if (!file.isFile()) {
            System.out.println("Файла по данному пути не существует. Пожалуйста проверьте существование файла и введите путь заново");
                    isFileIncorrect = true;
        }
        if (!isFileIncorrect && !file.canRead()) {
            System.out.println("Файл по данному пути не может быть прочитан. Пожалуйста проверьте файл и введите путь заново");
                    isFileIncorrect = true;
        }
        if (!isFileIncorrect) {
            try (Scanner fileScan = new Scanner(file)) {
                i = 0;
                while (fileScan.hasNext() && i < 20){
                    n = fileScan.nextInt();
                    if (n > MAX_VALUE || n < MIN_VALUE) {
                        System.out.println("В файле данные выходят за пределы допустимых значений. Пожалуйста проверьте файл и введите путь заново");
                                isFileIncorrect = true;
                    }
                    i++;
                }
                if (!isFileIncorrect && fileScan.hasNext()) {
                    System.out.println("В файле данные представлены в неправильном формате. Пожалуйста проверьте файл и введите путь заново");
                            isFileIncorrect = true;
                }

            } catch (FileNotFoundException e) {
                System.out.println("Файл по данному пути не существует. Пожалуйста проверьте файл и введите путь заново");
                        isFileIncorrect = true;
            } catch (NoSuchElementException e) {
                System.out.println("В файле данные представлены в неправильном формате. Пожалуйста проверьте файл и введите путь заново");
                        isFileIncorrect = true;
            }
        }
        return isFileIncorrect;
    }

    public static int findLongestPath(Node treeStart, List pathList) {
        if (treeStart == null) {
            return 0;
        } else {
            leftPathList = new List(null);
            rightPathList = new List(null);

            int leftPathLength = findLongestPath(treeStart.nextLeft, leftPathList);
            int rightPathLength = findLongestPath(treeStart.nextRight, rightPathList);

            int res;
            if (leftPathLength > rightPathLength) {
                reversedPath = leftPathList;
                rightPathList = leftPathList;
                addElementToList(reversedPath, treeStart);
                res = leftPathLength + 1;
            } else {
                reversedPath = rightPathList;
                leftPathList = rightPathList;
                addElementToList(reversedPath, treeStart);
                res = rightPathLength + 1;
            }

            return res;
        }
    }

    public static String treeToString(Node treeStart){
        String ans = "";
        if (treeStart != null){
            ans += treeStart.data + " ";
            ans += treeToString(treeStart.nextLeft);
            ans += treeToString(treeStart.nextRight);
        }
        return ans;
    }
    public static void inputFromFile(File file) {
        int n = 0;
        try (Scanner fileScan = new Scanner(file)) {
            while (fileScan.hasNext()) {
                n = fileScan.nextInt();
                treeFirst = add(n, treeFirst);
            }
        } catch (IOException e) {
            System.out.println("Не удалось считать файл");
        }
    }

    public static int menu() {
        System.out.print("""
                ______________________________________________
                1.Создать пустое дерево.
                2.Добавить элемент в дерево.
                3.Найти максимальный путь в дереве и отзеркалить дерево относительно этого пути
                4.Импортировать дерево из файла.
                5.Сохранить в файл текущее дерево.
                6.Закончить.
                ______________________________________________
                Введите номер пункта меню в который хотите попасть:
                """);
        return inputInt(1, 6);
    }

    public static int inputInt(int min, int max) {
        int num = 0;
        boolean isNotCorrect;
        do {
            isNotCorrect = false;
            System.out.print("Введите число: ");
            try {
                num = Integer.parseInt(consoleScan.nextLine());
            } catch (NumberFormatException e) {
                System.out.println("Вы ввели некорректные данные. Попробуйте снова.");
                        isNotCorrect = true;
            }
            if (!isNotCorrect && (num < min || num > max)) {
                System.out.println("Введено значение не входящее в диапазон допустимых значений");
                        isNotCorrect = true;
            }
        } while (isNotCorrect);
        return num;
    }

    public static Node makeEmptyNode() {
        return null;
    }

    public static Node get(List list, int index) {
        List current = list;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current.record;
    }

    private static List reverseList (List list){
        List reversList;

        reversList = new List(null);

        for (int i = counter; i > 0; i-- ) {
            addElementToList(reversList, get(list, i));
        }

        return reversList;
    }

    public static void addElementToList(List pathList, Node newNode) {
        List current = pathList;
        while (current.next != null) {
            current = current.next;
        }
        current.next = new List(newNode);
    }
    public static void swapChildren(Node treeStart) {
        if (treeStart != null) {
            Node temp = treeStart.nextLeft;
            treeStart.nextLeft = treeStart.nextRight;
            treeStart.nextRight = temp;
        }
    }
    public static boolean isNodeInList(List list, Node treeStart){
        boolean res;
        res = false;
        while ((list.next != null) && (!res)){
            list = list.next;
            if (list.record == treeStart) {
                res = true;
            }
        }
        return res;
    }
    public static void mirrorTreeRelativeToPath(Node treeStart, List pathList) {
        if (treeStart != null) {
            mirrorTreeRelativeToPath(treeStart.nextLeft, pathList);
            mirrorTreeRelativeToPath(treeStart.nextRight, pathList);

            if (isNodeInList(pathList, treeStart)) {
                swapChildren(treeStart);
            }
        }
    }
    public static Node add(int n, Node treeStart) {
        if (treeStart != null) {
            if (treeStart.data > n) {
                treeStart.nextLeft = add(n, treeStart.nextLeft);
            } else if (treeStart.data < n) {
                treeStart.nextRight = add(n, treeStart.nextRight);
            }
        } else {
            treeStart = new Node(n);
        }
        return treeStart;
    }

    public static void main(String[] args) {
        int choice;
        System.out.println("Программа создаёт бинарное дерево.\n" + "Диапазон значений элементов дерева - от 1 до 10.");
        do {
            choice = menu();
            switch (choice) {
                case 1:
                    treeFirst = makeEmptyNode();
                    printTree(treeFirst, null, false);
                    break;
                case 2:
                    System.out.println("Введите элемент, который хотите добавить в дерево (1-20)");
                    int m = inputInt(1, 20);
                    treeFirst = add(m, treeFirst);
                    printTree(treeFirst, null, true);
                    break;
                case 3:
                    counter = findLongestPath(treeFirst, reversedPath);

                    if (counter > 0){
                        System.out.println("Длина максимального пути " + counter);
                        normalMaxPath = reverseList(reversedPath);
                        currList = normalMaxPath;
                        while (currList.next != null) {
                            System.out.print(currList.next.record.data + " ");
                            currList =  currList.next;
                        }
                        System.out.println();
                        mirrorTreeRelativeToPath(treeFirst, normalMaxPath);
                        printTree(treeFirst, null, true);
                    } else{
                        System.out.println("Максимального пути не существует");
                    }
                    counter = 0;
                    reversedPath = null;
                    normalMaxPath = null;
                    break;
                case 4:
                    boolean isFileIncorrect;
                    String filePath;
                    File inputFile;
                    do {
                        System.out.println("При вводе из файла убедитесь, что каждый узел дерева(1-20) записан в отдельной строке,");
                        System.out.println("Введите путь к файлу с расширением");
                        filePath = consoleScan.nextLine();
                        inputFile = new File(filePath);
                        isFileIncorrect = checkFile(inputFile);
                    } while (isFileIncorrect);
                    inputFromFile(inputFile);
                    printTree(treeFirst, null, false);
                    break;
                case 5:
                    System.out.println("Введите путь к файлу с расширением");
                    filePath = consoleScan.nextLine();
                    File outputFile = new File(filePath);
                    isFileIncorrect = false;
                    if (!outputFile.isFile()) {
                        System.out.println("Файла по данному пути не существует. Пожалуйста проверьте существование файла и введите путь заново");
                        isFileIncorrect = true;
                    }
                    if (!isFileIncorrect && !outputFile.canWrite()) {
                        System.out.println("Файл по данному пути не может быть перезаписан. Пожалуйста проверьте файл и введите путь заново");
                        isFileIncorrect = true;
                    }
                    if (!isFileIncorrect) {
                        outputInFile(outputFile);
                    }
                    break;
            }
        } while (choice != 6);
        consoleScan.close();
    }
}