feat: Complete implementation and testing of segment tree

Author: 4ndrelim

src/main/java/dataStructures/segmentTree/README.md

@@ -0,0 +1 @@
+# Segment Tree

src/main/java/dataStructures/segmentTree/SegmentTree.java

@@ -1,9 +1,15 @@
 package dataStructures.segmentTree;
 
+/**
+ * Implementation of a Segment Tree. Uses SegmentTreeNode as a helper node class.
+ */
 public class SegmentTree {
     private SegmentTreeNode root;
     private int[] array;
 
+    /**
+     * Helper node class. Used internally.
+     */
     private class SegmentTreeNode {
         private SegmentTreeNode leftChild;   // left child
         private SegmentTreeNode rightChild;  // right child
@@ -21,13 +27,17 @@ private class SegmentTreeNode {
          */
         public SegmentTreeNode(SegmentTreeNode leftChild, SegmentTreeNode rightChild, int start, int end, int sum) {
             this.leftChild = leftChild;
-            this.rightChild = rightChild
+            this.rightChild = rightChild;
             this.start = start;
             this.end = end;
             this.sum = sum;
         }
     }
 
+    /**
+     * Constructor.
+     * @param nums
+     */
     public SegmentTree(int[] nums) {
         root = buildTree(nums, 0, nums.length - 1);
         array = nums;
@@ -37,7 +47,7 @@ private SegmentTreeNode buildTree(int[] nums, int start, int end) {
         if (start == end) {
             return new SegmentTreeNode(null, null, start, end, nums[start]);
         }
-        int mid = start + (end-start) / 2;
+        int mid = start + (end - start) / 2;
         SegmentTreeNode left = buildTree(nums, start, mid);
         SegmentTreeNode right = buildTree(nums, mid + 1, end);
         return new SegmentTreeNode(left, right, start, end, left.sum + right.sum);
@@ -68,10 +78,10 @@ private int query(SegmentTreeNode node, int leftEnd, int rightEnd) {
         // poss 2:             ^            ^
         // poss 3:                       ^      ^
         if (leftEnd <= mid) {
-            rangeSum += query(node.leftChild, leftEnd, Math.min(rightEnd, mid)); // poss1 / poss2
+            rangeSum += query(node.leftChild, leftEnd, Math.min(rightEnd, mid)); // poss1 or poss2
         }
         if (mid + 1 <= rightEnd) {
-            rangeSum += query(node.rightChild, Math.max(leftEnd, mid + 1), rightEnd); // poss2 / poss2
+            rangeSum += query(node.rightChild, Math.max(leftEnd, mid + 1), rightEnd); // poss2 or poss3
         }
         return rangeSum;
     }
@@ -91,13 +101,14 @@ public void update(int idx, int val) {
     private void update(SegmentTreeNode node, int idx, int val) {
         if (node.start == node.end && node.start == idx) {
             node.sum = val; // previously, node held a single value; now updated
+            return;
         }
         int mid = node.start + (node.end - node.start) / 2;
         if (idx <= mid) {
             update(node.leftChild, idx, val);
         } else {
             update(node.rightChild, idx, val);
         }
-        node.sum = node.leftChild.sum  + node.rightChild.sum; // propagate updates up
+        node.sum = node.leftChild.sum + node.rightChild.sum; // propagate updates up
     }
 }

src/test/java/dataStructures/segmentTree/SegmentTreeTest.java

@@ -0,0 +1,39 @@
+package dataStructures.segmentTree;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class SegmentTreeTest {
+    @Test
+    public void construct_shouldConstructSegmentTree() {
+        int[] arr1 = new int[] {7, 77, 37, 67, 33, 73, 13, 2, 7, 17, 87, 53};
+        SegmentTree tree1 = new SegmentTree(arr1);
+        assertEquals(arr1[1] + arr1[2] + arr1[3], tree1.query(1, 3));
+        assertEquals(arr1[4] + arr1[5] + arr1[6] + arr1[7], tree1.query(4, 7));
+        int sum1 = 0;
+        for (int i = 0; i < arr1.length; i++) {
+            sum1 += arr1[i];
+        }
+        assertEquals(sum1, tree1.query(0, arr1.length - 1));
+
+
+        int[] arr2 = new int[] {7, -77, 37, 67, -33, 0, 73, -13, 2, -7, 17, 0, -87, 53, 0}; // some negatives and 0s
+        SegmentTree tree2 = new SegmentTree(arr1);
+        assertEquals(arr1[1] + arr1[2] + arr1[3], tree2.query(1, 3));
+        assertEquals(arr1[4] + arr1[5] + arr1[6] + arr1[7], tree2.query(4, 7));
+        int sum2 = 0;
+        for (int i = 0; i < arr1.length; i++) {
+            sum2 += arr1[i];
+        }
+        assertEquals(sum2, tree2.query(0, arr1.length - 1));
+    }
+
+    @Test
+    public void update_shouldUpdateSegmentTree() {
+        int[] arr = new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        SegmentTree tree = new SegmentTree(arr);
+        assertEquals(55, tree.query(0, 10));
+        tree.update(5, 55);
+        assertEquals(105, tree.query(0, 10));
+    }
+}