线段树

用于区间查询和修改，优化其时间复杂度

区间长度为len = 10，每个节点 l 和　ｒ表示区间ｌ－ｒ的，根节点为１－１０

对于每个节点，左孩子的区间为：　［　ｌ　－　（ｌ＋ｒ）／２　］

右孩子的区间为：　［（ｌ＋ｒ）／２＋１　－　ｒ］

可以用数组来表示这棵二叉树

树的深度为 logn

修改和查询：

将第v个数值加x

若 v = 3 ，x =5

从根节点开始，将[1-10]里的sum值更新，3在左孩子，进入左孩子

将[1-5]里的sum值更新，3在左孩子，进入左孩子

将[1-3]里的sum值更新，3在右孩子，进入右孩子

将[3-3]里的sum值更新，因为是根节点，所以更新完了

因为树的深度为，所以每次修改的时间复杂度为O（logn）

// modify(1,1,10,3,5);
// p表示从根节点开始，l和r表示左区间和右区间，v表示修改的位置，x修改值
void modify(int p,int l,int r,int v,int x)
{
    s[p] += v;
    if(l==r)
    {
        return 0;
    }
    int mid = (l+r)>>1;
    if(x <= mid)
    {
        modify(p*2,l,mid,v,x);
    }else 
    {
        modify(p*2+1,mid+1,v,x);
    }
}

也可以先找到 [3-3]所在的子节点，然后回溯更新每个节点的值

void modify1(int p,int l,int r,int v,int x)
{
    if(l==r)
    {
        s[p] += v;
        return ;
    }
    int mid = (l+r)>>1;
    if(x <= mid)
    {
        modify(p*2,l,mid,v,x);
    }
    if(x > mid)
    {
        modify(p*2,mid+1,r,v,x);
    }
    up(p);
}

查询：

如果要查询的区间为[3-6]

从节点开始，

因为查询区间[3-5]，既在左区间，又在右区间，所以分别查询 左孩子[1-5]和右孩子[6-10]

​ 对于左孩子[1-5],查询区间[3-5],既在左区间，又在右区间，所以分别查询 左孩子[1-3]和右孩子[4-5]

​ 对于左孩子[1-3],查询区间[3-5],只在左区间，所以查询右孩子[3-3].

​ 对于右孩子[4-5],查询区间[3-5]将其包含，所以返回改区间值

​ 对于右孩子[6-10],查询区间[3-5],在左区间，所以查询左孩子[6-8];

​ 同理查询[6-8]

​ 同理查询[6-7],

​ 同理查询[6-6],此时将该区间值返回

所以真正要返回值的区间为 [3-3] [4-5] [6-6]

void query(int p,int l,int r,int x,int y)
{
    if(x <= l && r >= y )
    {
        return s[p];
    }
    int mid = (l+r)>>1;
    if(x<=mid)
    {
        res += query(p*2,l,mid,x,v);
    }
    if(y>mid)
    {
        res += query(p*2,mid+1,r,x,v);
    }
    return res ;
}

斑点蛇

问题描述

有一种神奇斑点蛇，蛇如其名，全身都是斑点，斑点数量可以任意改变。
有一天，蒜头君十分的无聊，开始数蛇上的斑点。假设这条蛇的长度是N cm，蒜头君已经数完开始时蛇身的第i上有ai个斑点。
现在蒜头君想知道这条斑点蛇的任意区间的蛇身上一共有多少个斑点。这好像是一个很容易的
事情，但是这条蛇好像是和蒜头君过不去，总是刻意的改变蛇身上的斑点数量。
于是，蒜头君受不了了，加上蒜头君有密集型恐惧症。聪明又能干的你能帮帮他吗？
输入格式
第一行一个正整数 N（N≤50000）表示这条斑点蛇长度为 N 厘米，接下来有 N 个正整数，第 i 个正整数 ai​ 代表第 i 个斑点蛇第 i 厘米开始时有 ai​ 个斑点（1≤ai​≤50）。
接下来每行有一条命令，命令有 4 种形式：
(1) Add i j，i 和 j 为正整数，表示第 i 厘米增加 j 个斑点（j 不超过 30）；
(2) Sub i j，i 和 j 为正整数，表示第 i 厘米减少 j 个斑点（j 不超过 30）；
(3) Query i j，i 和 j 为正整数，i≤j，表示询问第 i 到第 j 厘米的斑点总数（包括第 i 厘米和第 j 厘米）；
(4) End 表示结束，这条命令在每组数据最后出现；
最多有 40000 条命令。
输出格式
对于每个 Query 询问，输出一个整数并回车，表示询问的段中的总斑点数，这个数保证在int范围内。
样例输入
10
1 2 3 4 5 6 7 8 9 10
Query 1 3
Add 3 6
Query 2 7
Sub 10 2
Add 6 3
Query 3 10
End
样例输出
6
33
59

这里是C++代码

#include <iostream>
using namespace std;
const int MAX_N = 50010;
int s[4*MAX_N];
int arr[MAX_N];
void up(int p)
{
    s[p] = s[p*2]+s[p*2+1];
}
void modify(int p,int l,int r,int x,int v)
{
    if(l==r)
    {
        s[p]+=v;
        return ;
    }
    int mid = (l+r)/2;
    if(x<=mid)
    {
        modify(p*2,l,mid,x,v);
    }else 
    {
        modify(p*2+1,mid+1,r,x,v);
    }
    up(p);
}

int query(int p,int l,int r,int x,int y)
{
    if(x<=l && r<=y)
    {
        return s[p];
    }
    int mid = (l+r)/2,res=0;
    if(x<=mid)
    {
        res+=query(p*2,l,mid,x,y);
    }
    if(y>mid)
    {
        res+=query(p*2+1,mid+1,r,x,y);
    }
    return res;
}

int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;++i)
    {
        cin>>arr[i];
        modify(1,1,n,i,arr[i]);
    }    
    string s;
    int x,y;
    while(cin>>s)
    {
        if(s[0]=='E')
        {
            break;
        }else if(s[0]=='S')
        {
            cin>>x>>y;
            modify(1,1,n,x,-y);
        }else if(s[0]=='A')
        {
            cin>>x>>y;
            modify(1,1,n,x,y);
        }else if(s[0]=='Q')
        {
            cin>>x>>y;
            cout<<query(1,1,n,x,y)<<endl;
        }
    } 
    return 0;
}

这里是java代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
    static int maxn = (int) (5e4+10);
    static int[] s = new int[4*maxn];
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(reader.readLine());
        String[] string = reader.readLine().split(" ");
        for (int i=1; i<=N; ++i) {
            int x = Integer.parseInt(string[i-1]);
            modify(1, 1, N, i, x);
        }
        while(true) {
            String[] tmpstr = reader.readLine().split(" ");
            String inst = tmpstr[0];
            if(inst.equals("End")) {
                break;
            } else if(inst.equals("Add")) {
                int i = Integer.parseInt(tmpstr[1]);
                int j = Integer.parseInt(tmpstr[2]);
                modify(1, 1, N, i, j);
            } else if(inst.equals("Sub")) {
                int i = Integer.parseInt(tmpstr[1]);
                int j = Integer.parseInt(tmpstr[2]);
                modify(1, 1, N, i, -j);
            } else if(inst.equals("Query")){
                int i = Integer.parseInt(tmpstr[1]);
                int j = Integer.parseInt(tmpstr[2]);
                System.out.println(query (1, 1, N, i, j));
            }
        }
    }
    private static void up(int p) {
        s[p] = s[p*2] + s[p*2+1];
    }
    private static void modify(int p, int l, int r, int x, int v) {
        if(l==r) {
            s[p] += v;
            return;
        }
        int mid = (l+r)/2;
        if(x<=mid) {
            modify(p*2, l, mid, x, v);
        } else {
            modify(p*2+1, mid+1, r, x, v);
        }
        up(p);
    }
    
    private static int query(int p, int l, int r, int x, int y) {
        if(x<=l && r<=y) {
            return s[p];
        }
        int mid = (l+r)/2, res = 0;
        if(x<=mid) {
            res += query(p*2, l, mid, x, y);
        }
        if(y>mid) {
            res += query(p*2+1, mid+1, r, x, y);
        }
        return res;
    }
}

​

​