[Leetcode]307. Range Sum Query - Mutable 数组区间和 - 可变

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:

1. The array is only modifiable by the update function.
2. You may assume the number of calls to update and sumRange function is distributed evenly.

 

 

思路：

线段树

1. 将给定数组的信息转到线段树。 用recursion来build tree

2. 在建好的线段树上进行sumRange()操作， 时间复杂度为O(logn)

3. 在建好的线段树上进行update()操作， 时间复杂度为O(logn)

 

代码

class NumArray {
    private SegmentTreeNode root;   
    /*Time Complexity: O(n)
      Build SegmentTree
     */
    public NumArray (int[] nums) {
        this.root = buildTree(nums, 0, nums.length - 1);
    }
    private SegmentTreeNode buildTree(int[] nums, int start, int end) {
        if (start > end) return null;
        SegmentTreeNode node = new SegmentTreeNode(start, end);
        if (start == end) {
            node.val = nums[start];
        } else {
            int mid = start + (end - start) / 2;
            node.left = buildTree(nums, start, mid);
            node.right = buildTree(nums, mid + 1, end);
            node.val = node.left.val + node.right.val;
        }
        return node;    
    }
    /* Time Complexity: O(log n)
       update()
     */
    public void update(int i, int val) {
        update(this.root, i, val);
    }
    void update(SegmentTreeNode root, int i, int val) {
        if (root.start == root.end) {
            root.val = val;
            return;
        }
        int middle = root.start + (root.end - root.start) / 2;
        if (i <= middle) {
            update(root.left, i, val);
        } else {
            update(root.right, i, val);
        }
        root.val = root.left.val + root.right.val;
    }
    /* Time Complexity: O(log n)
       sumRange()
     */
    public int sumRange(int i, int j) {
        return sumRange(this.root, i, j);
    }
    int sumRange(SegmentTreeNode root, int start, int end) {
        if (root.end == end && root.start == start) return root.val;
        int mid = root.start + (root.end - root.start) / 2;
        if (end <= mid) {
            return sumRange(root.left, start, end);
        } else if (start >= mid + 1) {
            return sumRange(root.right, start, end);
        } else {
            return sumRange(root.right, mid + 1, end) + sumRange(root.left, start, mid);
        }
    }

    class SegmentTreeNode {
        int start;
        int end;
        int val;
        SegmentTreeNode left;
        SegmentTreeNode right;

        public SegmentTreeNode(int start, int end) {
            this.start = start;
            this.end = end;
            this.val = 0;
        }
    }
}