数据结构: 线段树

简介

线段树是一种二叉树形数据结构，1977年由Jon Louis Bentley发明， 上面的每个节点用来存储区间和线段，特别的，叶子节点存储长度为1的线段，即一个值。对区间的查找和节点的更新都可以在$O(logN)$的内完成。其空间复杂度为$O(4N)$。运用延迟更新技术，其可用于区间的更新，时间复杂度仍然为$O(logN)$。

树节点

const int MAXN = 100000;
struct Node
{
    int start;
    int end;
    int data;
    int mark;
}segment_tree[MAXN*4];

• start：区间的起始
• end：区间的结束
• data：节点的值, 代表区间[start, end)的属性 (根据实际问题赋值）
• mark：用于延迟更新(根据实际问题赋值）
• 注意1： 这篇博客遵循传统的$STL$库，区间采用前开后闭的形式，即$[start,end)$。
• 注意2： 这篇博客我们采用查询区间[a,b)的最小值， 单点改变某个值，对区间[a，b)的每个数加减一个数进行举例。

建树

线段树的建立是一个线段的二分过程。采用递归建树的方法。

• 示意图:对数组 [4,1,2,3,5,6] 建树
  
  • 绿色节点: 叶子节点。
  • 节点中数字: 代表区间。
  • 红色数字: 代表节点存在于实际数组中的下标。
  • data: 该区间最小值，data值的计算是自底向上的。
  • mark：区间改变量。因为只是初始化，因此改变量为0。
• 代码：根据示意图，很容易写出递归建树代码

void build(int start, int end, int index)
{
    /*
    [start, end): 目前建立节点负责区间负责区间
    index:        目前建立结点在segment_tree数组中的下标
    
    使用方式： 如针对数据： int base[6] = {4,1,2,3,5,6};
               调用build(0, 6, 0)完成建树
    */
    
    // 赋值区间
    segment_tree[index].start = start ;
    segment_tree[index].end = end;
    
     // 如果已经到了叶子节点
    if(segment_tree[index].start == segment_tree[index].end - 1)
    {
        segment_tree[index].data = base[segment_tree[index].start];
        segment_tree[index].mark = 0;
        return;
    }
    
    // 递归建左子树和右子树
    int mid = (start + end) >> 1;
    build(start, mid, (index << 1) + 1);
    build(mid, end, (index << 1) + 2);
    
    // 根据左儿子右儿子更新当前结点的值
    segment_tree[index].data = min(segment_tree[(index << 1) + 1].data, segment_tree[(index << 1) + 2].data);
    segment_tree[index].mark = 0;
}

区间查询

区间查询，即查询给定区间[a, b)的最小值。

• 查询策略: 若当前结点为Node
  
• 例: 在上方树中，查询区间[1, 5)最小值
  
  • 黄色：需要细化查询， 返回左右儿子返回值的最小值。
  • 绿色：完全被[1,5)覆盖，直接返回当前data。
  • 红色：[1,5)之外的区间，不应该影响最终结果，返回一个极大值。
• 代码：根据示意图，很容易写出代码：

int query(int a, int b, int index)
{
    /*
    [a, b): 查询区间
    index:  当前查询节点在segment_tree数组中的下标

    返回:   [a,b)和[Node.start, Node.end)交集的最小值。 其中Node = segment_tree[index]
    */

    // 情况一：完全覆盖
    if(a <= segment_tree[index].start && segment_tree[index].end <= b)
    {
        return segment_tree[index].data;
    }

    // 情况二：交集为空
    else if(a >= segment_tree[index].end || b <= segment_tree[index].start)
    {
        return INF;
    }

    // 情况三：细化查询
    int v1 = query(a, b, (index << 1) + 1);
    int v2 = query(a, b, (index << 1) + 2);
    return min(v1, v2);
}

单点改变

现在我们要改变线段树叶子节点的某一个值。比如将第1个值1改为3。很明显，我们需要先定位，更改，再将影响向上传播。示意图如下:

• 代码：根据示意图，很容易写出代码:

void update_one(int p, int x, int index)
{
    /*
    p:   要更改的元素位置
    x:   将位置p的元素更改为x
    index:  当前结点在segment_tree数组中的下标
    */

    // 定位成功
    if(segment_tree[index].start == p && segment_tree[index].start == segment_tree[index].end-1)
    {
        segment_tree[index].data = x;
        return;
    }

    int mid = (segment_tree[index].start + segment_tree[index].end) >> 1;

    // 需要更改的位置在右子树
    if(p >= mid)
    {
        update_one(p, x, (index << 1) + 2);
    }

    // 需要更改的位置在左子树
    else
    {
        update_one(p, x, (index << 1) + 1);
    }
    // 根据左右儿子更新当前结点值
    segment_tree[index].data = min(segment_tree[(index << 1) + 1].data, segment_tree[(index << 1) + 2].data);
}

区间改变

这里我们模拟将整个区间[a, b)整体加上一个数字c。 可用的策略是对区间[a, b)的每个数都进行一个单点更新，但是最终会导致O(NlogN)的时间复杂度。为了降低复杂度，我们引入延时更新策略：

• (1)完全包含: 区间[a,b)完全包含[Node.start, Node,end)，那我们先将该更新记录到Node的mark中，并只更新Node的data， 同时更新其祖先的值。
• (2)毫不相交：不做处理
• (3)需要细化： 直到细化区间更新或者细化区间查询操作到来, 我们将父节点记录的更新信息传递给子节点。

现在我们逐一解释该策略：

• 对(1): 如图，我们对区间[1,3)的每个数都增加3， 因此我们将代表区间[1,3)的节点的mark值记为3，并更新其data，更新后，我们便不再继续向下更新，而是直接返回并更新其祖先的值。

• 对(3): 遇到细化区间更新，比如在更区间[1,3)基础上，我们希望再将区间[0,2)的值增加2。因为[0,2)和区间[1,3)有交集也有不同。因此我们先将[1,3)的更新信息传递到子节点。
  
  然后再执行对[0,2)加2的更新操作
  
  最后完成更新。
• 代码：根据图示，我们很容易写出代码

void push_down(int index)
{
    /*
    将segment_tree[index]的段更新信息传递到子节点，并清除掉自己的标记
    */
    int mark = segment_tree[index].mark;
    if(mark != 0)
    {
        segment_tree[(index << 1) + 1].mark += mark;
        segment_tree[(index << 1) + 2].mark += mark;
        segment_tree[(index << 1) + 1].data += mark;
        segment_tree[(index << 1) + 2].data += mark;
    }
    segment_tree[index].mark = 0;
}

void update_seg(int a, int b, int add, int index)
{
    /*
    [a, b): 需要更新的区间
    add:    区间[a, b)需要增加的数
    index:  当前结点在segment_tree中的下标
    */

    // 情况一: 完全包含, 只维护该节点与其祖先
    if(a <= segment_tree[index].start && segment_tree[index].end <= b)
    {
        segment_tree[index].data += add;
        segment_tree[index].mark += add;
        return;
    }

    // 情况二：完全不相交，跳过
    else if(a >= segment_tree[index].end || b <= segment_tree[index].start)
    {
        return;
    }

    // 情况三：需要细化更新
    push_down(index);  // 将当前结点保存的更新信息推向儿子节点
    update_seg(a, b, add, (index << 1) + 1);
    update_seg(a, b, add, (index << 1) + 2);

    segment_tree[index].data = min(segment_tree[(index << 1) + 1].data, segment_tree[(index << 1) + 2].data);
}

• 对(3): 遇到细化区间查询是指在如下状态时：

我们希望查询[0,2)的最小值。这时我们需要将[1,3)区间的节点的更新信息先传递下去。

这样，我们才能查询到[1,2)节点的最新信息。

• 代码：我们只需要对原始代码稍作修改

int query(int a, int b, int index)
{
    /*
    [a, b): 查询区间
    index:  当前查询节点在segment_tree数组中的下标

    返回:   [a,b)和[Node.start, Node.end)交集的最小值。 其中Node = segment_tree[index]
    */

    // 情况一：完全覆盖
    if(a <= segment_tree[index].start && segment_tree[index].end <= b)
    {
        return segment_tree[index].data;
    }

    // 情况二：交集为空
    else if(a >= segment_tree[index].end || b <= segment_tree[index].start)
    {
        return INF;
    }

    // 情况三：细化查询
    // --------------------加入此行---------------------------------
    push_down(index);
    // -----------------------------------------------------------
    int v1 = query(a, b, (index << 1) + 1);
    int v2 = query(a, b, (index << 1) + 2);
    return min(v1, v2);
}

例题

• Balanced Lineup(维护区间最大最小值，区间查询)
• Minimizing maximizer(动态规划+维护区间最小值，单点更新)
• A Simple Problem with Integers(维护区间和，区间整体更新查询)
• Crane(维护区间向量和, 区间整体更新查询)

博客示例完整代码

#include
using namespace std;
const int MAXN = 100000;
const int INF = 100000+5;
struct Node
{
    int start;
    int end;
    int data;
    int mark;
}segment_tree[MAXN*4];

int base[MAXN];
void build(int start, int end, int index)
{
    /*
    [start, end): 目前建立节点负责区间负责区间
    index:        目前建立结点在segment_tree数组中的下标

    使用方式： 针对数据： int base[6] = {4,1,2,3,5,6};
               调用build(0, 6, 0)完成建树
    */

    // 赋值区间
    segment_tree[index].start = start ;
    segment_tree[index].end = end;

     // 如果已经到了叶子节点
    if(segment_tree[index].start == segment_tree[index].end - 1)
    {
        segment_tree[index].data = base[segment_tree[index].start];
        segment_tree[index].mark = 0;
        return;
    }

    // 递归建左子树和右子树
    int mid = (start + end) >> 1;
    build(start, mid, (index << 1) + 1);
    build(mid, end, (index << 1) + 2);

    // 根据左儿子右儿子更新当前结点的值
    segment_tree[index].data = min(segment_tree[(index << 1) + 1].data, segment_tree[(index << 1) + 2].data);
    segment_tree[index].mark = 0;
}


void update_one(int p, int x, int index)
{
    /*
    p:   要更改的元素位置
    x:   将位置p的元素更改为x
    index:  当前结点在segment_tree数组中的下标
    */

    // 定位成功
    if(segment_tree[index].start == p && segment_tree[index].start == segment_tree[index].end-1)
    {
        segment_tree[index].data = x;
        return;
    }

    int mid = (segment_tree[index].start + segment_tree[index].end) >> 1;

    // 需要更改的位置在右子树
    if(p >= mid)
    {
        update_one(p, x, (index << 1) + 2);
    }

    // 需要更改的位置在左子树
    else
    {
        update_one(p, x, (index << 1) + 1);
    }
    // 根据左右儿子更新当前结点值
    segment_tree[index].data = min(segment_tree[(index << 1) + 1].data, segment_tree[(index << 1) + 2].data);
}

void push_down(int index)
{
    /*
    将segment_tree[index]的段更新信息传递到子节点，并清除掉自己的标记
    */
    int mark = segment_tree[index].mark;
    if(mark != 0)
    {
        segment_tree[(index << 1) + 1].mark += mark;
        segment_tree[(index << 1) + 2].mark += mark;
        segment_tree[(index << 1) + 1].data += mark;
        segment_tree[(index << 1) + 2].data += mark;
    }
    segment_tree[index].mark = 0;
}

void update_seg(int a, int b, int add, int index)
{
    /*
    [a, b): 需要更新的区间
    add:    区间[a, b)需要增加的数
    index:  当前结点在segment_tree中的下标
    */

    // 情况一: 完全包含, 只维护该节点与其祖先
    if(a <= segment_tree[index].start && segment_tree[index].end <= b)
    {
        segment_tree[index].data += add;
        segment_tree[index].mark += add;
        return;
    }

    // 情况二：完全不相交，跳过
    else if(a >= segment_tree[index].end || b <= segment_tree[index].start)
    {
        return;
    }

    // 情况三：需要细化更新
    push_down(index);  // 将当前结点保存的更新信息推向儿子节点
    update_seg(a, b, add, (index << 1) + 1);
    update_seg(a, b, add, (index << 1) + 2);

    segment_tree[index].data = min(segment_tree[(index << 1) + 1].data, segment_tree[(index << 1) + 2].data);
}
int query(int a, int b, int index)
{
    /*
    [a, b): 查询区间
    index:  当前查询节点在segment_tree数组中的下标

    返回:   [a,b)和[Node.start, Node.end)交集的最小值。 其中Node = segment_tree[index]
    */

    // 情况一：完全覆盖
    if(a <= segment_tree[index].start && segment_tree[index].end <= b)
    {
        return segment_tree[index].data;
    }

    // 情况二：交集为空
    else if(a >= segment_tree[index].end || b <= segment_tree[index].start)
    {
        return INF;
    }

    // 情况三：细化查询
    push_down(index);
    int v1 = query(a, b, (index << 1) + 1);
    int v2 = query(a, b, (index << 1) + 2);
    return min(v1, v2);
}

int main()
{
    int n;
    cout << "输入数组长度:" << endl;
    cin >> n;
    cout << "输入" << n << "个整数(空格隔开):" << endl;
    for(int i=0; i> base[i];
    }
    cout << "正在建树.." << endl;
    build(0, n, 0);
    cout << "建树完成.." << endl;

    int op;
    int a, b;
    int add;
    int pos;
    int x;
    do{
        cout << "输入操作：" << endl;
        cout << "0: 退出\n1: 查询区间最小值\n2: 单点改变某个值\n3: 区间整体增加某个值\n";
        cin >> op;
        if(op == 1)
        {
            cout << "输入区间起始位置a,b(区间为:[a, b)):" << endl;
            cin >> a >> b;
            cout << "区间[" << a << "," << b << ")最小值为:";
            cout << query(a, b, 0) << endl;
        }
        else if(op == 2)
        {
            cout << "输入改变值的位置:";
            cin >> pos;
            cout << "输入改变后的值:";
            cin >> x;
            update_one(pos, x, 0);
            cout << "单点改变成功" << endl;
        }
        else if(op == 3)
        {
             cout << "输入区间其实位置a,b(区间为:[a, b))" << endl;
             cin >> a >> b;
             cout << "要增加的值:" << endl;
             cin >> add;
             update_seg(a, b, add, 0);
             cout << "区间更改成功" << endl;
        }
        cout << endl << endl;
    }while(op != 0);
    return 0;
}