Leetcode: Range Sum Query - Mutable && Summary: Segment Tree

Given an integer array nums, find the sum of the elements between indices i and j (i ≤ j), inclusive.

The update(i, val) function modifies nums by updating the element at index i to val.
Example:
Given nums = [1, 3, 5]

sumRange(0, 2) -> 9
update(1, 2)
sumRange(0, 2) -> 8
Note:
The array is only modifiable by the update function.
You may assume the number of calls to update and sumRange function is distributed evenly.

Introduction of Segment Tree: http://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/

Time Complexity:
Time Complexity for tree construction is O(n). There are total 2n-1 nodes, and value of every node is calculated only once in tree construction.

Time complexity to query is O(Logn). To query a sum, we process at most four nodes at every level and number of levels is O(Logn).

The time complexity of update is also O(Logn). To update a leaf value, we process one node at every level and number of levels is O(Logn).

public class NumArray {
    SegmentTreeNode root;

    public NumArray(int[] nums) {
        this.root = buildTree(nums, 0, nums.length-1);
    }

    void update(int i, int val) {
        update(root, i, val);
    }

    public int sumRange(int i, int j) {
        return sumRange(root, i, j);
    }
    
    public SegmentTreeNode buildTree(int[] nums, int start, int end) {
            if (start > end) return null;
            else {
                SegmentTreeNode cur = new SegmentTreeNode(start, end);
                if (start == end) {
                    cur.sum = nums[start];
                }
                else {
                    int mid = start + (end - start)/2;
                    cur.left = buildTree(nums, start, mid);
                    cur.right = buildTree(nums, mid+1, end);
                    cur.sum = cur.left.sum + cur.right.sum;
                }
                return cur;
            }
    }
        
    public void update(SegmentTreeNode root, int i, int val) {
            if (root.start == root.end) { //leaf node
                root.sum = val;
                return;
            }
            else {
                int mid = root.start + (root.end - root.start)/2;
                if (i <= mid) update(root.left, i, val);
                else update(root.right, i, val);
                root.sum = root.left.sum + root.right.sum;
            }
    }
        
    public int sumRange(SegmentTreeNode root, int i, int j) {
            if (i==root.start && j==root.end) return root.sum;
            else {
                int mid = root.start + (root.end - root.start)/2;
                if (j <= mid) return sumRange(root.left, i, j);
                else if (i >= mid+1) return sumRange(root.right, i, j);
                else 
                    return sumRange(root.left, i, mid) + sumRange(root.right, mid+1, j);
            }
    }
        
    
    public class SegmentTreeNode{
        int sum;
        int start;
        int end;
        SegmentTreeNode left;
        SegmentTreeNode right;
        
        public SegmentTreeNode(int start, int end) {
            this.sum = 0;
            this.start = start;
            this.end = end;
            this.left = null;
            this.right = null;
        }
        
    }
}


// Your NumArray object will be instantiated and called as such:
// NumArray numArray = new NumArray(nums);
// numArray.sumRange(0, 1);
// numArray.update(1, 10);
// numArray.sumRange(1, 2);