From 74d12eb6fe4ec4b0b594ee7d0987e48e7ac7c497 Mon Sep 17 00:00:00 2001 From: Jacob Date: Sun, 5 Jan 2025 15:42:57 -0500 Subject: [PATCH] h --- huffman_coding/src/huffman_coding/Main.java | 118 ++++++++++++++------ 1 file changed, 83 insertions(+), 35 deletions(-) diff --git a/huffman_coding/src/huffman_coding/Main.java b/huffman_coding/src/huffman_coding/Main.java index f8f129d..812310c 100644 --- a/huffman_coding/src/huffman_coding/Main.java +++ b/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 trees; + ArrayList treesSomeSorted; + ArrayList treesFirstTwoSorted; + ArrayList treesSame; ArrayList 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(Arrays.asList(a, b, c, d, e, f)); + treesSomeSorted = new ArrayList(Arrays.asList(e, d, f)); + treesFirstTwoSorted = new ArrayList(Arrays.asList(c, e, b, f)); + treesSame = new ArrayList(Arrays.asList(h, i)); treesSorted = new ArrayList(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(Arrays.asList(c, e, d, f))); + Util.insertIntoSorted(a, treesSomeSorted); + t.checkExpect( + treesSomeSorted, + new ArrayList(Arrays.asList(c, e, a, d, f))); + Util.insertIntoSorted(b, treesSomeSorted); + t.checkExpect( + treesSomeSorted, + new ArrayList(Arrays.asList(c, e, a, d, f, b))); + Util.insertIntoSorted(j, treesSame); + t.checkExpect(treesSame, new ArrayList(Arrays.asList(h, i, j))); + } + + void testUtilInsert(Tester t) { + init(); + Util.insert(a, treesFirstTwoSorted, 2); + t.checkExpect( + treesFirstTwoSorted, + new ArrayList(Arrays.asList(c, e, a, b, f))); + Util.insert(g, treesFirstTwoSorted, 3); + t.checkExpect( + treesFirstTwoSorted, + new ArrayList(Arrays.asList(c, e, a, g, b, f))); + } + + void testUtilSort(Tester t) { + init(); + ArrayList treesSortedCp = treesSorted; + + Util.sort(treesSortedCp); + t.checkExpect(treesSortedCp, treesSorted); + + Util.sort(trees); + t.checkExpect(trees, treesSorted); } } class Huffman { ArrayList charset; // Character set. - ArrayList freqs; // Frequencies of characters. + ArrayList freqs; // Frequencies of characters in charset. Huffman(ArrayList charset, ArrayList freqs) { if (charset.size() != freqs.size()) @@ -52,6 +98,18 @@ class Huffman { this.charset = charset; this.freqs = freqs; } + + /* + * // Encode a message. + * ArrayList encode(String s) { + * for + * } + * + * // Decode a message. + * String decode(ArrayList 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 sort(ArrayList trees) { - System.out.println("Sorting."); - // The sorted list starts out as just the first element. - ArrayList sorted = new ArrayList(Arrays.asList(trees.getFirst())); // Why must this be so fucking - // verbose. + static void sort(ArrayList 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 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 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 sortedTrees) { - for (int i = 0; i < sortedTrees.size(); i++) { - System.out.println("h"); + static void insertIntoSorted(ITree tree, ArrayList 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. } }