leetcode 307. Range Sum Query - Mutable

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、下面是自己开始写的原始方式。

2、后面有学习的线段树的方式。

class NumArray {
public:
    NumArray(vector<int> nums) 
    {
        if (!nums.empty())
        {
            num = nums;
            sum.push_back(num[0]);
            for (int i = 1; i < num.size(); i++)
                sum.push_back(sum[i - 1] + num[i]);
        }
    }
    
    void update(int i, int val) 
    {
        
        for (int k = i; k < num.size(); k++)
        {
            sum[k] += val - num[i];
        }
        num[i] = val;
    }
    
    int sumRange(int i, int j) 
    {
        if (i == 0) return sum[j];
        return sum[j] - sum[i - 1];    
    }
private:
    vector<int> sum; //前n项和
    vector<int> num;
};

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * obj.update(i,val);
 * int param_2 = obj.sumRange(i,j);
 */

2、线段树

自己写的线段树，使用的是节点的左右子树来截断：

#include <iostream>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <math.h>

using namespace std;

class MYPoint{
public:
    MYPoint(int b, int c) : start(b), end(c)
    {
        sum = 0;
        left = nullptr;
        right = nullptr;
    }
    const int start;
    const int end;
    int sum;
    MYPoint* left;
    MYPoint* right;
};

class NumArray {
public:
    NumArray(vector<int> nums)
    {
        if (nums.empty())
            return;
        root = new MYPoint(0, nums.size() - 1);
        NumArrayBuilder(root, nums);
    }
    
    void update(int i, int val)
    {
        updateHelper(i, val, root);
    }
    
    int sumRange(int i, int j)
    {
        return sumhelper(i ,j, root);
    }
private:
    MYPoint* root;
    
    void NumArrayBuilder(MYPoint* root, vector<int>& nums)
    {
        //停止
        if (root->start == root->end)
        {
            root->sum = nums[root->start];
            return;
        }
        
        int mid = (root->end - root->start) / 2 + root->start;
        MYPoint* left = new MYPoint(root->start, mid);
        MYPoint* right = new MYPoint(mid + 1, root->end);
        
        root->left = left;
        root->right = right;
        
        NumArrayBuilder(root->left, nums);
        NumArrayBuilder(root->right, nums);
        
        root->sum = root->left->sum + root->right->sum;
    }
    
    void updateHelper(int pos, int newkey, MYPoint* root)
    {
        if (root->left == root->right)  //找到了最小的节点
        {
            root->sum = newkey;
            return;
        }
        
        int mid = (root->end - root->start) / 2 + root->start;
        if (pos <= mid) //修改的位置在左边
            updateHelper(pos, newkey, root->left);
        else if (pos > mid)
            updateHelper(pos, newkey, root->right);
        
        root->sum = root->left->sum + root->right->sum; //关键步骤，从下往上把新的数据传上来。而且能到这一步说明肯定有左右子树。
    }
    
    int sumhelper(int i, int j, MYPoint* root)
    {
        if (i == root->start && j == root->end)
            return root->sum;
        
        int mid = (root->end - root->start) / 2 + root->start;
        if (j <= mid)       //都在左子树
            return sumhelper(i, j, root->left);
        else if (i > mid)   //都在右子树
            return sumhelper(i, j, root->right);
        else                //左右都有
            return sumhelper(i, mid, root->left) + sumhelper(mid + 1, j, root->right);
    }
};

int main()
{
    vector<int> vt{1, 3, 5};
    NumArray test(vt);
    cout<<test.sumRange(0, 2)<<endl;
    test.update(1, 2);
    cout<<test.sumRange(0, 2)<<endl;
    return 0;
}

下面是参考别人的线段树。

class NumArray {
public:
    NumArray(vector<int> nums) 
    {
        if (!nums.empty())
        {
            Num = nums;
            for (int i = 0; i < Num.size() * 4; i++)
                TreeSum.push_back(0);
            Build(1, 0, Num.size() - 1);   
        }
    }
    
    /*i表示当前递归编号,l,r分别表示当前点的左右区间*/
    /* Tree数组是存储 线段树的数组 */
    void Build(int i, int l, int r) 
    {
        if (l == r) 
        {
            TreeSum[i] = Num[l];
            return;
        }
        int Mid = (l + r) / 2;
        Build(i * 2, l, Mid);
        Build(i * 2 + 1, Mid + 1, r);
        PushUp(i);  //下面的子节点，需要把 和 传上来      
    }
    
    void update(int i, int val) 
    {
        Update_Single(1, 0, Num.size() - 1, i, val);
    }
    
    /*i为当前编号,L,R为左右区间,A为修改点的编号,B为修改的值*/
    void Update_Single(int i, int L, int R, int A, int B) 
    {
        if (L == R) 
        {
            /*如果找到了,修改值*/
            TreeSum[i] = B;
            return;
        }
        int Mid = (L + R) / 2;
        if  (A <= Mid) 
            Update_Single(i * 2, L, Mid, A, B); /*递归左子树*/
        else 
            Update_Single(i * 2 + 1, Mid + 1, R, A, B); /*递归右子树*/
        PushUp(i); //下面的子节点，需要把 修改后的和 传上来 
    }
    
    int sumRange(int i, int j) 
    {
        return Quary_Total(1, 0, Num.size() - 1, i, j);
    }
    
    /*i 为当前编号, L, R为当前i节点的区间。 l、r 是使用者查询的区间*/    
    int Quary_Total(int i, int L, int R, int l, int r) 
    {
        if (l == L && r == R) return TreeSum[i]; /*如果刚好是在当前区间*/
        int Mid = (L + R) / 2;
        if(l <= Mid && r > Mid)  //查询区间 在当前区间 的 左右两小部分 都有的情况
            return Quary_Total(i * 2, L, Mid, l, Mid) + Quary_Total(i * 2 + 1, Mid + 1, R, Mid + 1, r);
        else if (r <= Mid) //只在左边部分 
            return Quary_Total(i * 2, L, Mid, l, r); /*递归左子树*/
        else if (l > Mid)  //只在右边部分 
            return Quary_Total(i * 2 + 1, Mid + 1, R, l, r); /*递归右子树*/
    }
    
    /*区间和处理*/
    void PushUp(int Now) 
    {
        TreeSum[Now] = TreeSum[Now * 2] + TreeSum[Now * 2 + 1];
    }
    
private: 
    vector<int> TreeSum;  //注意 TreeSum编号是从1开始的
    vector<int> Num;    //只在最开始build的时候有用   
};

/**
 * Your NumArray object will be instantiated and called as such:
 * NumArray obj = new NumArray(nums);
 * obj.update(i,val);
 * int param_2 = obj.sumRange(i,j);
 */