线段树知识点模版详解

线段树详解

第一部分

1.定义：线段树（Segment Tree）是一种二叉搜索树，它将一个区间划分成一些单元区间，每个单元区间对应线段树

中的一个叶结点。对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为

[(a+b)/2,b]。因此线段树是满二叉树，最后的子节点数目为N，即整个线段区间的长度。使用线段树可以快速的查找某

一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，因此有时需要离散化让

空间压缩。

2.从一个小问题引出线段树

问题：在自然数，且所有的数不大于30000的范围内讨论一个问题：现在已知n条线段，把端点依次输入告诉你，然

后有m个询问，每个询问输入一个点，要求这个点在多少条线段上出现过；

基本解法（一）分析：最基本的解法当然就是读一个点，就把所有线段比一下，看看在不在线段中；每次询问都要

把n条线段查一次，那么m次询问，就要运算m*n次，复杂度就是O(m*n)道题m和n都是30000，那么计算量达到10^9；

而计算机1秒的计算量大约是10^8的数量级，所以这种方法无论怎么优化都是超时。因为n条线段是固定的，所以某种

程度上说每次都把n条线段查一遍有大量的重复和浪费；线段树就是可以解决这类问题的数据结构

线段树解题：

已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次？

在[0,7]区间上建立一棵满二叉树：

每个节点用结构体：struct line{int left,right;//左端点、右端点int n;//记录这条线段出现了多少次，默认为0}a[16];//和堆类似，满二叉树的性质决定a[i]的左儿子是a[2*i]、右儿子是a[2*i+1];然后对于已知的线段依次进行插入操作：从树根开始调用递归函数insertvoid insert(int s,int t,int step)//要插入的线段的左端点和右端点、以及当前线段树中的某条线段{if (s==a[step].left && t==a[step].right){a[step].n++;//插入的线段匹配则此条线段的记录+1return;//插入结束返回}if (a[step].left==a[step].right) return;//当前线段树的线段没有儿子，插入结束返回int mid=(a[step].left+a[step].right)/2;if (mid>=t) insert(s,t,step*2);//如果中点在t的右边，则应该插入到左儿子else if (mid<t) insert(t,s,step*2+1);else//否则，中点一定在s和t之间，把待插线段分成两半分别插到左右儿子里面{insert(s,mid,step*2);insert(mid+1,t,step*2+1);}}

 三条已知线段插入过程：

[2,5]

--[2,5]与【0,7】比较，分成两部分：[2,3]插到左儿子【0,3】，[4,5]插到右儿子【4,7】

--[2,3]与【0,3】比较，插到右儿子【2,3】；[4,5]和【4,7】比较，插到左儿子【4,5】

--[2,3]与【2,3】匹配，【2,3】记录+1；[4,5]与【4,5】匹配，【4,5】记录+1

[4,6]

--[4,6]与【0,7】比较，插到右儿子【4,7】

--[4,6]与【4,7】比较，分成两部分，[4,5]插到左儿子【4,5】；[6,6]插到右儿子【6,7】

--[4,5]与【4,5】匹配，【4,5】记录+1；[6,6]与【6,7】比较，插到左儿子【6,6】

--[6,6]与【6,6】匹配，【6,6】记录+1

[0,7]

--[0,7]与【0,7】匹配，【0,7】记录+1

插入过程结束，线段树上的记录如下（红色数字为每条线段的记录n）：

询问操作和插入操作类似，也是递归过程，略

2——依次把【0,7】 【0,3】 【2,3】 【2,2】的记录n加起来，结果为2

4——依次把【0,7】 【4,7】 【4,5】 【4,4】的记录n加起来，结果为3

7——依次把【0,7】 【4,7】 【6,7】 【7,7】的记录n加起来，结果为1

不管是插入操作还是查询操作，每次操作的执行次数仅为树的深度——logN

建树有n次插入操作，n*logN，一次查询要logN，m次就是m*logN；总共复杂度O(n+m)*logN，这道题N不超过

30000，logN约等于14，所以计算量在10^5～10^6之间，比普通方法快了1000倍；

这道题是线段树最基本的操作，只用到了插入和查找；删除操作和插入类似，扩展功能的还有测度、连续段数等等，

在N数据范围很大的时候，依然可以用离散化的方法建树。

第二部分：

一 概述

线段树，类似区间树，它在各个节点保存一条线段（数组中的一段子数组），主要用于高效解决连续区间的动态查询问题，由于二叉结构的特性，它基本能保持每个操作的复杂度为O(logn)。

线段树的每个节点表示一个区间，子节点则分别表示父节点的左右半区间，例如父亲的区间是[a,b]，那么(c=(a+b)/2)左儿子的区间是[a,c]，右儿子的区间是[c+1,b]。

二 从一个例子理解线段树

下面我们从一个经典的例子来了解线段树，问题描述如下:从数组arr[0...n-1]中查找某个数组某个区间内的最小值，其中数组大小固定，但是数组中的元素的值可以随时更新。

对这个问题一个简单的解法是：遍历数组区间找到最小值，时间复杂度是O(n),额外的空间复杂度O(1)。当数据量特别大，而查询操作很频繁的时候，耗时可能会不满足需求。

另一种解法：使用一个二维数组来保存提前计算好的区间[i,j]内的最小值，那么预处理时间为O(n^2)，查询耗时O(1), 但是需要额外的O(n^2)空间，当数据量很大时，这个空间消耗是庞大的，而且当改变了数组中的某一个值时，更新二维数组中的最小值也很麻烦。

我们可以用线段树来解决这个问题：预处理耗时O(n)，查询、更新操作O(logn)，需要额外的空间O(n)。根据这个问题我们构造如下的二叉树

• 叶子节点是原始组数arr中的元素
• 非叶子节点代表它的所有子孙叶子节点所在区间的最小值

例如对于数组[2, 5, 1, 4, 9, 3]可以构造如下的二叉树（背景为白色表示叶子节点，非叶子节点的值是其对应数组区间内的最小值，例如根节点表示数组区间arr[0...5]内的最小值是1）：                                                                                                                           本文地址

由于线段树的父节点区间是平均分割到左右子树，因此线段树是完全二叉树，对于包含n个叶子节点的完全二叉树，它一定有n-1个非叶节点，总共2n-1个节点，因此存储线段是需要的空间复杂度是O(n)。那么线段树的操作：创建线段树、查询、节点更新 是如何运作的呢（以下所有代码都是针对求区间最小值问题）？

2.1 创建线段树

对于线段树我们可以选择和普通二叉树一样的链式结构。由于线段树是完全二叉树，我们也可以用数组来存储，下面的讨论及代码都是数组来存储线段树，节点结构如下（注意到用数组存储时，有效空间为2n-1,实际空间确不止这么多，比如上面的线段树中叶子节点1、3虽然没有左右子树，但是的确占用了数组空间，实际空间是满二叉树的节点数目，但是这个空间复杂度也是O(n)的 ）。

struct SegTreeNode

{

　　int val;

}；

定义包含n个节点的线段树 SegTreeNode segTree[n]，segTree[0]表示根节点。那么对于节点segTree[i]，它的左孩子是segTree[2*i+1],右孩子是segTree[2*i+2]。

我们可以从根节点开始，平分区间，递归的创建线段树，线段树的创建函数如下：

 1 const int MAXNUM = 1000; 2 struct SegTreeNode 3 { 4     int val; 5 }segTree[MAXNUM];//定义线段树 6  7 /* 8 功能：构建线段树 9 root：当前线段树的根节点下标10 arr: 用来构造线段树的数组11 istart：数组的起始位置12 iend：数组的结束位置13 */14 void build(int root, int arr[], int istart, int iend)15 {16     if(istart == iend)//叶子节点17         segTree[root].val = arr[istart];18     else19     {20         int mid = (istart + iend) / 2;21         build(root*2+1, arr, istart, mid);//递归构造左子树22         build(root*2+2, arr, mid+1, iend);//递归构造右子树23         //根据左右子树根节点的值，更新当前根节点的值24         segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);25     }26 }

2.2 查询线段树

已经构建好了线段树，那么怎样在它上面超找某个区间的最小值呢？查询的思想是选出一些区间，使他们相连后恰好涵盖整个查询区间，因此线段树适合解决“相邻的区间的信息可以被合并成两个区间的并区间的信息”的问题。代码如下，具体见代码解释

 1 /* 2 功能：线段树的区间查询 3 root：当前线段树的根节点下标 4 [nstart, nend]: 当前节点所表示的区间 5 [qstart, qend]: 此次查询的区间 6 */ 7 int query(int root, int nstart, int nend, int qstart, int qend) 8 { 9     //查询区间和当前节点区间没有交集10     if(qstart > nend || qend < nstart)11         return INFINITE;12     //当前节点区间包含在查询区间内13     if(qstart <= nstart && qend >= nend)14         return segTree[root].val;15     //分别从左右子树查询，返回两者查询结果的较小值16     int mid = (nstart + nend) / 2;17     return min(query(root*2+1, nstart, mid, qstart, qend),18                query(root*2+2, mid + 1, nend, qstart, qend));19 20 }

举例说明（对照上面的二叉树）：

1、当我们要查询区间[0,2]的最小值时，从根节点开始，要分别查询左右子树，查询左子树时节点区间[0,2]包含在查询区间[0,2]内，返回当前节点的值1，查询右子树时，节点区间[3,5]和查询区间[0,2]没有交集，返回正无穷INFINITE，查询结果取两子树查询结果的较小值1，因此结果是1.

2、查询区间[0,3]时，从根节点开始，查询左子树的节点区间[0,2]包含在区间[0,3]内，返回当前节点的值1；查询右子树时，继续递归查询右子树的左右子树，查询到非叶节点4时，又要继续递归查询：叶子节点4的节点区间[3,3]包含在查询区间[0,3]内，返回4，叶子节点9的节点区间[4,4]和[0,3]没有交集，返回INFINITE,因此非叶节点4返回的是min(4, INFINITE) = 4，叶子节点3的节点区间[5,5]和[0,3]没有交集，返回INFINITE,因此非叶节点3返回min(4, INFINITE) = 4, 因此根节点返回 min(1,4) = 1。

2.3单节点更新

单节点更新是指只更新线段树的某个叶子节点的值，但是更新叶子节点会对其父节点的值产生影响，因此更新子节点后，要回溯更新其父节点的值。

 1 /* 2 功能：更新线段树中某个叶子节点的值 3 root：当前线段树的根节点下标 4 [nstart, nend]: 当前节点所表示的区间 5 index: 待更新节点在原始数组arr中的下标 6 addVal: 更新的值（原来的值加上addVal） 7 */ 8 void updateOne(int root, int nstart, int nend, int index, int addVal) 9 {10     if(nstart == nend)11     {12         if(index == nstart)//找到了相应的节点，更新之13             segTree[root].val += addVal;14         return;15     }16     int mid = (nstart + nend) / 2;17     if(index <= mid)//在左子树中更新18         updateOne(root*2+1, nstart, mid, index, addVal);19     else updateOne(root*2+2, mid+1, nend, index, addVal);//在右子树中更新20     //根据左右子树的值回溯更新当前节点的值21     segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);22 }

比如我们要更新叶子节点4（addVal = 6）,更新后值变为10，那么其父节点的值从4变为9，非叶结点3的值更新后不变，根节点更新后也不变。

2.4 区间更新

区间更新是指更新某个区间内的叶子节点的值，因为涉及到的叶子节点不止一个，而叶子节点会影响其相应的非叶父节点，那么回溯需要更新的非叶子节点也会有很多，如果一次性更新完，操作的时间复杂度肯定不是O(lgn)，例如当我们要更新区间[0,3]内的叶子节点时，需要更新出了叶子节点3,9外的所有其他节点。为此引入了线段树中的延迟标记概念，这也是线段树的精华所在。

延迟标记：每个节点新增加一个标记，记录这个节点是否进行了某种修改(这种修改操作会影响其子节点)，对于任意区间的修改，我们先按照区间查询的方式将其划分成线段树中的节点，然后修改这些节点的信息，并给这些节点标记上代表这种修改操作的标记。在修改和查询的时候，如果我们到了一个节点p，并且决定考虑其子节点，那么我们就要看节点p是否被标记，如果有，就要按照标记修改其子节点的信息，并且给子节点都标上相同的标记，同时消掉节点p的标记。

因此需要在线段树结构中加入延迟标记域，本文例子中我们加入标记与addMark，表示节点的子孙节点在原来的值的基础上加上addMark的值，同时还需要修改创建函数build 和 查询函数 query，修改的代码用红色字体表示，其中区间更新的函数为update，代码如下：

  1 const int INFINITE = INT_MAX;  2 const int MAXNUM = 1000;  3 struct SegTreeNode  4 {  5     int val;  6     int addMark;//延迟标记  7 }segTree[MAXNUM];//定义线段树  8   9 /* 10 功能：构建线段树 11 root：当前线段树的根节点下标 12 arr: 用来构造线段树的数组 13 istart：数组的起始位置 14 iend：数组的结束位置 15 */ 16 void build(int root, int arr[], int istart, int iend) 17 { 18     segTree[root].addMark = 0;//----设置标延迟记域 19     if(istart == iend)//叶子节点 20         segTree[root].val = arr[istart]; 21     else 22     { 23         int mid = (istart + iend) / 2; 24         build(root*2+1, arr, istart, mid);//递归构造左子树 25         build(root*2+2, arr, mid+1, iend);//递归构造右子树 26         //根据左右子树根节点的值，更新当前根节点的值 27         segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val); 28     } 29 } 30  31 /* 32 功能：当前节点的标志域向孩子节点传递 33 root: 当前线段树的根节点下标 34 */ 35 void pushDown(int root) 36 { 37     if(segTree[root].addMark != 0) 38     { 39         //设置左右孩子节点的标志域，因为孩子节点可能被多次延迟标记又没有向下传递 40         //所以是 “+=” 41         segTree[root*2+1].addMark += segTree[root].addMark; 42         segTree[root*2+2].addMark += segTree[root].addMark; 43         //根据标志域设置孩子节点的值。因为我们是求区间最小值，因此当区间内每个元 44         //素加上一个值时，区间的最小值也加上这个值 45         segTree[root*2+1].val += segTree[root].addMark; 46         segTree[root*2+2].val += segTree[root].addMark; 47         //传递后，当前节点标记域清空 48         segTree[root].addMark = 0; 49     } 50 } 51  52 /* 53 功能：线段树的区间查询 54 root：当前线段树的根节点下标 55 [nstart, nend]: 当前节点所表示的区间 56 [qstart, qend]: 此次查询的区间 57 */ 58 int query(int root, int nstart, int nend, int qstart, int qend) 59 { 60     //查询区间和当前节点区间没有交集 61     if(qstart > nend || qend < nstart) 62         return INFINITE; 63     //当前节点区间包含在查询区间内 64     if(qstart <= nstart && qend >= nend) 65         return segTree[root].val; 66     //分别从左右子树查询，返回两者查询结果的较小值 67     pushDown(root); //----延迟标志域向下传递 68     int mid = (nstart + nend) / 2; 69     return min(query(root*2+1, nstart, mid, qstart, qend), 70                query(root*2+2, mid + 1, nend, qstart, qend)); 71  72 } 73  74 /* 75 功能：更新线段树中某个区间内叶子节点的值 76 root：当前线段树的根节点下标 77 [nstart, nend]: 当前节点所表示的区间 78 [ustart, uend]: 待更新的区间 79 addVal: 更新的值（原来的值加上addVal） 80 */ 81 void update(int root, int nstart, int nend, int ustart, int uend, int addVal) 82 { 83     //更新区间和当前节点区间没有交集 84     if(ustart > nend || uend < nstart) 85         return ; 86     //当前节点区间包含在更新区间内 87     if(ustart <= nstart && uend >= nend) 88     { 89         segTree[root].addMark += addVal; 90         segTree[root].val += addVal; 91         return ; 92     } 93     pushDown(root); //延迟标记向下传递 94     //更新左右孩子节点 95     int mid = (nstart + nend) / 2; 96     update(root*2+1, nstart, mid, ustart, uend, addVal); 97     update(root*2+2, mid+1, nend, ustart, uend, addVal); 98     //根据左右子树的值回溯更新当前节点的值 99     segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);100 }

区间更新举例说明：当我们要对区间[0,2]的叶子节点增加2，利用区间查询的方法从根节点开始找到了非叶子节点[0-2]，把它的值设置为1+2 = 3，并且把它的延迟标记设置为2，更新完毕；当我们要查询区间[0,1]内的最小值时，查找到区间[0,2]时，发现它的标记不为0，并且还要向下搜索，因此要把标记向下传递，把节点[0-1]的值设置为2+2 = 4，标记设置为2，节点[2-2]的值设置为1+2 = 3，标记设置为2（其实叶子节点的标志是不起作用的，这里是为了操作的一致性），然后返回查询结果：[0-1]节点的值4；当我们再次更新区间[0,1]（增加3）时，查询到节点[0-1],发现它的标记值为2，因此把它的标记值设置为2+3 = 5，节点的值设置为4+3 = 7；

其实当区间更新的区间左右值相等时（[i,i]），就相当于单节点更新，单节点更新只是区间更新的特例。

第三部分

1：概述

线段树，类似区间树，是一个完全二叉树，它在各个节点保存一条线段（数组中的一段子数组），主要用于高效解决连续区间的动态查询问题，由于二叉结构的特性，它基本能保持每个操作的复杂度为O(lgN)!

性质：父亲的区间是[a,b],(c=(a+b)/2)左儿子的区间是[a,c]，右儿子的区间是[c+1,b]，线段树需要的空间为数组大小的四倍

2：基本操作（demo用的是查询区间最小值）

线段树的主要操作有：

(1)：线段树的构造 void build(int node, int begin, int end);

主要思想是递归构造，如果当前节点记录的区间只有一个值，则直接赋值，否则递归构造左右子树，最后回溯的时候给当前节点赋值

1. #include <iostream>  
2. using namespace std;  
3.   
4. const int maxind = 256;  
5. int segTree[maxind * 4 + 10];  
6. int array[maxind];   
7. /* 构造函数，得到线段树 */  
8. void build(int node, int begin, int end)    
9. {    
10.     if (begin == end)    
11.         segTree[node] = array[begin]; /* 只有一个元素,节点记录该单元素 */  
12.     else    
13.     {     
14.         /* 递归构造左右子树 */   
15.         build(2*node, begin, (begin+end)/2);    
16.         build(2*node+1, (begin+end)/2+1, end);   
17.            
18.         /* 回溯时得到当前node节点的线段信息 */    
19.         if (segTree[2 * node] <= segTree[2 * node + 1])    
20.             segTree[node] = segTree[2 * node];    
21.         else    
22.             segTree[node] = segTree[2 * node + 1];    
23.     }    
24. }  
25.   
26. int main()  
27. {  
28.     array[0] = 1, array[1] = 2,array[2] = 2, array[3] = 4, array[4] = 1, array[5] = 3;  
29.     build(1, 0, 5);  
30.     for(int i = 1; i<=20; ++i)  
31.      cout<< "seg"<< i << "=" <<segTree[i] <<endl;  
32.     return 0;  
33. }   

 此build构造成的树如图：

(2)：区间查询int query(int node, int begin, int end, int left, int right);

（其中node为当前查询节点，begin,end为当前节点存储的区间，left,right为此次query所要查询的区间）

主要思想是把所要查询的区间[a,b]划分为线段树上的节点，然后将这些节点代表的区间合并起来得到所需信息

比如前面一个图中所示的树，如果询问区间是[0,2]，或者询问的区间是[3,3]，不难直接找到对应的节点回答这一问题。但并不是所有的提问都这么容易回答，比如[0,3]，就没有哪一个节点记录了这个区间的最小值。当然，解决方法也不难找到：把[0,2]和[3,3]两个区间（它们在整数意义上是相连的两个区间）的最小值“合并”起来，也就是求这两个最小值的最小值，就能求出[0,3]范围的最小值。同理，对于其他询问的区间，也都可以找到若干个相连的区间，合并后可以得到询问的区间。

1. int query(int node, int begin, int end, int left, int right)    
2. {   
3.     int p1, p2;    
4.     
5.     /*  查询区间和要求的区间没有交集  */  
6.     if (left > end || right < begin)    
7.         return -1;    
8.     
9.     /*  if the current interval is included in  */    
10.     /*  the query interval return segTree[node]  */  
11.     if (begin >= left && end <= right)    
12.         return segTree[node];    
13.     
14.     /*  compute the minimum position in the  */  
15.     /*  left and right part of the interval  */   
16.     p1 = query(2 * node, begin, (begin + end) / 2, left, right);   
17.     p2 = query(2 * node + 1, (begin + end) / 2 + 1, end, left, right);    
18.     
19.     /*  return the expect value  */   
20.     if (p1 == -1)    
21.         return p2;    
22.     if (p2 == -1)    
23.         return p1;    
24.     if (p1 <= p2)    
25.         return  p1;    
26.     return  p2;      
27. }   

可见，这样的过程一定选出了尽量少的区间，它们相连后正好涵盖了整个[left,right]，没有重复也没有遗漏。同时，考虑到线段树上每层的节点最多会被选取2个，一共选取的节点数也是O(log n)的，因此查询的时间复杂度也是O(log n)。

线段树并不适合所有区间查询情况，它的使用条件是“相邻的区间的信息可以被合并成两个区间的并区间的信息”。即问题是可以被分解解决的。

(3)：区间或节点的更新 及 线段树的动态维护update （这是线段树核心价值所在，节点中的标记域可以解决N多种问题）

动态维护需要用到标记域，延迟标记等。

a:单节点更新

1. void Updata(int node, int begin, int end, int ind, int add)/*单节点更新*/    
2. {    
3.     
4.     if( begin == end )    
5.     {    
6.         segTree[node] += add;    
7.         return ;    
8.     }    
9.     int m = ( left + right ) >> 1;    
10.     if(ind <= m)    
11.         Updata(node * 2,left, m, ind, add);    
12.     else    
13.         Updata(node * 2 + 1, m + 1, right, ind, add);    
14.     /*回溯更新父节点*/    
15.     segTree[node] = min(segTree[node * 2], segTree[node * 2 + 1]);     
16.          
17. }   

b：区间更新（线段树中最有用的）

需要用到延迟标记，每个结点新增加一个标记，记录这个结点是否被进行了某种修改操作(这种修改操作会影响其子结点)。对于任意区间的修改，我们先按照查询的方式将其划分成线段树中的结点，然后修改这些结点的信息，并给这些结点标上代表这种修改操作的标记。在修改和查询的时候，如果我们到了一个结点p，并且决定考虑其子结点，那么我们就要看看结点p有没有标记，如果有，就要按照标记修改其子结点的信息，并且给子结点都标上相同的标记，同时消掉p的标记。（优点在于，不用将区间内的所有值都暴力更新，大大提高效率，因此区间更新是最优用的操作）

void Change来自dongxicheng.org

1. void Change(node *p, int a, int b) /* 当前考察结点为p，修改区间为(a,b]*/  
2.    
3. {  
4.    
5.   if (a <= p->Left && p->Right <= b)  
6.    
7.   /* 如果当前结点的区间包含在修改区间内*/  
8.    
9.   {  
10.    
11.      ...... /* 修改当前结点的信息，并标上标记*/  
12.    
13.      return;  
14.    
15.   }  
16.    
17.   Push_Down(p); /* 把当前结点的标记向下传递*/  
18.    
19.   int mid = (p->Left + p->Right) / 2; /* 计算左右子结点的分隔点 
20.   
21.   if (a < mid) Change(p->Lch, a, b); /* 和左孩子有交集，考察左子结点*/  
22.    
23.   if (b > mid) Change(p->Rch, a, b); /* 和右孩子有交集，考察右子结点*/  
24.    
25.   Update(p); /* 维护当前结点的信息（因为其子结点的信息可能有更改）*/  
26.    
27. }  

参考地址：http://www.cnblogs.com/TenosDoIt/p/3453089.html

http://baike.sogou.com/v490596.htm?fromTitle=%E7%BA%BF%E6%AE%B5%E6%A0%91

http://blog.csdn.net/metalseed/article/details/8039326

http://blog.csdn.net/zearot/article/details/48299459