Changed the testing of the data structures to use JUnit

Author: Justin Wetherell

src/com/jwetherell/algorithms/DataStructures.java

@@ -24,11 +24,11 @@ public interface BinaryHeap<T extends Comparable<T>> extends IHeap<T> {
 
     public enum HeapType {
         Tree, Array
-    };
+    }
 
     public enum Type {
         MIN, MAX
-    };
+    }
 
     /**
      * Get the heap in array form.

src/com/jwetherell/algorithms/DataStructuresTiming.java

@@ -0,0 +1,30 @@
+package com.jwetherell.algorithms.data_structures;
+
+import java.util.Set;
+
+/**
+ * In computer science, a suffix tree (also called PAT tree or, in an earlier form, position tree) is a compressed trie 
+ * containing all the suffixes of the given text as their keys and positions in the text as their values. Suffix trees 
+ * allow particularly fast implementations of many important string operations.
+ * 
+ * http://en.wikipedia.org/wiki/Suffix_tree
+ * 
+ * @author Justin Wetherell <[email protected]>
+ */
+public interface ISuffixTree<C extends CharSequence> {
+
+    /**
+     * Does the sub-sequence exist in the suffix tree.
+     * 
+     * @param sub-sequence to locate in the tree.
+     * @return True if the sub-sequence exist in the tree.
+     */
+    public boolean doesSubStringExist(C sub);
+
+    /**
+     * Get all the suffixes in the tree.
+     * 
+     * @return set of suffixes in the tree.
+     */
+    public Set<String> getSuffixes();
+}

src/com/jwetherell/algorithms/data_structures/BinaryHeap.java

@@ -18,7 +18,7 @@
  * 
  * @author Justin Wetherell <[email protected]>
  */
-public class SuffixTree<C extends CharSequence> {
+public class SuffixTree<C extends CharSequence> implements ISuffixTree<C> {
 
     private static final char DEFAULT_END_SEQ_CHAR = '$';
 

src/com/jwetherell/algorithms/data_structures/ISuffixTree.java

@@ -15,7 +15,7 @@
  * 
  * @author Justin Wetherell <[email protected]>
  */
-public class SuffixTrie<C extends CharSequence> {
+public class SuffixTrie<C extends CharSequence> implements ISuffixTree<C> {
 
     private Trie<C> tree = null;
 

src/com/jwetherell/algorithms/data_structures/SuffixTree.java

@@ -27,6 +27,6 @@ public void testAVLTree() {
         assertTrue(TreeTest.testTree(bst, Type.Integer, bstName, 
                                      data.unsorted, data.invalid));
         assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.Integer, bstName, 
-                                                 data.unsorted, data.sorted));
+                                                 data.unsorted, data.sorted, data.invalid));
     }
 }

src/com/jwetherell/algorithms/data_structures/SuffixTrie.java

@@ -28,6 +28,12 @@
                 SkipListTests.class,
                 SplayTreeTests.class,
                 StackTests.class,
+                SuffixTreeTests.class,
+                SuffixTrieTests.class,
+                TreapTests.class,
+                TreeMapTests.class,
+                TrieTests.class,
+                TrieMapTests.class
                }
              )
 

src/com/jwetherell/algorithms/data_structures/test/AVLTreeTests.java

@@ -25,6 +25,6 @@ public void testBTree() {
 
         assertTrue(TreeTest.testTree(bst, Type.Integer, bstName, data.unsorted, data.invalid));
         assertTrue(JavaCollectionTest.testCollection(bstCollection, Type.Integer, bstName,
-                                                 data.unsorted, data.sorted));
+                                                     data.unsorted, data.sorted, data.invalid));
     }
 }

src/com/jwetherell/algorithms/data_structures/test/AllTests.java

@@ -1,6 +1,6 @@
 package com.jwetherell.algorithms.data_structures.test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
 
 import java.util.Collection;
 
@@ -17,23 +17,23 @@ public class BinaryHeapTests {
 
     @Test
     public void testMinHeap() {
-        TestData data = Utils.generateTestData(1000);
+        TestData data = Utils.generateTestData(100);
 
         String aNameMin = "Min-Heap [array]";
         BinaryHeap.BinaryHeapArray<Integer> aHeapMin = new BinaryHeap.BinaryHeapArray<Integer>(BinaryHeap.Type.MIN);
         Collection<Integer> aCollectionMin = aHeapMin.toCollection();
-        assertTrue(HeapTest.testHeap(aHeapMin, aNameMin, BinaryHeap.Type.MIN, 
+        assertTrue(HeapTest.testHeap(BinaryHeap.Type.MIN, aHeapMin, Type.Integer, aNameMin,  
                                      data.unsorted, data.sorted, data.invalid));
         assertTrue(JavaCollectionTest.testCollection(aCollectionMin, Type.Integer, aNameMin,
-                                                 data.unsorted, data.sorted));
+                                                     data.unsorted, data.sorted, data.invalid));
 
         String tNameMin = "Min-Heap [tree]";
         BinaryHeap.BinaryHeapTree<Integer> tHeapMin = new BinaryHeap.BinaryHeapTree<Integer>(BinaryHeap.Type.MIN);
         Collection<Integer> tCollectionMin = tHeapMin.toCollection();
-        assertTrue(HeapTest.testHeap(tHeapMin, tNameMin, BinaryHeap.Type.MIN,
+        assertTrue(HeapTest.testHeap(BinaryHeap.Type.MIN, tHeapMin, Type.Integer, tNameMin,
                                      data.unsorted, data.sorted, data.invalid));
         assertTrue(JavaCollectionTest.testCollection(tCollectionMin, Type.Integer, tNameMin,
-                                                 data.unsorted, data.sorted));
+                                                     data.unsorted, data.sorted, data.invalid));
     }
 
     @Test
@@ -43,17 +43,17 @@ public void testMaxHeap() {
         String aNameMax = "Max-Heap [array]";
         BinaryHeap.BinaryHeapArray<Integer> aHeapMax = new BinaryHeap.BinaryHeapArray<Integer>(BinaryHeap.Type.MAX);
         Collection<Integer> aCollectionMax = aHeapMax.toCollection();
-        assertTrue(HeapTest.testHeap(aHeapMax, aNameMax, BinaryHeap.Type.MAX,
+        assertTrue(HeapTest.testHeap(BinaryHeap.Type.MAX, aHeapMax, Type.Integer, aNameMax, 
                                      data.unsorted, data.sorted, data.invalid));
         assertTrue(JavaCollectionTest.testCollection(aCollectionMax, Type.Integer, aNameMax,
-                                                 data.unsorted, data.sorted));
+                                                 data.unsorted, data.sorted, data.invalid));
 
         String lNameMax = "Max-Heap [tree]";
         BinaryHeap.BinaryHeapTree<Integer> tHeapMax = new BinaryHeap.BinaryHeapTree<Integer>(BinaryHeap.Type.MAX);
         Collection<Integer> tCollectionMax = tHeapMax.toCollection();
-        assertTrue(HeapTest.testHeap(tHeapMax, lNameMax, BinaryHeap.Type.MAX,
+        assertTrue(HeapTest.testHeap(BinaryHeap.Type.MAX, tHeapMax, Type.Integer, lNameMax, 
                                      data.unsorted, data.sorted, data.invalid));
         assertTrue(JavaCollectionTest.testCollection(tCollectionMax, Type.Integer, lNameMax,
-                                                 data.unsorted, data.sorted));
+                                                 data.unsorted, data.sorted, data.invalid));
     }
 }