Task_31 - master - Skob.m.a/WorkSpace

Task_31
270 строк10 KB
Skob.m.a
create Task_31
22 дек 2024, 16:12
22 дек 2024, 16:12ee9e6ef
import java.io.*;
import java.util.*;

class Processor {
    int key;
    String name;
    double clockSpeed;
    int cacheSize;
    double busSpeed;
    int specInt;
    int specFp;

    public Processor(int key, String name, double clockSpeed, int cacheSize, double busSpeed, int specInt, int specFp) {
        this.key = key;
        this.name = name;
        this.clockSpeed = clockSpeed;
        this.cacheSize = cacheSize;
        this.busSpeed = busSpeed;
        this.specInt = specInt;
        this.specFp = specFp;
    }

    @Override
    public String toString() {
        return key + ", " + name + ", " + clockSpeed + ", " + cacheSize + ", " + busSpeed + ", " + specInt + ", " + specFp;
    }
}

class Node {
    Processor[] processors = new Processor[3];
    Node[] children = new Node[4];
    int numProcessors = 0;

    public boolean isLeaf() {
        return children[0] == null;
    }
}

class TwoThreeTree {
    private Node root;

    public void insert(Processor processor) {
        if (root == null) {
            root = new Node();
        }
        root = insert(root, processor);
    }

    private Node insert(Node node, Processor processor) {
        if (node.isLeaf()) {
            return insertInLeaf(node, processor);
        } else {
            return insertInInternal(node, processor);
        }
    }

    private Node insertInLeaf(Node node, Processor processor) {
        if (node.numProcessors < 2) {
            node.processors[node.numProcessors++] = processor;
            Arrays.sort(node.processors, 0, node.numProcessors, Comparator.comparingInt(p -> p.key));
            return null;
        } else {
            Node newNode = new Node();
            Processor[] temp = Arrays.copyOf(node.processors, 3);
            temp[2] = processor;
            Arrays.sort(temp, Comparator.comparingInt(p -> p.key));

            node.processors[0] = temp[0];
            node.processors[1] = temp[1];
            newNode.processors[0] = temp[2];
            newNode.numProcessors = 1;
            node.numProcessors = 2;

            return newNode;
        }
    }

    private Node insertInInternal(Node node, Processor processor) {
        int i = 0;
        while (i < node.numProcessors && processor.key > node.processors[i].key) {
            i++;
        }
        Node newNode = insert(node.children[i], processor);
        if (newNode != null) {
            if (node.numProcessors < 2) {
                for (int j = node.numProcessors; j > i; j--) {
                    node.processors[j] = node.processors[j - 1];
                    node.children[j + 1] = node.children[j];
                }
                node.processors[i] = newNode.processors[0];
                node.children[i + 1] = newNode.children[0];
                node.numProcessors++;
            } else {
                Processor[] temp = Arrays.copyOf(node.processors, 3);
                Node[] tempChildren = Arrays.copyOf(node.children, 4);
                temp[2] = newNode.processors[0];
                Arrays.sort(temp, 0, 3, Comparator.comparingInt(p -> p.key));

                int index = 0;
                while (index < 2 && temp[index] != null && temp[index].key < temp[2].key) {
                    index++;
                }

                for (int j = 2; j > index; j--) {
                    temp[j] = temp[j - 1];
                    tempChildren[j + 1] = tempChildren[j];
                }
                temp[index] = newNode.processors[0];
                tempChildren[index + 1] = newNode.children[0];

                node.processors[0] = temp[0];
                node.processors[1] = temp[1];
                node.children[1] = tempChildren[1];
                node.children[2] = tempChildren[2];
                node.numProcessors = 2;

                Node newInternalNode = new Node();
                newInternalNode.processors[0] = temp[2];
                newInternalNode.children[0] = tempChildren[2];
                newInternalNode.children[1] = tempChildren[3];
                newInternalNode.numProcessors = 1;

                return newInternalNode;
            }
        }
        return null;
    }

    public void print() {
        print(root, 0);
    }

    private void print(Node node, int level) {
        if (node == null) return;

        for (int i = 0; i < level; i++) {
            System.out.print("  ");
        }

        for (int i = 0; i < node.numProcessors; i++) {
            System.out.print(node.processors[i].key + (i < node.numProcessors - 1 ? " - " : ""));
        }
        System.out.println();

        for (int i = 0; i <= node.numProcessors; i++) {
            print(node.children[i], level + 1);
        }
    }

    public boolean delete(int key) {
        return delete(root, key) != null;
    }

    private Node delete(Node node, int key) {
        return null;
    }

    public boolean contains(int key) {
        return contains(root, key);
    }

    private boolean contains(Node node, int key) {
        if (node == null) return false;

        for (int i = 0; i < node.numProcessors; i++) {
            if (node.processors[i].key == key) return true;
            if (key < node.processors[i].key) return contains(node.children[i], key);
        }
        return contains(node.children[node.numProcessors], key);
    }
}

public class ProcessorManager {
    private static final String FILENAME = "PROCS.TXT";
    private static TwoThreeTree tree = new TwoThreeTree();

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

        while (true) {
            System.out.println("Введите команду (L, D n, A n, S, E):");
            String command = scanner.nextLine().trim();

            if (command.equalsIgnoreCase("L")) {
                tree.print();
            } else if (command.startsWith("D ")) {
                int key = Integer.parseInt(command.split(" ")[1]);
                if (tree.delete(key)) {
                    System.out.println("Запись с ключом " + key + " удалена.");
                } else {
                    System.out.println("Запись с ключом " + key + " не найдена.");
                }
            } else if (command.startsWith("A ")) {
                int key = Integer.parseInt(command.split(" ")[1]);
                if (tree.contains(key)) {
                    System.out.println("Запись с ключом " + key + " уже существует.");
                } else {
                    System.out.println("Введите название процессора:");
                    String name = scanner.nextLine();
                    System.out.println("Введите тактовую частоту (в ГГц):");
                    double clockSpeed = Double.parseDouble(scanner.nextLine());
                    System.out.println("Введите размер кеш-памяти (в Кб):");
                    int cacheSize = Integer.parseInt(scanner.nextLine());
                    System.out.println("Введите частоту системной шины (в ГГц):");
                    double busSpeed = Double.parseDouble(scanner.nextLine());
                    System.out.println("Введите результат теста SPECint:");
                    int specInt = Integer.parseInt(scanner.nextLine());
                    System.out.println("Введите результат теста SPECfp:");
                    int specFp = Integer.parseInt(scanner.nextLine());

                    Processor processor = new Processor(key, name, clockSpeed, cacheSize, busSpeed, specInt, specFp);
                    tree.insert(processor);
                    System.out.println("Запись добавлена.");
                }
            } else if (command.equalsIgnoreCase("S")) {
                saveProcessors();
                System.out.println("Записи сохранены в файл " + FILENAME);
            } else if (command.equalsIgnoreCase("E")) {
                System.out.println("Выход из программы.");
                break;
            } else {
                System.out.println("Неизвестная команда. Попробуйте снова.");
            }
        }
        scanner.close();
    }

    private static void loadProcessors() {
        try (BufferedReader br = new BufferedReader(new FileReader(FILENAME))) {
            String line;
            while ((line = br.readLine()) != null) {
                String[] parts = line.split(", ");
                int key = Integer.parseInt(parts[0]);
                String name = parts[1];
                double clockSpeed = Double.parseDouble(parts[2]);
                int cacheSize = Integer.parseInt(parts[3]);
                double busSpeed = Double.parseDouble(parts[4]);
                int specInt = Integer.parseInt(parts[5]);
                int specFp = Integer.parseInt(parts[6]);

                Processor processor = new Processor(key, name, clockSpeed, cacheSize, busSpeed, specInt, specFp);
                tree.insert(processor);
            }
        } catch (IOException e) {
            System.out.println("Ошибка при чтении файла: " + e.getMessage());
        }
    }

    private static void saveProcessors() {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter(FILENAME))) {
            saveProcessors(bw, tree.root);
        } catch (IOException e) {
            System.out.println("Ошибка при записи в файл: " + e.getMessage());
        }
    }

    private static void saveProcessors(BufferedWriter bw, Node node) throws IOException {
        if (node == null) return;

        for (int i = 0; i < node.numProcessors; i++) {
            bw.write(node.processors[i].toString());
            bw.newLine();
        }

        for (int i = 0; i <= node.numProcessors; i++) {
            saveProcessors(bw, node.children[i]);
        }
    }
}