laba_5_2_java

package com.company;

import java.io.*;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    private static final String REG_EX_PATH_TO_TXT_FILE = ".+\\.txt|^$";
    private static final String REG_EX_FOR_LINE_OF_NUMBERS = "^\\s*(0*[1-9]\\d{0,2}\\b\\s*)+$";
    private static final String REG_EX_FOR_NUMBER = "[1-9]\\d{0,2}";
    private static final String ASK_PATH_TO_FILE = "Введите путь к файлу. (Нажмите Enter для отмены ввода)";
    private static final String CLARIFICATION_ASK_PATH_TO_FILE = "Введите абсолютный путь к текстовому файлу (.txt).";

    private static Scanner scConsole;

    private static final MyTree myTree = new MyTree();
    private static String inputStr;
    private static String answerStr;

    private static short choose(String sQuestion, String[] Options) { // не больше 9-ти вариантов ответа
        short nChoice;
        String answer;
        StringBuilder optionsDigits = new StringBuilder();

        System.out.println(sQuestion + "\n\tВарианты: ");
        for (int i = 0; i < Options.length; i++) {
            System.out.println("\t" + (i + 1) + " - " + Options[i]);
            optionsDigits.append(i + 1);
        }

        answer = getAnythingFromConsole("", "^[" + optionsDigits + "]$", "Нужно ввести " +
                "цифру (одну из предложенных).");
        nChoice = (short) (Short.parseShort(answer) - 1);

        return nChoice;
    }

    private static String getAnythingFromConsole(String Question, String regEx, String clarification) {
        String sInput;
        String sOutput;
        final String stringIfNothingIsFoundInString = "";
        boolean nothingIsFoundIsNotAllowed = findRegEx(regEx, "\\^\\$", "")[0].equals("");

        if (!Question.equals("")) {
            System.out.println(Question);
        }

        do {
            sInput = scConsole.nextLine().trim();
            sOutput = findRegEx(sInput, regEx, stringIfNothingIsFoundInString)[0];
            if (sOutput.equals(stringIfNothingIsFoundInString) && nothingIsFoundIsNotAllowed) {
                System.err.println("Данные введены неверно. " + clarification + "\nПовторите попытку:");
            }
        } while (sOutput.equals(stringIfNothingIsFoundInString) && nothingIsFoundIsNotAllowed);

        System.out.println();
        return sOutput;
    }

    private static String[] findRegEx(String sInput, String regEx, String outputIfNothingFound) {
        ArrayList<String> arrStringOutput = new ArrayList<>();
        Pattern pattern = Pattern.compile(regEx);
        Matcher matcher = pattern.matcher(sInput);

        if (matcher.find()) {
            do {
                arrStringOutput.add(matcher.group());
            } while (matcher.find());
        } else
            arrStringOutput.add(outputIfNothingFound);

        return arrStringOutput.toArray(new String[0]);
    }

    private static void createNewTree() {
        myTree.clear();

        inputStr = getAnythingFromConsole("Введите список (числа через пробел).", REG_EX_FOR_LINE_OF_NUMBERS, "Надо ввести числа (от 1 до 999) через пробел.");
        String[] inputs = findRegEx(inputStr, REG_EX_FOR_NUMBER, "");
        for (String oneStr : inputs) {
            myTree.addNode(Integer.parseInt(oneStr));
        }
    }

    private static boolean exportDataFromFile() {
        final String MES_INPUT_DONE = "Данные успешно импортированы.\n";
        final String ERROR_COULD_NOT_OPEN_OR_READ_FILE = "Ошибка. Не удалось открыть или прочитать " +
                "текстовый файл в заданной Вами директории.";

        boolean isNotCorrect = true;
        boolean processIsNotAborted = true;

        myTree.clear();

        do {
            String sPathToFile = getAnythingFromConsole(ASK_PATH_TO_FILE, REG_EX_PATH_TO_TXT_FILE,
                    CLARIFICATION_ASK_PATH_TO_FILE);

            if (sPathToFile.equals("")) {
                processIsNotAborted = false;
            } else {
                try (BufferedReader bufferedReader = new BufferedReader(new FileReader(new File(sPathToFile)))) {
                    String temp;
                    boolean isCorrect = true;

                    temp = bufferedReader.readLine();
                    if (temp == null || findRegEx(temp, REG_EX_FOR_LINE_OF_NUMBERS, "")[0].equals("")) {
                        System.out.println("Ошибка. Как минимум одна строка в файле записана неверно. " +
                                "Не удалось импортировать данные.");
                        isCorrect = false;
                    } else {
                        String[] inputs = findRegEx(temp, REG_EX_FOR_NUMBER, "");
                        for (String oneStr : inputs) {
                            myTree.addNode(Integer.parseInt(oneStr));
                        }
                    }
                    inputStr = temp;

                    if (isCorrect) {
                        isNotCorrect = false;
                        System.out.println(MES_INPUT_DONE);
                    }
                } catch (java.io.IOException e) {
                    System.out.println(ERROR_COULD_NOT_OPEN_OR_READ_FILE);
                }
            }
        } while (isNotCorrect && processIsNotAborted);
        return processIsNotAborted;
    }

    private static void saveToFile() {
        final String MES_OUTPUT_DONE = "Данные успешно записаны в файл.\n";
        final String ERROR_COULD_NOT_OPEN_OR_CREATE_OR_WRITE_FILE = "Ошибка. Не удалось создать, открыть или записать " +
                "текстовый файл в заданной Вами директории.";
        String sPathToFile;
        boolean isNotCorrect = true;
        boolean processIsNotAborted = true;
        do {
            sPathToFile = getAnythingFromConsole(ASK_PATH_TO_FILE, REG_EX_PATH_TO_TXT_FILE,
                    CLARIFICATION_ASK_PATH_TO_FILE);
            if (sPathToFile.equals("")) {
                processIsNotAborted = false;
            } else {
                if (Files.exists(Paths.get(sPathToFile)) && choose("Файл \"" + sPathToFile +
                        "\" уже существует.\n" + "Вы уверены, что хотите перезаписать файл? Все текущие данные в этом " +
                        "файле будут безвозвратно утеряны.", new String[]{"да, перезаписать файл.",
                        "нет, выбрать другой файл."}) == 0) {
                    try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(new File(sPathToFile)))) {
                        bufferedWriter.append("Входной список: \n").append(inputStr).append("\nОтвет:\n").append(answerStr);

                        isNotCorrect = false;
                        System.out.println(MES_OUTPUT_DONE);
                    } catch (java.io.IOException e) {
                        System.out.println(ERROR_COULD_NOT_OPEN_OR_CREATE_OR_WRITE_FILE);
                    }
                }
            }
        } while (isNotCorrect && processIsNotAborted);
    }

    private static void outputAnswer() {
        answerStr = "";
        int heightOfTree = MyTree.countHeightOfTree(myTree.getHeadNode());

        int lineNumber = 1;
        int margin = (int) Math.round(Math.pow(2, heightOfTree)) - 2;
        String oneLine;

        while (lineNumber < heightOfTree + 1) {
            oneLine = getOneLineOfOutput(margin, lineNumber);

            answerStr = answerStr + "\n" + oneLine;
            margin = Math.round((float) margin / 2) - 1;
            lineNumber++;
        }

        System.out.println(answerStr);

        short answerOnQuestion = choose("Хотите вывести ответ в файл?",
                new String[]{"да", "нет"});
        if (answerOnQuestion == 0) {
            saveToFile();
        }
    }

    private static String getOneLineOfOutput(int margin, int lineNumber) {
        StringBuilder oneLine = new StringBuilder();
        oneLine.setLength(0);
        if (margin > 0) {
            oneLine.append(String.format(String.format("%%%ds", margin), ""));
        }
        int[] numbersOnLine = MyTree.getNumbersOnLine(myTree.getHeadNode(), lineNumber);

        for (int num : numbersOnLine) {
            oneLine.append(String.format("%3s", findRegEx(Integer.toString(num), "[1-9]\\d*", "")[0])).append(String.format(String.format("%%%ds", margin * 2 + 1), ""));
        }

        return oneLine.toString();
    }

    private static void showHelp() {
        short answerOnQuestion;
        do {
            answerOnQuestion = choose("Справка", new String[]{"о программе", "задание", "автор", "назад"});
            switch (answerOnQuestion) {
                case 0 -> System.out.println("О программе:\n" +
                        "\tВы можете вводить числа для создания дерева вручную.\n" +
                        "\tВы также можете импортировать данные из файла и экспортировать ответв файл.\n");
                case 1 -> System.out.println("Задание:\n\tИз текстового файла TREE.TXT вводится ряд чисел, " +
                        "представляющих собой коды работников фирмы.\n\tПервым в этом списке код руководителя фирмы, " +
                        "далее коды его  подчиненных, подчиненных этих подчиненных и т.д.\n\tУ каждого сотрудника в " +
                        "непосредственном подчинении может быть не больше двух подчиненных.\n\tЕсли код очередного " +
                        "сотрудника меньше кода его непосредственного начальника, то он располагается слева " +
                        "от своего начальника, иначе справа.\n");
                case 2 -> System.out.println("Автор:\n\tПанев Александр, гр. 051007\n\tМинск, 2021\n");
            }
        } while (answerOnQuestion != 3);
    }

    private static void mainMenu() {
        short answerOnQuestion;
        do {
            answerOnQuestion = choose("Главное меню",
                    new String[]{"ввести список", "открыть имеющийся список из файла", "показать справку", "закрыть программу"});
            switch (answerOnQuestion) {
                case 0 -> {
                    createNewTree();
                    outputAnswer();
                }
                case 1 -> {
                    if (exportDataFromFile()) {
                        outputAnswer();
                    }
                }
                case 2 -> showHelp();
            }
        } while (answerOnQuestion != 3);
    }

    public static void main(String[] args) {
        scConsole = new Scanner(System.in);

        // /Users/sasha/Documents/___Университет/ОАиП/Пз/Лабы/блок 5/input.txt
        // /Users/sasha/Documents/___Университет/ОАиП/Пз/Лабы/блок 5/output.txt

        mainMenu();
        System.out.println("До свидания");

        scConsole.close();
    }
}











package com.company;

import java.util.Arrays;

public class MyTree {
    private MyNode headNode;

    public MyTree() {
        headNode = null;
    }

    public void addNode(int data) {
        boolean sameNotFound = true;

        if (headNode == null) {
            headNode = new MyNode(data);
        } else {
            MyNode nextNode = null;
            MyNode currentNode = headNode;
            do {
                if (data < currentNode.data) {
                    nextNode = currentNode.nextSmaller;
                } else if (data > currentNode.data) {
                    nextNode = currentNode.nextBigger;
                } else {
                    sameNotFound = false;
                }
                if (sameNotFound && nextNode != null) {
                    currentNode = nextNode;
                }
            } while (nextNode != null && sameNotFound);

            if (sameNotFound) {
                if (data < currentNode.data) {
                    currentNode.nextSmaller = new MyNode(data);
                } else {
                    currentNode.nextBigger = new MyNode(data);
                }
            }
        }
    }

    public void clear() {
        headNode = null;
    }

    public static int countHeightOfTree(MyNode headNode) {
        int heightOfTree = 0;

        if (headNode != null) {
            int heightFromLeft = 0;
            int heightFromRight = 0;

            if (headNode.nextSmaller != null) {
                heightFromLeft = countHeightOfTree(headNode.nextSmaller);
            }
            if (headNode.nextBigger != null) {
                heightFromRight = countHeightOfTree(headNode.nextBigger);
            }
            heightOfTree = Math.max(heightFromRight, heightFromLeft) + 1;
        }

        return heightOfTree;
    }

    public static int[] getNumbersOnLine(MyNode headNode, int lineQuantity) {
        int[] numbersOnLine = new int[(int) Math.round(Math.pow(2, lineQuantity - 1))];
        int[] numbersOnLineFromLeft;
        int[] numbersOnLineFromRight;

        if (lineQuantity == 1) {
            numbersOnLine[0] = headNode.data;
        } else {
            if (headNode.nextSmaller != null) {
                numbersOnLineFromLeft = getNumbersOnLine(headNode.nextSmaller, lineQuantity - 1);
            } else {
                numbersOnLineFromLeft = new int[(int) Math.round(Math.pow(2, lineQuantity - 2))];
                Arrays.fill(numbersOnLineFromLeft, 0);
            }

            if (headNode.nextBigger != null) {
                numbersOnLineFromRight = getNumbersOnLine(headNode.nextBigger, lineQuantity - 1);
            } else {
                numbersOnLineFromRight = new int[(int) Math.round(Math.pow(2, lineQuantity - 2))];
                Arrays.fill(numbersOnLineFromRight, 0);
            }

            System.arraycopy(numbersOnLineFromLeft, 0, numbersOnLine, 0, numbersOnLineFromLeft.length);
            System.arraycopy(numbersOnLineFromRight, 0, numbersOnLine, numbersOnLineFromLeft.length, numbersOnLineFromRight.length);
        }

        return numbersOnLine;
    }

    public MyNode getHeadNode() {
        return headNode;
    }
}










package com.company;

public class MyNode {
    int data;
    MyNode nextSmaller;
    MyNode nextBigger;

    public MyNode(int data) {
        this.data = data;
    }
}