Lab5.2(Java)

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

public class Main {

    static Scanner scanner = new Scanner(System.in);
    public static boolean exit = false;
    public static Tree tree = new Tree();
    public static ArrayList<Integer> keys = new ArrayList<>();
    public static void main (String[] args) throws IOException{
        System.out.println("Эта программа демонстрирует дерево как структуру данных.");
        while (!exit) {
            showInfo();
            chooseAction();
        }
    }

    public static void showInfo () {
        System.out.println("1 - создать пустое дерево");
        System.out.println("2 - добавить новый элемент в дерево");
        System.out.println("3 - удалить элемент из дерева");
        System.out.println("4 - просмотреть дерево");
        System.out.println("5 - открыть дерево из файла");
        System.out.println("6 - сохранить дерево в файл");
        System.out.println("7 - Выход");
    }
    private static int inputData() {
        int n = 0;
        boolean isIncorrect;
        final int MIN_SIZE = 1;
        do {
            isIncorrect = false;
            try {
                n = Integer.parseInt(scanner.nextLine());
            } catch (Exception e) {
                isIncorrect = true;
                System.out.println("Пожалуйста, введите целое число");
            }
            if (n < MIN_SIZE && !isIncorrect) {
                System.out.println("Пожалуйста, введите положительное число");
                isIncorrect = true;
            }
        } while (isIncorrect);
        return n;
    }

    private static int inputKey() {
        int n = 0;
        boolean isIncorrect;
        do {
            isIncorrect = false;
            try {
                n = Integer.parseInt(scanner.nextLine());
            } catch (Exception e) {
                isIncorrect = true;
                System.out.println("Пожалуйста, введите целое число");
            }
        } while (isIncorrect);
        return n;
    }

    public static void chooseAction () throws IOException {
        int chose;
        boolean isIncorrect;
        final int MAX = 8;
        System.out.println("Пожалуйста, выберите:");

        do {
            chose = inputData();
            isIncorrect = false;
            if ((chose > MAX) || (chose < 1)) {
                isIncorrect = true;
                System.out.println("Пожалуйста, введите правильный номер функции.");
            }
        } while (isIncorrect);

        switch (chose) {
            case 1 -> buildTree();
            case 2 -> addNode();
            case 3 -> removeNode();
            case 4 -> showTree();
            case 5 -> openFile();
            case 6 -> saveData();
            case 7 -> exit = true;
        }
    }

    public static void buildTree () {
        tree.createTree();
        System.out.println("Готово!");
        System.out.println(); // просто пустая строка для удобства чтения
    }

    public static boolean checkExistenceOrUniqueness (int nodeToDelete) {
        for (Integer key : keys) {
            if (nodeToDelete == key) {
                return true;
            }
        }
        return false;
    }

    public static boolean checkUniqueness (int[] keysFromFile) {
        for (int i = 0; i < keysFromFile.length; i++){
            for (int j = i + 1; j < keysFromFile.length; j++){
                if (keysFromFile[i] == keysFromFile[j]) {
                    System.out.println("В вашем файле есть повторения. Измените исходные данные.");
                    return false;
                }
            }
        }
        for (int i = 0; i < keysFromFile.length; i++) {
            if (keys.contains(keysFromFile[i])) {
                System.out.println("Элемент, которого пытаются добавить, уже существует. Измените исходные данные.");
                return false;
            }
        }
        return true;
    }

    public static void addNode () {
        System.out.println("Входной узел:");
        int node = inputKey();
        if (checkExistenceOrUniqueness(node)) {
            System.out.println("К сожалению, невозможно добавить узел, который уже существует. Введите снова");
        } else {
            tree.addNode(node);
            keys.add(node);
            System.out.println("Узел \"" + node +"\" добавлен.");
        }
        System.out.println(); // просто пустая строка для удобства чтения
    }

    public static void removeNode () {
        System.out.println("Введите элемент для удаления.");
        int nodeToDelete = inputKey();
        int index;
        if (tree.getRoot() != null) {
            if (checkExistenceOrUniqueness(nodeToDelete)) {
                tree.deleteNode(nodeToDelete);
                index = keys.indexOf(nodeToDelete);
                keys.remove(index);
                System.out.println("Готово!");
            } else
                System.out.println("Такого узла не существует.");
        } else {
            System.out.println("Дерево пустое.");
        }
        System.out.println(); // просто пустая строка для удобства чтения
    }

    public static void showTree () {
        String text = "";
        if (tree.getRoot() != null) {
            System.out.println("Для улучшения работы пользователя поверните монитор по часовой стрелке)");
            Tree root = tree.getRoot();
            tree.printTree(root, 0, text);
            System.out.println("Номера вершин: " + tree.string);
            tree.string = "";
        } else {
            System.out.println("Дерево пустое.");
        }
        System.out.println(); // просто пустая строка для удобства чтения
    }

    public static String inputFilePath() {
        String path;
        boolean isIncorrect;
        do {
            isIncorrect = false;
            System.out.println("Введите путь к файлу:");
            path = scanner.nextLine();
            File file = new File(path);
            if (!file.exists()) {
                System.out.println("Неправильный путь к файлу");
                isIncorrect = true;
            }
            if (!file.canRead() && file.exists()) {
                System.out.println("Невозможно прочитать из файла.");
                isIncorrect = true;
            }
            if (!file.canWrite() && file.canRead()) {
                System.out.println("Невозможно записать в файл.");
                isIncorrect = true;
            }
        } while (isIncorrect);
        return path;
    }

    public static String[] deleteSpacesInArray (String[] keys) {
        int counterOfSpaces = 0;
        for (int j = 0; j < keys.length; j++) {
            if (!Objects.equals(keys[j], "")) {
                counterOfSpaces++;
            }
        }
        int i = 0;
        String[] newArr = new String[counterOfSpaces];
        for (int j = 0; j < keys.length; j++) {
            if (!Objects.equals(keys[j], "")) {
                newArr[i] = keys[j];
                i++;
            }
        }
        return newArr;
    }
    public static boolean checkArrayOfStrings (String[] keys) {
        for (int j = 0; j < keys.length; j++){
            try {
                Integer.parseInt(keys[j]);
            } catch (Exception e) {
                System.out.println("Проверьте файл, он не должен содержать ничего, кроме цифр.");
                return false;
            }
        }
        return true;
    }

    public static int[] getArrOfKeys (String[] keys) {
        int[] keysFromFile = new int[keys.length];
        for (int j = 0; j < keys.length; j++) {
            keysFromFile[j] = Integer.parseInt(keys[j]);
        }
        return keysFromFile;
    }
    public static void openFile () {
        System.out.println("Пример строки с узлами дерева:");
        System.out.println("узел1 - узел2 - узел3 - ... - узелN");
        System.out.println("P.S. после каждой позиции ожидается только пробел. Узлы из файла будут добавлены в существующее дерево.");
        String path = inputFilePath();
        String str;
        String[] mas;
        try {
            Scanner fileReader = new Scanner(new File(path));
            str = fileReader.nextLine();
            mas = str.split(" ");
            mas = deleteSpacesInArray(mas);
            if (checkArrayOfStrings(mas)) {
                int[] keysFromFile = getArrOfKeys(mas);
                if (checkUniqueness(keysFromFile)) {
                    for (int j = 0; j < keysFromFile.length; j++) {
                        tree.addNode(keysFromFile[j]);
                        keys.add(keysFromFile[j]);
                    }
                    System.out.println("Готово!");
                }
            }
        } catch (Exception q) {
            System.out.println("Что-то пошло не так, проверьте файл.");
        }
    }
    public static void saveData () throws IOException {
        if (tree.getRoot() != null) {
            String path = inputFilePath();
            FileWriter writer = new FileWriter(path);
            String result = "";
            for (Integer key: keys) {
                result = result + key + " ";
            }
            writer.write(result);
            writer.close();
            System.out.println("Готово!");
        } else {
            System.out.println("Дерево пусто, добавьте несколько узлов!");
        }
    }
}


public class Tree {

    public String string = "";
    private int key;
    private Tree leftChild;
    private Tree rightChild;

    public static Tree rootNode;

    public Tree getRoot() {
        return rootNode;
    }

    public int getKey() {
        return this.key;
    }

    public void setKey(final int key) {
        this.key = key;
    }

    public Tree getLeftChild() {
        return this.leftChild;
    }

    public void setLeftChild(final Tree leftChild) {
        this.leftChild = leftChild;
    }

    public Tree getRightChild() {
        return this.rightChild;
    }

    public void setRightChild(final Tree rightChild) {
        this.rightChild = rightChild;
    }

    public void createTree() {
        rootNode = null;
    }

    public void addNode(int key) {
        Tree newNode = new Tree();
        newNode.setKey(key);
        if (rootNode == null) {
            rootNode = newNode;
        } else {
            Tree currentNode = rootNode;
            Tree parentNode;
            while (true) {
                parentNode = currentNode;
                if (key == currentNode.getKey()) {
                    return;
                } else if (key < currentNode.getKey()) {
                    currentNode = currentNode.getLeftChild();
                    if (currentNode == null) {
                        parentNode.setLeftChild(newNode);
                        return;
                    }
                } else {
                    currentNode = currentNode.getRightChild();
                    if (currentNode == null) {
                        parentNode.setRightChild(newNode);
                        return;
                    }
                }
            }
        }
    }

    public void deleteNode(int value) {
        Tree currentNode = rootNode;
        Tree parentNode = rootNode;
        boolean isLeftChild = true;
        while (currentNode.getKey() != value) {
            parentNode = currentNode;
            if (value < currentNode.getKey()) {
                isLeftChild = true;
                currentNode = currentNode.getLeftChild();
            }
            else {
                isLeftChild = false;
                currentNode = currentNode.getRightChild();
            }
        }

        if (currentNode.getLeftChild() == null && currentNode.getRightChild() == null) {
            if (currentNode == rootNode)
                rootNode = null;
            else if (isLeftChild)
                parentNode.setLeftChild(null);
            else
                parentNode.setRightChild(null);
        }
        else if (currentNode.getRightChild() == null) {
            if (currentNode == rootNode)
                rootNode = currentNode.getLeftChild();
            else if (isLeftChild)
                parentNode.setLeftChild(currentNode.getLeftChild());
            else
                parentNode.setRightChild(currentNode.getLeftChild());
        }
        else if (currentNode.getLeftChild() == null) {
            if (currentNode == rootNode)
                rootNode = currentNode.getRightChild();
            else if (isLeftChild)
                parentNode.setLeftChild(currentNode.getRightChild());
            else
                parentNode.setRightChild(currentNode.getRightChild());
        }
        else {
            Tree successor = getSuccessor(currentNode);
            if (currentNode == rootNode)
                rootNode = successor;
            else if (isLeftChild)
                parentNode.setLeftChild(successor);
            else
                parentNode.setRightChild(successor);
        }
    }

    private Tree getSuccessor(Tree deleteNode) {
        Tree successorParent = deleteNode;
        Tree successor = deleteNode;
        Tree current = deleteNode.getRightChild();
        while (current != null) {
            successorParent = successor;
            successor = current;
            current = current.getLeftChild();
        }
        if (successor != deleteNode.getRightChild()) {
            successorParent.setLeftChild(successor.getRightChild());
            successor.setRightChild(deleteNode.getRightChild());
        }
        successor.setLeftChild(deleteNode.getLeftChild());
        return successor;
    }

    public static int height(Tree node) {
        if (node == null) {
            return 0;
        }

        if ((node.getLeftChild() != null && node.getLeftChild().getRightChild() == node) && (node.getRightChild() != null && node.getRightChild().getLeftChild() == node)) {
            return 1;
        }

        return 1 + Math.max(height(node.getLeftChild()), height(node.getRightChild()));
    }

    public void printTree(Tree node, int level, String text) {

        if (node == null) {
            return;
        }
        printTree(node.getRightChild(), level + 1, text);
        for (int i = 0; i < level; i++) {
            System.out.print("    ");
        }
        System.out.println(node.getKey());
        if (height(node.getLeftChild()) != height(node.getRightChild())) {
            text = text + node.getKey() + ' ';
            string = string + text;
        }
        printTree(node.getLeftChild(), level + 1, text);
    }
}