Updated IntervalSum and LowestCommonAncestor

Author: phishman3579

src/com/jwetherell/algorithms/data_structures/IntervalSumArray.java renamed to src/com/jwetherell/algorithms/data_structures/IntervalSum.java

@@ -10,15 +10,15 @@
  * @author Szymon Stankiewicz <dakurels@gmail.com>
  * @author Justin Wetherell <phishman3579@gmail.com>
  */
-public class IntervalSumArray {
+public class IntervalSum {
 
     private List<Integer> values = new ArrayList<Integer>();
     private List<Integer> prefSums = new ArrayList<Integer>();
 
     /**
      * Creates empty IntervalSumArray
      */
-    public IntervalSumArray() {
+    public IntervalSum() {
         values.add(0);
         prefSums.add(0);
     }
@@ -30,7 +30,7 @@ public IntervalSumArray() {
      *
      * @param size size of IntervalSumArray
      */
-    public IntervalSumArray(int size) {
+    public IntervalSum(int size) {
         for (int i = 0; i<size; i++) {
             values.add(0);
             prefSums.add(0);
@@ -44,7 +44,7 @@ public IntervalSumArray(int size) {
      *
      * @param values sequence of values for IntervalSumArray.
      */
-    public IntervalSumArray(Iterable<Integer> values) {
+    public IntervalSum(Iterable<Integer> values) {
         for (Integer v: values)
             add(v);
     }

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

@@ -32,7 +32,7 @@ public static class NodesNotInSameTreeException extends Exception {
      * @return lower common ancestor
      * @throws NodesNotInSameTreeException if nodes don't have common root
      */
-    public static <S> RootedTree<S> lowestCommonAncestor(RootedTree<S> node1, RootedTree<S> node2) throws NodesNotInSameTreeException {
+    public static <S> TreeNode<S> lowestCommonAncestor(TreeNode<S> node1, TreeNode<S> node2) throws NodesNotInSameTreeException {
         if (node1 == node2) 
             return node1;
         else if (node1.depth < node2.depth) 
@@ -67,30 +67,30 @@ else if (node1.depth > node2.depth) {
         }
     }
 
-    public static final class RootedTree<T> {
+    public static final class TreeNode<T> {
 
-        private final List<RootedTree<T>> ancestors = new ArrayList<RootedTree<T>>();
-        private final List<RootedTree<T>> children = new ArrayList<RootedTree<T>>();
+        private final List<TreeNode<T>>     ancestors   = new ArrayList<TreeNode<T>>();
+        private final List<TreeNode<T>>     children    = new ArrayList<TreeNode<T>>();
 
-        private T value = null;
-        private int depth = 0;
+        private T                           value       = null;
+        private int                         depth       = 0;
 
         /**
          * Creates tree with root only.
          *
          */
-        public RootedTree() { }
+        public TreeNode() { }
 
         /**
          * Creates tree with root (storing value) only.
          *
          * @param value value to be stored in root
          */
-        public RootedTree(T value) {
+        public TreeNode(T value) {
             this.value = value;
         }
 
-        private RootedTree(RootedTree<T> parent) {
+        private TreeNode(TreeNode<T> parent) {
             parent.children.add(this);
             this.ancestors.add(parent);
             this.depth = parent.depth + 1;
@@ -105,7 +105,7 @@ private RootedTree(RootedTree<T> parent) {
             }
         }
 
-        public RootedTree<T> setValue(T value) {
+        public TreeNode<T> setValue(T value) {
             this.value = value;
             return this;
         }
@@ -117,8 +117,8 @@ public RootedTree<T> setValue(T value) {
          *
          * @return added child
          */
-        public RootedTree<T> addChild() {
-            return new RootedTree<T>(this);
+        public TreeNode<T> addChild() {
+            return new TreeNode<T>(this);
         }
 
         /**
@@ -129,7 +129,7 @@ public RootedTree<T> addChild() {
          * @param value value to be stored in new child
          * @return added child
          */
-        public RootedTree<T> addChild(T value) {
+        public TreeNode<T> addChild(T value) {
             return addChild().setValue(value);
         }
 
@@ -148,14 +148,14 @@ public T getValue() {
          * @param value value to be find
          * @return subtree with given value in the root
          */
-        public RootedTree<T> find(T value) {
+        public TreeNode<T> find(T value) {
             if (this.value == null) {
                 if (value == null)
                     return this;
             } else if (this.value.equals(value))
                 return this;
-            for (RootedTree<T> child: children) {
-                final RootedTree<T> res = child.find(value);
+            for (TreeNode<T> child: children) {
+                final TreeNode<T> res = child.find(value);
                 if (res != null)
                     return res;
             }

test/com/jwetherell/algorithms/data_structures/test/IntervalSumArrayTest.java renamed to test/com/jwetherell/algorithms/data_structures/test/IntervalSumTest.java

@@ -9,13 +9,13 @@
 
 import org.junit.Test;
 
-import com.jwetherell.algorithms.data_structures.IntervalSumArray;
+import com.jwetherell.algorithms.data_structures.IntervalSum;
 
-public class IntervalSumArrayTest {
+public class IntervalSumTest {
 
     @Test
     public void properSumAllElementsTest() {
-        final IntervalSumArray sub = new IntervalSumArray();
+        final IntervalSum sub = new IntervalSum();
         for (int i = 0; i<=100; i++)
             sub.add(i);
         for (int i = 0; i<=100; i++)
@@ -29,7 +29,7 @@ public void randomGeneratedTest() {
         final List<Integer> list = new ArrayList<Integer>();
         for (int i = 0; i<=100; i++)
             list.add(i);
-        final IntervalSumArray sum = new IntervalSumArray(list);
+        final IntervalSum sum = new IntervalSum(list);
         for (int i = 0; i<1000000; i++) {
             final int pos = generator.nextInt(100);
             final int val = generator.nextInt(2000000) - 1000000;
@@ -55,7 +55,7 @@ public void randomGeneratedTest() {
 
     @Test
     public void setIndexOutOfRangeTest() {
-        final IntervalSumArray sum = new IntervalSumArray(100);
+        final IntervalSum sum = new IntervalSum(100);
         boolean thrown = false;
         try {
             sum.set(101, 10);
@@ -67,7 +67,7 @@ public void setIndexOutOfRangeTest() {
 
     @Test
     public void sumIndexOutOfRangeTest() {
-        final IntervalSumArray sum = new IntervalSumArray(100);
+        final IntervalSum sum = new IntervalSum(100);
         boolean thrown = false;
         try {
             sum.sum(101);
@@ -79,7 +79,7 @@ public void sumIndexOutOfRangeTest() {
 
     @Test
     public void endBeforeStartTest() {
-        final IntervalSumArray sum = new IntervalSumArray(100);
+        final IntervalSum sum = new IntervalSum(100);
         boolean thrown = false;
         try {
             sum.sum(101, 100);

test/com/jwetherell/algorithms/data_structures/test/LowestCommonAncestorTest.java

@@ -9,23 +9,23 @@
 
 import com.jwetherell.algorithms.data_structures.LowestCommonAncestor;
 import com.jwetherell.algorithms.data_structures.LowestCommonAncestor.NodesNotInSameTreeException;
-import com.jwetherell.algorithms.data_structures.LowestCommonAncestor.RootedTree;
+import com.jwetherell.algorithms.data_structures.LowestCommonAncestor.TreeNode;
 
 public class LowestCommonAncestorTest {
 
     @Test
     public void largeTreeTest() throws NodesNotInSameTreeException {
 
-        final RootedTree<Integer> root = new RootedTree<Integer>();
-        final RootedTree<Integer> left = root.addChild();
-        final RootedTree<Integer> middle = root.addChild();
-        final RootedTree<Integer> right = root.addChild();
+        final TreeNode<Integer> root = new TreeNode<Integer>();
+        final TreeNode<Integer> left = root.addChild();
+        final TreeNode<Integer> middle = root.addChild();
+        final TreeNode<Integer> right = root.addChild();
 
         //long path
-        RootedTree<Integer> v = left;
+        TreeNode<Integer> v = left;
         for (int i = 0; i<1000; i++)
             v = v.addChild();
-        RootedTree<Integer> leftRight = left.addChild();
+        TreeNode<Integer> leftRight = left.addChild();
         assertEquals(LowestCommonAncestor.lowestCommonAncestor(v, leftRight), left);
 
         for (int i = 0; i<2000; i++) {
@@ -37,7 +37,7 @@ public void largeTreeTest() throws NodesNotInSameTreeException {
         assertEquals(LowestCommonAncestor.lowestCommonAncestor(root, right), root);
         assertEquals(LowestCommonAncestor.lowestCommonAncestor(root, root), root);
 
-        final RootedTree<Integer> root2 = new RootedTree<Integer>();
+        final TreeNode<Integer> root2 = new TreeNode<Integer>();
         boolean thrownException = false;
         try {
             LowestCommonAncestor.lowestCommonAncestor(v, root2);
@@ -46,7 +46,7 @@ public void largeTreeTest() throws NodesNotInSameTreeException {
         }
         assertTrue(thrownException);
 
-        final RootedTree<Integer> deepChild = v.addChild(101);
+        final TreeNode<Integer> deepChild = v.addChild(101);
         assertEquals(deepChild, root.find(101));
         assertTrue(root.contains(101));