Практические работы 31-32

students/23K0354/23K0354-p31/pom.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>23K0354</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0354-p31</artifactId>
+    <description> 2-3 деревья </description>
+</project>

students/23K0354/23K0354-p31/src/main/java/ru/mirea/practices0000001/task1/FileHandler.java

@@ -0,0 +1,52 @@
+package ru.mirea.practices0000001.task1;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class FileHandler {
+
+    private FileHandler() {
+    }
+
+    public static List<ProcessorRecord> readFile(String filePath) {
+        List<ProcessorRecord> records = new ArrayList<>();
+        BufferedReader reader = null;
+
+        try {
+            reader = new BufferedReader(new FileReader(new File(filePath)));
+            String line;
+            while ((line = reader.readLine()) != null) {
+                String[] parts = line.split(",");
+                if (parts.length == 7) {
+                    int key = Integer.parseInt(parts[0].trim());
+                    String name = parts[1].trim();
+                    double clockFrequency = Double.parseDouble(parts[2].trim());
+                    int cacheSize = Integer.parseInt(parts[3].trim());
+                    double busFrequency = Double.parseDouble(parts[4].trim());
+                    int specint = Integer.parseInt(parts[5].trim());
+                    int specfp = Integer.parseInt(parts[6].trim());
+
+                    ProcessorRecord record = new ProcessorRecord(
+                            key, name, clockFrequency, cacheSize, busFrequency, specint, specfp);
+                    records.add(record);
+                }
+            }
+        } catch (IOException e) {
+            System.out.println("Error reading file: " + e.getMessage());
+        } finally {
+            try {
+                if (reader != null) {
+                    reader.close();
+                }
+            } catch (IOException e) {
+                System.out.println("Error closing reader: " + e.getMessage());
+            }
+        }
+
+        return records;
+    }
+}

students/23K0354/23K0354-p31/src/main/java/ru/mirea/practices0000001/task1/Main.java

@@ -0,0 +1,75 @@
+package ru.mirea.practices0000001.task1;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public final class Main {
+
+    private static Scanner scanner = new Scanner(System.in);
+    private static TwoThreeTree tree = new TwoThreeTree();
+
+    private Main() {
+    }
+
+    public static void run() {
+        while (true) {
+            System.out.println("Enter command (L, D, A, S, E):");
+            String command = scanner.nextLine().trim().toUpperCase(Locale.ROOT);
+
+            switch (command) {
+                case "L":
+                    tree.printByLevels();
+                    break;
+
+                case "D":
+                    System.out.println("Enter key to delete:");
+                    int deleteKey = Integer.parseInt(scanner.nextLine().trim());
+                    boolean deleted = tree.delete(deleteKey);
+                    if (deleted) {
+                        System.out.println("Deleted successfully.");
+                    } else {
+                        System.out.println("Key not found.");
+                    }
+                    break;
+
+                case "A":
+                    System.out.println("Enter key to add:");
+                    int addKey = Integer.parseInt(scanner.nextLine().trim());
+                    System.out.println("Enter processor name:");
+                    String name = scanner.nextLine().trim();
+                    System.out.println("Enter clock frequency (GHz):");
+                    double clockFrequency = Double.parseDouble(scanner.nextLine().trim());
+                    System.out.println("Enter cache size (KB):");
+                    int cacheSize = Integer.parseInt(scanner.nextLine().trim());
+                    System.out.println("Enter bus frequency (GHz):");
+                    double busFrequency = Double.parseDouble(scanner.nextLine().trim());
+                    System.out.println("Enter SPECint result:");
+                    int specint = Integer.parseInt(scanner.nextLine().trim());
+                    System.out.println("Enter SPECfp result:");
+                    int specfp = Integer.parseInt(scanner.nextLine().trim());
+
+                    ProcessorRecord record = new ProcessorRecord(addKey, name, clockFrequency, cacheSize, busFrequency, specint, specfp);
+                    tree.insert(record);
+                    System.out.println("Record added.");
+                    break;
+
+                case "S":
+                    System.out.println("Saving to file...");
+                    break;
+
+                case "E":
+                    System.out.println("Exiting...");
+                    scanner.close();
+                    return;
+
+                default:
+                    System.out.println("Unknown command.");
+                    break;
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        run();
+    }
+}

students/23K0354/23K0354-p31/src/main/java/ru/mirea/practices0000001/task1/ProcessorRecord.java

@@ -0,0 +1,62 @@
+package ru.mirea.practices0000001.task1;
+
+public class ProcessorRecord {
+    private int key;
+    private String name;
+    private double clockFrequency;
+    private int cacheSize;
+    private double busFrequency;
+    private int specint;
+    private int specfp;
+
+    public ProcessorRecord(int key, String name, double clockFrequency, int cacheSize, double busFrequency, int specint, int specfp) {
+        this.key = key;
+        this.name = name;
+        this.clockFrequency = clockFrequency;
+        this.cacheSize = cacheSize;
+        this.busFrequency = busFrequency;
+        this.specint = specint;
+        this.specfp = specfp;
+    }
+
+    public int getKey() {
+        return key;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public double getClockFrequency() {
+        return clockFrequency;
+    }
+
+    public int getCacheSize() {
+        return cacheSize;
+    }
+
+    public double getBusFrequency() {
+        return busFrequency;
+    }
+
+    public int getSpecint() {
+        return specint;
+    }
+
+    public int getSpecfp() {
+        return specfp;
+    }
+
+    @Override
+    public String toString() {
+        return "ProcessorRecord{"
+                + "key=" + key
+                + ", name='" + name + '\''
+                + ", clockFrequency=" + clockFrequency
+                + ", cacheSize=" + cacheSize
+                + ", busFrequency=" + busFrequency
+                + ", specint=" + specint
+                + ", specfp=" + specfp
+                + '}';
+    }
+}

students/23K0354/23K0354-p31/src/main/java/ru/mirea/practices0000001/task1/TwoThreeTree.java

@@ -0,0 +1,128 @@
+package ru.mirea.practices0000001.task1;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class TwoThreeTree {
+    private static class Node {
+        private final boolean isLeaf;
+        private final List<ProcessorRecord> records = new ArrayList<>();
+        private final List<Node> children = new ArrayList<>();
+
+        Node(boolean isLeaf) {
+            this.isLeaf = isLeaf;
+        }
+    }
+
+    private Node root = new Node(true);
+
+    public void insert(ProcessorRecord record) {
+        root = insertRec(root, record);
+    }
+
+    private Node insertRec(Node node, ProcessorRecord record) {
+        if (node.isLeaf) {
+            node.records.add(record);
+            node.records.sort(Comparator.comparingInt(ProcessorRecord::getKey));
+            if (node.records.size() > 2) {
+                return split(node);
+            }
+            return node;
+        } else {
+            if (record.getKey() < node.records.get(0).getKey()) {
+                Node newChild = insertRec(node.children.get(0), record);
+                if (newChild != node.children.get(0)) {
+                    node.children.add(0, newChild);
+                }
+            } else if (node.records.size() == 1 || record.getKey() < node.records.get(1).getKey()) {
+                Node newChild = insertRec(node.children.get(1), record);
+                if (newChild != node.children.get(1)) {
+                    node.children.add(1, newChild);
+                }
+            } else {
+                Node newChild = insertRec(node.children.get(2), record);
+                if (newChild != node.children.get(2)) {
+                    node.children.add(2, newChild);
+                }
+            }
+            if (node.children.size() > 3) {
+                return split(node);
+            }
+            return node;
+        }
+    }
+
+    private Node split(Node node) {
+        Node left = new Node(node.isLeaf);
+        Node right = new Node(node.isLeaf);
+        left.records.add(node.records.get(0));
+        right.records.add(node.records.get(2));
+        if (!node.isLeaf) {
+            left.children.add(node.children.get(0));
+            left.children.add(node.children.get(1));
+            right.children.add(node.children.get(2));
+            right.children.add(node.children.get(3));
+        }
+        Node parent = new Node(false);
+        parent.records.add(node.records.get(1));
+        parent.children.add(left);
+        parent.children.add(right);
+        return parent;
+    }
+
+    public boolean delete(int key) {
+        return deleteRec(root, key);
+    }
+
+    private boolean deleteRec(Node node, int key) {
+        if (node.isLeaf) {
+            return node.records.removeIf(r -> r.getKey() == key);
+        } else {
+            for (int i = 0; i < node.records.size(); i++) {
+                if (key < node.records.get(i).getKey()) {
+                    return deleteRec(node.children.get(i), key);
+                }
+            }
+            return deleteRec(node.children.get(node.children.size() - 1), key);
+        }
+    }
+
+    public void printByLevels() {
+        Queue<Node> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            Node current = queue.poll();
+            if (current.isLeaf) {
+                for (ProcessorRecord record : current.records) {
+                    System.out.print(record.getKey() + " ");
+                }
+            } else {
+                for (ProcessorRecord record : current.records) {
+                    System.out.print(record.getKey() + "- ");
+                }
+                queue.addAll(current.children);
+            }
+            System.out.println();
+        }
+    }
+
+    public List<ProcessorRecord> getAllRecords() {
+        List<ProcessorRecord> result = new ArrayList<>();
+        getAllRecordsRec(root, result);
+        return result;
+    }
+
+    private void getAllRecordsRec(Node node, List<ProcessorRecord> result) {
+        if (node.isLeaf) {
+            result.addAll(node.records);
+        } else {
+            for (int i = 0; i < node.records.size(); i++) {
+                getAllRecordsRec(node.children.get(i), result);
+            }
+            getAllRecordsRec(node.children.get(node.children.size() - 1), result);
+        }
+    }
+}

students/23K0354/23K0354-p32/pom.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>23K0354</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0354-p32</artifactId>
+    <description> Алгоритмы генерации комбинаторных объектов </description>
+</project>