Лабораторная работа номер 32

students/23K0815/23K0815-p30/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>23K0815</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0815-p30</artifactId>
+    <description>Массивы</description>
+</project>

students/23K0815/23K0815-p30/src/main/java/ru/mirea/practice/s0000001/task1/SearchTree.java

@@ -0,0 +1,89 @@
+package ru.mirea.practice.s0000001.task1;
+
+class SearchTree {
+    private TreeNode root;
+
+    public SearchTree() {
+        root = null;
+    }
+
+    public void insert(int key) {
+        root = insertNode(root, key);
+    }
+
+    private TreeNode insertNode(TreeNode current, int key) {
+        if (current == null) {
+            current = new TreeNode(key);
+            return current;
+        }
+        if (key < current.value) {
+            current.leftChild = insertNode(current.leftChild, key);
+        } else if (key > current.value) {
+            current.rightChild = insertNode(current.rightChild, key);
+        }
+        return current;
+    }
+
+    public void printTree() {
+        inOrderTraversal(root);
+        System.out.println();
+    }
+
+    private void inOrderTraversal(TreeNode current) {
+        if (current != null) {
+            inOrderTraversal(current.leftChild);
+            System.out.print(current.value + " ");
+            inOrderTraversal(current.rightChild);
+        }
+    }
+
+    public void delete(int key) {
+        root = deleteNode(root, key);
+    }
+
+    private TreeNode deleteNode(TreeNode current, int key) {
+        if (current == null) {
+            return current;
+        }
+
+        if (key < current.value) {
+            current.leftChild = deleteNode(current.leftChild, key);
+        } else if (key > current.value) {
+            current.rightChild = deleteNode(current.rightChild, key);
+        } else {
+            if (current.leftChild == null) {
+                return current.rightChild;
+            } else if (current.rightChild == null) {
+                return current.leftChild;
+            }
+
+            current.value = getMinValue(current.rightChild);
+            current.rightChild = deleteNode(current.rightChild, current.value);
+        }
+        return current;
+    }
+
+    private int getMinValue(TreeNode current) {
+        int minValue = current.value;
+        while (current.leftChild != null) {
+            minValue = current.leftChild.value;
+            current = current.leftChild;
+        }
+        return minValue;
+    }
+
+    public void clear() {
+        root = clearAll(root);
+    }
+
+    private TreeNode clearAll(TreeNode current) {
+        if (current == null) {
+            return null;
+        }
+        current.leftChild = clearAll(current.leftChild);
+        current.rightChild = clearAll(current.rightChild);
+        current = null;
+        return current;
+    }
+}
+

students/23K0815/23K0815-p30/src/main/java/ru/mirea/practice/s0000001/task1/TreeNode.java

@@ -0,0 +1,12 @@
+package ru.mirea.practice.s0000001.task1;
+
+class TreeNode {
+    int value;
+    TreeNode leftChild;
+    TreeNode rightChild;
+
+    TreeNode(int key) {
+        value = key;
+        leftChild = rightChild = null;
+    }
+}

students/23K0815/23K0815-p30/src/main/java/ru/mirea/practice/s0000001/task2/HuffmanAlgorithm.java

@@ -0,0 +1,64 @@
+package ru.mirea.practice.s0000001.task2;
+
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.TreeMap;
+
+public abstract class HuffmanAlgorithm {
+
+    public static Map<Character, Integer> generateFrequencyMap(String input) {
+        Map<Character, Integer> frequencyMap = new TreeMap<>();
+        for (char character : input.toCharArray()) {
+            frequencyMap.put(character, frequencyMap.getOrDefault(character, 0) + 1);
+        }
+        return frequencyMap;
+    }
+
+    public static Map<Character, String> constructHuffmanTree(Map<Character, Integer> frequencyMap) {
+        PriorityQueue<HuffmanTreeNode> priorityQueue = new PriorityQueue<>();
+        for (Map.Entry<Character, Integer> entry : frequencyMap.entrySet()) {
+            priorityQueue.add(new HuffmanTreeNode(entry.getKey(), entry.getValue()));
+        }
+
+        while (priorityQueue.size() > 1) {
+            HuffmanTreeNode leftNode = priorityQueue.poll();
+            HuffmanTreeNode rightNode = priorityQueue.poll();
+            HuffmanTreeNode parentNode = new HuffmanTreeNode('\0', leftNode.frequency + rightNode.frequency);
+            parentNode.left = leftNode;
+            parentNode.right = rightNode;
+            priorityQueue.add(parentNode);
+        }
+
+        Map<Character, String> huffmanCodes = new TreeMap<>();
+        createHuffmanCodes(priorityQueue.peek(), "", huffmanCodes);
+
+        return huffmanCodes;
+    }
+
+    public static void createHuffmanCodes(HuffmanTreeNode node, String code, Map<Character, String> huffmanCodes) {
+        if (node != null) {
+            if (node.character != '\0') {
+                huffmanCodes.put(node.character, code);
+            }
+            createHuffmanCodes(node.left, code + "0", huffmanCodes);
+            createHuffmanCodes(node.right, code + "1", huffmanCodes);
+        }
+    }
+
+    public static class HuffmanTreeNode implements Comparable<HuffmanTreeNode> {
+        char character;
+        int frequency;
+        HuffmanTreeNode left;
+        HuffmanTreeNode right;
+
+        HuffmanTreeNode(char character, int frequency) {
+            this.character = character;
+            this.frequency = frequency;
+        }
+
+        @Override
+        public int compareTo(HuffmanTreeNode other) {
+            return Integer.compare(this.frequency, other.frequency);
+        }
+    }
+}

students/23K0815/23K0815-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>23K0815</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0815-p31</artifactId>
+    <description>Массивы</description>
+</project>

students/23K0815/23K0815-p31/src/main/java/ru/mirea/practice/s0000001/task1/BurgerDisplay.java

@@ -0,0 +1,69 @@
+package ru.mirea.practice.s0000001.task1;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public abstract class BurgerDisplay {
+
+    public static void displayBurgerTree(BurgerNode root) {
+        if (root == null) {
+            return;
+        }
+
+        int height = calculateHeight(root);
+        Deque<BurgerNode> queue = new ArrayDeque<>();
+        queue.offer(root);
+        int level = 0;
+
+        while (!queue.isEmpty()) {
+            int levelSize = queue.size();
+            int spacesBefore = (int) Math.pow(2, height - level - 1) - 1;
+            int spacesBetween = (int) Math.pow(2, height - level) - 1;
+
+            System.out.print(" ".repeat(spacesBefore));
+
+            for (int i = 0; i < levelSize; i++) {
+                BurgerNode node = queue.poll();
+                System.out.print(node.patty);
+
+                if (i < levelSize - 1) {
+                    System.out.print(" ".repeat(spacesBetween));
+                }
+
+                if (node.lettuce != null) {
+                    queue.offer(node.lettuce);
+                }
+                if (node.tomato != null) {
+                    queue.offer(node.tomato);
+                }
+                if (node.onion != null) {
+                    queue.offer(node.onion);
+                }
+            }
+            System.out.println();
+            level++;
+        }
+    }
+
+    // Function to compute the height of the burger tree
+    private static int calculateHeight(BurgerNode root) {
+        if (root == null) {
+            return 0;
+        }
+        return 1 + Math.max(Math.max(calculateHeight(root.lettuce), calculateHeight(root.tomato)), calculateHeight(root.onion));
+    }
+
+    public static void main(String[] args) {
+        BurgerNode root = new BurgerNode(5);
+        root.lettuce = new BurgerNode(2);
+        root.tomato = new BurgerNode(3);
+        root.onion = new BurgerNode(6);
+        root.lettuce.lettuce = new BurgerNode(1);
+        root.lettuce.onion = new BurgerNode(2);
+        root.tomato.lettuce = new BurgerNode(4);
+        root.onion.lettuce = new BurgerNode(5);
+        root.onion.onion = new BurgerNode(6);
+
+        displayBurgerTree(root);
+    }
+}

students/23K0815/23K0815-p31/src/main/java/ru/mirea/practice/s0000001/task1/BurgerNode.java

@@ -0,0 +1,13 @@
+package ru.mirea.practice.s0000001.task1;
+
+class BurgerNode {
+    int patty;
+    BurgerNode lettuce;
+    BurgerNode tomato;
+    BurgerNode onion;
+
+    BurgerNode(int patty) {
+        this.patty = patty;
+    }
+}
+

students/23K0815/23K0815-p31/src/main/java/ru/mirea/practice/s0000001/task1/BurgerTree.java

@@ -0,0 +1,34 @@
+package ru.mirea.practice.s0000001.task1;
+
+public abstract class BurgerTree {
+    public static void displayBurgerTree(BurgerNode node) {
+        if (node == null) {
+            return;
+        }
+
+        System.out.print(node.patty);
+
+        if (node.lettuce != null && node.onion != null) {
+            System.out.print("-");
+        }
+
+        System.out.print(" ");
+        displayBurgerTree(node.lettuce);
+        displayBurgerTree(node.tomato);
+        displayBurgerTree(node.onion);
+    }
+
+    public static void main(String[] args) {
+        BurgerNode root = new BurgerNode(5);
+        root.lettuce = new BurgerNode(2);
+        root.tomato = new BurgerNode(3);
+        root.onion = new BurgerNode(6);
+        root.lettuce.lettuce = new BurgerNode(1);
+        root.lettuce.onion = new BurgerNode(2);
+        root.tomato.lettuce = new BurgerNode(4);
+        root.onion.lettuce = new BurgerNode(5);
+        root.onion.onion = new BurgerNode(6);
+
+        displayBurgerTree(root);
+    }
+}

students/23K0815/23K0815-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>23K0815</artifactId>
+        <groupId>ru.mirea.practice</groupId>
+        <version>2024.1</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <artifactId>23K0815-p32</artifactId>
+    <description>Массивы</description>
+</project>