h

huffman_coding/src/huffman_coding/Main.java

@@ -2,7 +2,6 @@ package huffman_coding;
 
 import java.util.ArrayList;
 import java.util.Arrays;
-
 import tester.Tester;
 
 class Examples {
@@ -13,8 +12,12 @@ class Examples {
     ITree d;
     ITree e;
     ITree f;
+    ITree g, h, i, j;
 
     ArrayList<ITree> trees;
+    ArrayList<ITree> treesSomeSorted;
+    ArrayList<ITree> treesFirstTwoSorted;
+    ArrayList<ITree> treesSame;
     ArrayList<ITree> treesSorted;
 
     void init() {
@@ -24,21 +27,64 @@ class Examples {
         d = new Leaf(13, "d");
         e = new Leaf(9, "e");
         f = new Leaf(16, "f");
+        g = new Leaf(928373743, "f");
+        h = new Leaf(1, "h");
+        i = new Leaf(1, "i");
+        j = new Leaf(1, "j");
 
         trees = new ArrayList<ITree>(Arrays.asList(a, b, c, d, e, f));
+        treesSomeSorted = new ArrayList<ITree>(Arrays.asList(e, d, f));
+        treesFirstTwoSorted = new ArrayList<ITree>(Arrays.asList(c, e, b, f));
+        treesSame = new ArrayList<ITree>(Arrays.asList(h, i));
         treesSorted = new ArrayList<ITree>(Arrays.asList(c, e, a, d, f, b));
     }
 
-    void testITreeSort(Tester t) {
+    void testUtilInsertIntoSorted(Tester t) {
         init();
-        t.checkExpect(Util.sort(trees), treesSorted);
+        Util.insertIntoSorted(c, treesSomeSorted);
+        t.checkExpect(
+                treesSomeSorted,
+                new ArrayList<ITree>(Arrays.asList(c, e, d, f)));
+        Util.insertIntoSorted(a, treesSomeSorted);
+        t.checkExpect(
+                treesSomeSorted,
+                new ArrayList<ITree>(Arrays.asList(c, e, a, d, f)));
+        Util.insertIntoSorted(b, treesSomeSorted);
+        t.checkExpect(
+                treesSomeSorted,
+                new ArrayList<ITree>(Arrays.asList(c, e, a, d, f, b)));
+        Util.insertIntoSorted(j, treesSame);
+        t.checkExpect(treesSame, new ArrayList<ITree>(Arrays.asList(h, i, j)));
+    }
+
+    void testUtilInsert(Tester t) {
+        init();
+        Util.insert(a, treesFirstTwoSorted, 2);
+        t.checkExpect(
+                treesFirstTwoSorted,
+                new ArrayList<ITree>(Arrays.asList(c, e, a, b, f)));
+        Util.insert(g, treesFirstTwoSorted, 3);
+        t.checkExpect(
+                treesFirstTwoSorted,
+                new ArrayList<ITree>(Arrays.asList(c, e, a, g, b, f)));
+    }
+
+    void testUtilSort(Tester t) {
+        init();
+        ArrayList<ITree> treesSortedCp = treesSorted;
+
+        Util.sort(treesSortedCp);
+        t.checkExpect(treesSortedCp, treesSorted);
+
+        Util.sort(trees);
+        t.checkExpect(trees, treesSorted);
     }
 }
 
 class Huffman {
 
     ArrayList<String> charset; // Character set.
-    ArrayList<Integer> freqs; // Frequencies of characters.
+    ArrayList<Integer> freqs; // Frequencies of characters in charset.
 
     Huffman(ArrayList<String> charset, ArrayList<Integer> freqs) {
         if (charset.size() != freqs.size())
@@ -52,6 +98,18 @@ class Huffman {
         this.charset = charset;
         this.freqs = freqs;
     }
+
+    /*
+     * // Encode a message.
+     * ArrayList<Boolean> encode(String s) {
+     * for
+     * }
+     *
+     * // Decode a message.
+     * String decode(ArrayList<Boolean> c) {
+     *
+     * }
+     */
 }
 
 // Binary tree.
@@ -105,50 +163,40 @@ class Leaf extends ATree {
 class Util {
 
     // Sort a list of trees from least to most frequent.
-    static ArrayList<ITree> sort(ArrayList<ITree> trees) {
-        System.out.println("Sorting.");
-        // The sorted list starts out as just the first element.
-        ArrayList<ITree> sorted = new ArrayList<ITree>(Arrays.asList(trees.getFirst())); // Why must this be so fucking
-                                                                                         // verbose.
+    static void sort(ArrayList<ITree> trees) {
+        // Our work here is done.
+        if (trees.size() < 2)
+            return;
 
-        if (trees.size() == 1)
-            return sorted;
-
-        for (int i = 1; i < trees.size() - 1; i++) {
-            Util.insert(trees.get(i), sorted, i);
+        for (int i = 1; i < trees.size(); i++) {
+            // Copy out the tree to insert.
+            ITree tree = trees.get(i);
+            trees.remove(tree);
+            // Insert it.
+            insert(tree, trees, i);
         }
-
-        return sorted;
     }
 
     // Insert a Tree into an ArrayList of trees already sorted in [0, i), where
     // 0 <= i <= trees.size(), such that it is sorted through [0, i].
     static void insert(ITree tree, ArrayList<ITree> trees, int i) {
-<<<<<<< Updated upstream
-        System.out.println("Set j = 0. While j < " + (i + 1) + ", j++.");
-        for (int j = 0; j < (i + 1); j++) {
-=======
-        for (int j = 0; j < i + 1; j++) {
-            System.out.println("it's here it's fucking here");
->>>>>>> Stashed changes
-            if (trees.get(j).lessThan(tree)) {
-                trees.add(j, tree);
-                return;
-            }
-        }
-
-        trees.add(i, tree);
+        // Extract sorted.
+        ArrayList<ITree> sorted = new ArrayList<>(trees.subList(0, i));
+        // Insert tree.
+        insertIntoSorted(tree, sorted);
+        // Overwrite original trees with sorted ones.
+        for (int j = 0; j < i; trees.set(j, sorted.get(j++)))
+            ;
+        trees.add(i, sorted.getLast());
     }
 
     // Insert a Tree in an already fully sorted ArrayList of Trees.
-    static void insert(ITree tree, ArrayList<ITree> sortedTrees) {
-        for (int i = 0; i < sortedTrees.size(); i++) {
-            System.out.println("h");
+    static void insertIntoSorted(ITree tree, ArrayList<ITree> sortedTrees) {
+        for (int i = 0; i < sortedTrees.size(); i++)
             if (sortedTrees.get(i).lessThan(tree)) {
-                sortedTrees.add(i, tree);
+                sortedTrees.add(i, tree);//
                 return;
             }
-        }
         sortedTrees.addLast(tree); // This tree is bigger than all the others.
     }
 }