Merge pull request #1 from Vadym-Mitin/AnotherBranch

Another branch

Author: Vadym-Mitin

src/HuffmanCompression/Application.java

@@ -1,4 +1,46 @@
 package HuffmanCompression;
 
+import java.util.Map;
+
+import static HuffmanCompression.Compressor.encode;
+import static HuffmanCompression.HuffmanTree.*;
+import static HuffmanCompression.SerializeHuffmanTable.*;
+
+
 public class Application {
+
+    public static void main(String[] args) {
+
+        String s = "abracadabra";
+        System.out.println("String :");
+        System.out.println(s);
+        Node tree = growTree(s);
+
+        Map<Character, String> tableOfCodes = HuffmanTree.createTable(tree);
+
+        System.out.println("create table from string");
+        for (Map.Entry entry : tableOfCodes.entrySet()) {
+            System.out.println("key = " + entry.getKey() + "  Val = " + entry.getValue());
+        }
+
+        System.out.println("Encoded string");
+        String encoded = encode(s,tableOfCodes);
+        System.out.println(encoded);
+
+        System.out.println("Serialize table ");
+        String y = serialize(tableOfCodes);
+        System.out.println(y);
+
+        System.out.println("deserealize table");
+        Map<Character,String> deserialize = deserialize(y);
+
+        for (Map.Entry entry : deserialize.entrySet()) {
+            System.out.println("key = " + entry.getKey() + "  Val = " + entry.getValue());
+        }
+
+        System.out.println("decoded string");
+        String decode = Decompressor.decode(encoded,deserialize);
+        System.out.println(decode);
+
+    }
 }

src/HuffmanCompression/Compressor.java

@@ -1,36 +1,18 @@
 package HuffmanCompression;
 
-import java.sql.SQLOutput;
 import java.util.*;
 
 public class Compressor {
 
-    public static void main(String[] args) {
+        public static String encode(String encodedString, Map<Character, String> table) {
+        StringBuilder stringBuilder = new StringBuilder();
 
-        String s = "abracadabra";
-
-        HuffmanTree tree = HuffmanTree.growTree(s);
-
-        Map<Character, String> tableOfCodes = tree.createTable(tree.getParentNode());
-
-
-        for (Map.Entry entry : tableOfCodes.entrySet()) {
-            System.out.println("key = " + entry.getKey() + "  Val = " + entry.getValue());
+        for (int i = 0; i <encodedString.length(); i++) {
+            String code = table.get(encodedString.charAt(i));
+            stringBuilder.append(code);
         }
 
-//        Byte[] bytes = new Byte[s.length()];
-        StringBuffer sb = new StringBuffer();
-
-        for (int i = 0; i <s.length() ; i++) {
-            sb.append(tableOfCodes.get(s.charAt(i)));
-        }
-        System.out.println(sb.toString());
-
-        String x = HuffmanTree.nodeSerialize(tree.getParentNode());
-        System.out.println(x);
-
-        HuffmanTree.Node newParent = HuffmanTree.nodeDeserialize(x);
-
+        return stringBuilder.toString();
     }
 
 

src/HuffmanCompression/Decompressor.java

@@ -1,34 +1,40 @@
 package HuffmanCompression;
 
-import java.util.Iterator;
 import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.Queue;
 
 public class Decompressor {
 
     public static void main(String[] args) {
         String s = "abracadabra";
 
-        HuffmanTree tree = HuffmanTree.growTree(s);
-//        System.out.println(HuffmanTree.createTable(tree.getParentNode()).toString());
+        Node tree = HuffmanTree.growTree(s);
+
+        Map<Character, String> table = HuffmanTree.createTable(tree);
         String compressed = "01011001110011110101100";
 
-//        System.out.println(tree.getParentNode().getCode());
+        for (Map.Entry entry : table.entrySet()) {
+            System.out.println("key = " + entry.getKey() + "  Val = " + entry.getValue());
+        }
 
-        String swe = decode(compressed, tree);
+        String swe = decode(compressed, table);
 
         System.out.println(swe);
-//            for (int j = maxCode.length()-1; j >=0 ; j--) {
-//                System.out.println(j);
-//            }
 
     }
 
-    public static String decode(String s, HuffmanTree tree) {
-        HuffmanTree.Node parentNode = tree.getParentNode();
-        Map<Character, String> table = HuffmanTree.createTable(parentNode);
-//        System.out.println(table.toString());
-        Iterator<Map.Entry<Character, String>> iterator = table.entrySet().iterator();
-        int maxCodeLength = iterator.next().getValue().length();
+    public static String decode(String s, Map<Character, String> table) {
+
+        Queue<Map.Entry<Character, String>> queue = new PriorityQueue<>((Map.Entry<Character, String> o2,
+                                                                         Map.Entry<Character, String> o1) ->
+                o1.getValue().compareToIgnoreCase(o2.getValue()));
+
+        queue.addAll(table.entrySet());
+
+        String maxValue = queue.poll().getValue();
+//        System.out.println(maxValue);
+        int maxCodeLength = maxValue.length();
 
         StringBuilder sb = new StringBuilder();
 

src/HuffmanCompression/FileReader.java renamed to src/HuffmanCompression/FileWork.java

@@ -1,4 +1,4 @@
 package HuffmanCompression;
 
-public class FileReader {
+public class FileWork {
 }

src/HuffmanCompression/HuffmanTree.java

@@ -8,6 +8,8 @@ public class HuffmanTree {
 
     public static void main(String[] args) {
         String s = "abracadabra";
+        System.out.println(s);
+
         Map<Character, Integer> map = ListOfFrequencies(s);
 
         for (Map.Entry entry : map.entrySet()) {
@@ -17,10 +19,8 @@ public static void main(String[] args) {
         System.out.println();
         System.out.println();
 
-
-        HuffmanTree tree = HuffmanTree.growTree(s);
-        Map<Character, String> table = tree.createTable(tree.parent);
-
+        Node tree = HuffmanTree.growTree(s);
+        Map<Character, String> table = createTable(tree);
 
         for (Map.Entry entry : table.entrySet()) {
             System.out.println("key = " + entry.getKey() + "  Val = " + entry.getValue());
@@ -36,34 +36,28 @@ public Node getParentNode() {
     }
 
     private static Map<Character, Integer> ListOfFrequencies(String s) {
-        Map<Character, Integer> map = new HashMap<>();
+        Map<Character, Integer> listOfRepetition = new HashMap<>();
         char[] characters = s.toCharArray();
-        for (int i = 0; i < characters.length; i++) {
-            char aChar = characters[i];
-            if (map.containsKey(aChar)) {
-                Integer count = map.get(aChar) + 1;
-                map.put(aChar, count);
+        for (char aChar : characters) {
+            if (listOfRepetition.containsKey(aChar)) {
+                Integer count = listOfRepetition.get(aChar) + 1;
+                listOfRepetition.put(aChar, count);
             } else {
-                map.put(aChar, 1);
+                listOfRepetition.put(aChar, 1);
             }
         }
 
-        List<Map.Entry<Character, Integer>> list = new LinkedList<>(map.entrySet());
-
-        //Sorting witch Comparator
-        //LamBadAss
+        List<Map.Entry<Character, Integer>> list = new LinkedList<>(listOfRepetition.entrySet());
         Collections.sort(list, (Map.Entry<Character, Integer> o1, Map.Entry<Character, Integer> o2) ->
                 o1.getValue().compareTo(o2.getValue()));
-
-        map = new LinkedHashMap<>();
+        listOfRepetition = new LinkedHashMap<>();
         for (Map.Entry<Character, Integer> entry : list) {
-            map.put(entry.getKey(), entry.getValue());
+            listOfRepetition.put(entry.getKey(), entry.getValue());
         }
-
-        return map;
+        return listOfRepetition;
     }
 
-    public static HuffmanTree growTree(String s) {
+    public static Node growTree(String s) {
 
         Map<Character, Integer> nodeSet = HuffmanTree.ListOfFrequencies(s);
 
@@ -92,116 +86,26 @@ public static HuffmanTree growTree(String s) {
         }
 
         Node root = queue.poll();
-        return new HuffmanTree(root);
+        return root;
     }
 
     public static Map<Character, String> createTable(Node node) {
         Map<Character, String> table = new LinkedHashMap<>();
-        treeTraversalforCreateTable(table, node, "");
+        treeTraversalForCreateTable(table, node, "");
         return table;
     }
 
-    private static void treeTraversalforCreateTable(Map<Character, String> table, Node node, String s) {
+    private static void treeTraversalForCreateTable(Map<Character, String> table, Node node, String s) {
 
         if (!node.isLeaf()) {
 //            System.out.println(node.getChars());
-            treeTraversalforCreateTable(table, node.getLeftNode(), s+ node.getLeftNode().getCode());
-            treeTraversalforCreateTable(table, node.getRightNode(), s+ node.getRightNode().getCode());
+            treeTraversalForCreateTable(table, node.getLeftNode(), s+ node.getLeftNode().getCode());
+            treeTraversalForCreateTable(table, node.getRightNode(), s+ node.getRightNode().getCode());
         } else {
             node.setLeafCode(s);
             table.put(node.getSymbol(), node.getCode());
         }
     }
 
 
-    public static class Node {
-
-        private Node leftNode;
-        private Node rightNode;
-        private boolean isRoot;
-        private boolean isFirst;
-        private int freq;
-        private String code;
-        private String chars;
-        private Character symbol;
-
-        private Node(Node left, int freq, Node right) {
-            this.leftNode = left;
-            this.rightNode = right;
-            this.freq = freq;
-        }
-
-        private Node(Node left, int freq, Node right, Character symbol) {
-            this.leftNode = left;
-            this.rightNode = right;
-            this.freq = freq;
-            this.chars = symbol.toString();
-            this.symbol = symbol;
-
-        }
-
-        public Character getSymbol() {
-            return symbol;
-        }
-
-        public void setChars(String s) {
-            this.chars = s;
-        }
-
-        public String getChars() {
-            return chars;
-        }
-
-        public static Node createLeaf(Map.Entry<Character, Integer> symbol) {
-            return new Node(null, symbol.getValue(), null, symbol.getKey());
-        }
-
-        public static Node createNode(Node left, int freq, Node right) {
-            return new Node(left, freq, right);
-        }
-
-        public String getCode() {
-            return code;
-        }
-
-        public void setCode(String code) {
-            if (code.equals("1") || code.equals("0")) {
-                this.code = code;
-//                return this;
-            } else throw new IllegalStateException("this wrong code type 0 or 1");
-        }
-
-        public void setLeafCode(String code) {
-            if (isLeaf()) {
-                this.code = code;
-            }
-        }
-
-        public boolean isLeaf() {
-            return leftNode == null && rightNode == null && !(chars.isEmpty());
-        }
-
-        public Node setLeftNode(Node leftNode) {
-            this.leftNode = leftNode;
-            return this;
-        }
-
-        public Node setRightNode(Node rightNode) {
-            this.rightNode = rightNode;
-            return this;
-        }
-
-        public Node getLeftNode() {
-            return leftNode;
-        }
-
-        public Node getRightNode() {
-            return rightNode;
-        }
-
-        public Integer getFreq() {
-            return freq;
-        }
-
-    }
 }