feat: Implement array-based version of Segment Tree for fun

Author: 4ndrelim

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

@@ -27,6 +27,20 @@ That said, in practice, the array-based implementation of a heap often provides
 former, in cache efficiency and memory locality. This is due to its contiguous memory layout. As such,
 the implementation shown here is a 0-indexed array-based heap.
 
+#### Obtain index representing child nodes
+Suppose the parent node is captured at index *i* of the array (1-indexed).
+**1-indexed**: <br>
+Left Child: *i* x 2 <br>
+Right Child:  *i* x 2 + 1 <br>
+
+The 1-indexed calculation is intuitive. So, when dealing with 0-indexed representation (as in our implementation), 
+one option is to convert 0-indexed to 1-indexed representation, do the above calculations, and revert. <br>
+(Note: Now, we assume parent node is captured at index *i* (0-indexed))
+
+**0-indexed**: <br>
+Left Child: (*i* + 1) x 2 - 1  = *i* x 2 + 1 <br>
+Right Child: (*i* + 1) x 2 + 1 - 1 = *i* x 2 + 2 <br>
+
 ### Relevance of increaseKey and decreaseKey operations
 
 The decision not to include explicit "decrease key" and "increase key" operations in the standard implementations of

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

@@ -95,6 +95,7 @@ public void update(int idx, int val) {
         if (idx > array.length) {
             return;
         }
+        array[idx] = val;
         update(root, idx, val);
     }
 

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

@@ -0,0 +1,105 @@
+package dataStructures.segmentTree.arrayRepresentation;
+
+/**
+ * Array-based implementation of a Segment Tree.
+ */
+public class SegmentTree {
+    private int[] tree;
+    private int[] array;
+
+    /**
+     * Constructor.
+     * @param nums
+     */
+    public SegmentTree(int[] nums) {
+        tree = new int[4 * nums.length];  // Need to account for up to 4n nodes.
+        array = nums;
+        buildTree(nums, 0, nums.length - 1, 0);
+    }
+
+    /**
+     * Builds the tree from the given array of numbers.
+     * Unlikely before where we capture child nodes in the helper node class, here we capture position of child nodes
+     * in the array-representation of the tree with an additional variable.
+     * @param nums
+     * @param start
+     * @param end
+     * @param idx tells us which index of the tree array we are at.
+     */
+    private void buildTree(int[] nums, int start, int end, int idx) {
+        // recall, each node is a position in the array
+        // explicitly track which position in the array to fill with idx variable
+        if (start == end) {
+            tree[idx] = nums[start];
+            return;
+        }
+        int mid = start + (end - start) / 2;
+        int idxLeftChild = (idx + 1) * 2 - 1; // convert from 0-based to 1-based, do computation, then revert
+        buildTree(nums, start, mid, idxLeftChild);
+        int idxRightChild = (idx + 1) * 2 + 1 - 1; // convert from 0-based to 1-based, do computation, then revert
+        buildTree(nums, mid + 1, end, idxRightChild);
+        tree[idx] = tree[idxLeftChild] + tree[idxRightChild];
+    }
+
+    /**
+     * Queries the sum of all values in the specified range.
+     * @param leftEnd
+     * @param rightEnd
+     * @return the sum.
+     */
+    public int query(int leftEnd, int rightEnd) {
+        return query(0, 0, array.length - 1, leftEnd, rightEnd);
+    }
+
+    private int query(int nodeIdx, int startRange, int endRange, int leftEnd, int rightEnd) {
+        // this is the case when:
+        //                start     end
+        // range query:   ^           ^  --> so simply capture the sum at this node!
+        if (leftEnd <= startRange && endRange <= rightEnd) {
+            return tree[nodeIdx];
+        }
+        int rangeSum = 0;
+        int mid = startRange + (endRange - startRange) / 2;
+        // Consider the 3 possible kinds of range queries
+        //           start          mid          end
+        // poss 1:         ^      ^
+        // poss 2:             ^            ^
+        // poss 3:                       ^      ^
+        if (leftEnd <= mid) {
+            int idxLeftChild = (nodeIdx + 1) * 2 - 1;
+            rangeSum += query(idxLeftChild, startRange, mid, leftEnd, Math.min(rightEnd, mid));
+        }
+        if (mid + 1 <= rightEnd) {
+            int idxRightChild = (nodeIdx + 1) * 2 + 1 - 1;
+            rangeSum += query(idxRightChild, mid + 1, endRange, Math.max(leftEnd, mid + 1), rightEnd);
+        }
+        return rangeSum;
+    }
+
+    /**
+     * Updates the segment tree based on updates to the array at the specified index with the specified value.
+     * @param idx
+     * @param val
+     */
+    public void update(int idx, int val) {
+        if (idx > array.length) {
+            return;
+        }
+        array[idx] = val;
+        update(0, 0, array.length - 1, idx, val);
+    }
+
+    private void update(int nodeIdx, int startRange, int endRange, int idx, int val) {
+        if (startRange == endRange) {
+            tree[nodeIdx] = val;
+            return;
+        }
+        int mid = startRange + (endRange - startRange) / 2;
+        if (idx <= mid) {
+            update(nodeIdx * 2 + 1, startRange, mid, idx, val);
+        } else {
+            update(nodeIdx * 2 + 2, mid + 1, endRange, idx, val);
+        }
+        tree[nodeIdx] = tree[nodeIdx * 2 + 1] + tree[nodeIdx * 2 + 2];
+    }
+}

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

@@ -0,0 +1,42 @@
+package dataStructures.segmentTree.arrayRepresentation;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+/**
+ * This file is essentially duplicated from the parent.
+ */
+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));
+    }
+}