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);