码迷，mamicode.com
首页 > 其他好文 > 详细

线段树（二）

时间：2017-06-26 23:55:17      阅读：256      评论：0      收藏：0      [点我收藏+]

标签：comm   apple   举例   ack   source   value   通过   board   width   

转自：http://blog.csdn.net/liujian20150808/article/details/51137749

 

1.线段树的定义：

线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。

对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。

 

举例描述：

因此有了以上对线段树的定义，我们可以将区间[1,10]的线段树结构描述出来：

技术分享

图片来自于百度百科

有了线段[1,10]的线段树结构，我们可以发现，每个叶节点对应区间范围内的端点[a,a](1<=a<=10)

 

2.构造线段树

显然，当我们将线段树定义清楚之后，那么我们就要想要怎么去实现它。

我们可以观察上图，对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间均为[a,(a+b)/2]，右儿子表示的区间均为[(a+b)/2+1,b]，

因此我们利用线段树的这一特点，可以递归的将这棵线段树构造出来，递归的终止条件也就是我们构造到了叶节点，即此时线段的左右区间相等。

有了以上的思路，我们可以得出以下构造线段树的代码：

 

[cpp] view plain copy
  1. //由区间[left,right]建立一棵线段树  
  2.   
  3. Node *Build(Node *_root,int left,int right){  
  4.     _root = Init(_root,left,right);    //节点初始化  
  5.     if(left != right){            //递归终止条件,表示已经线段树建立到了叶节点  
  6.         _root -> lchild = Build(_root -> lchild,left,(left + right) / 2);  
  7.         _root -> rchild = Build(_root -> rchild,(left + right)/2+1,right);  
  8.     }  
  9.     return _root;        //回溯至最后一层时,则返回整棵树的根节点  
  10. }  


为了检验构造情况是否和上述图示一致，我们可以利用树的中序遍历，查看每个节点存储的线段，因此我们得出以下完整代码：

 

 

[cpp] view plain copy
  1. #include<cstdio>  
  2. #include<cstdlib>  
  3.   
  4. typedef struct node Node;  
  5.   
  6. struct node{  
  7.     int leftvalue;  
  8.     int rightvalue;      //分别用来记录节点记录的区间范围  
  9.     Node *lchild;     //左孩子节点  
  10.     Node *rchild;    //右孩子节点  
  11. };  
  12.   
  13. int flag = 1;      //用于标记当前遍历到哪个节点  
  14. //节点的初始化  
  15. Node *Init(Node *_node,int lvalue,int rvalue){  
  16.     _node = (Node *)malloc(sizeof(Node));  
  17.     _node -> lchild = NULL;  
  18.     _node -> rchild = NULL;  
  19.     _node -> leftvalue = lvalue;  
  20.     _node -> rightvalue = rvalue;  
  21.     return _node;  
  22. }  
  23.   
  24. //由区间[left,right]建立一棵线段树  
  25.   
  26. Node *Build(Node *_root,int left,int right){  
  27.     _root = Init(_root,left,right);    //节点初始化  
  28.     if(left != right){            //递归终止条件,表示已经线段树建立到了叶节点  
  29.         _root -> lchild = Build(_root -> lchild,left,(left + right) / 2);  
  30.         _root -> rchild = Build(_root -> rchild,(left + right)/2+1,right);  
  31.     }  
  32.     return _root;        //回溯至最后一层时,则返回整棵树的根节点  
  33. }  
  34.   
  35. //中序遍历,便于从左往右查看各节点存储的线段区间  
  36.   
  37. void inorder(Node *_node){  
  38.     if(_node){  
  39.         inorder(_node -> lchild);  
  40.         printf("第%d个遍历的节点,存储区间为:[%d,%d]\n",flag++,_node -> leftvalue,_node -> rightvalue);  
  41.         inorder(_node -> rchild);  
  42.     }  
  43. }  
  44.   
  45. int main(){  
  46.     Node *root;  
  47.     root = Build(root,1,10);  
  48.     inorder(root);  
  49.     return 0;  
  50. }  

 

 

运行结果：
技术分享

我们发现，存储的结果与一开始定义的完全一致，于是我们便成功的建立好了一棵空的线段树。

 

3.线段树的一些简单应用：

 

(1).区间查询问题：

我们以RMQ为例，即在给定区间内查询最小值，假设我们已经将对应区间的最小值存入了线段树的节点中，那么我们利用刚刚建立好的线段树来解决这一问题。

如果查询的区间是[1,2],[3,3]这样的区间，那么我们直接找到对应节点解决这一问题即可。但是如果查询的区间是[1,6],[2,7]这样的区间时，我们可以发现在线段树中，无法找到这样的节点，

但是呢，我们可以找到树中哪几个节点能够组成我们所要求的区间，然后再取这几个区间内的最小值不就解决问题了吗？

因此有了这样的想法，我们对于任何在合理范围内的查询，都可以找到若干个相连的区间，然后将这若干个区间合并，得到待求的区间。

通常，我们用来寻找这样的一个区间的简单办法是：

function 在节点v查询区间[l,r]

if v所表示的区间和[l,r]交集不为空集 if v所表示的区间完全属于[l,r]

选取v 

else

在节点v的左右儿子分别查询区间[l,r]end if end if

end function

伪代码出自《线段树》讲稿 杨戈

因此根据以上伪代码我们可以得出以下完整代码：

 

[cpp] view plain copy
 
  1. #include<cstdio>  
  2. #include<cstdlib>  
  3.   
  4. typedef struct node Node;  
  5.   
  6. struct node{  
  7.     int leftvalue;  
  8.     int rightvalue;      //分别用来记录节点记录的区间范围  
  9.     Node *lchild;     //左孩子节点  
  10.     Node *rchild;    //右孩子节点  
  11. };  
  12.   
  13. int flag = 1;      //用于标记当前遍历到哪个节点  
  14. //节点的初始化  
  15. Node *Init(Node *_node,int lvalue,int rvalue){  
  16.     _node = (Node *)malloc(sizeof(Node));  
  17.     _node -> lchild = NULL;  
  18.     _node -> rchild = NULL;  
  19.     _node -> leftvalue = lvalue;  
  20.     _node -> rightvalue = rvalue;  
  21.     return _node;  
  22. }  
  23.   
  24. //由区间[left,right]建立一棵线段树  
  25.   
  26. Node *Build(Node *_root,int left,int right){  
  27.     _root = Init(_root,left,right);    //节点初始化  
  28.     if(left != right){            //递归终止条件,表示已经线段树建立到了叶节点  
  29.         _root -> lchild = Build(_root -> lchild,left,(left + right) / 2);  
  30.         _root -> rchild = Build(_root -> rchild,(left + right)/2+1,right);  
  31.     }  
  32.     return _root;        //回溯至最后一层时,则返回整棵树的根节点  
  33. }  
  34.   
  35. //中序遍历,便于从左往右查看各节点存储的线段区间  
  36.   
  37. void inorder(Node *_node){  
  38.     if(_node){  
  39.         inorder(_node -> lchild);  
  40.         printf("第%d个遍历的节点,存储区间为:[%d,%d]\n",flag++,_node -> leftvalue,_node -> rightvalue);  
  41.         inorder(_node -> rchild);  
  42.     }  
  43. }  
  44.   
  45. /**用于查询一个给定的区间是由线段树中哪几个子区间构成的,为了简化代码, 
  46.  **因此保证输入的区间范围合法,这里就不作输入的合法性判断了 
  47.  */  
  48. void Query(Node *_node,int left,int right){  
  49.     /**要查询一个给定的区间是由线段树中哪几个子区间构成的 
  50.      **首先要满足的是当前遍历到的区间要和待查询区间有交集, 
  51.      **否则的话不再继续往当前节点的孩子节点继续遍历,原因很简单 
  52.      **每个孩子节点存储的区间范围都是包含于父亲节点的,父亲节点与 
  53.      **待查询区间无交集的话,则孩子节点一定无交集 
  54.      **/  
  55.      if(right >= _node -> leftvalue && left <= _node -> rightvalue){  
  56.         /**如果当前遍历到的线段树区间完全属于待查询区间, 
  57.          **那么选取该区间,否则的话,继续缩小范围, 
  58.          **在当前节点的左孩子和右孩子节点继续寻找 
  59.          **/  
  60.         if(left <= _node -> leftvalue && right >= _node -> rightvalue){  
  61.             printf("[%d,%d]\n",_node -> leftvalue,_node -> rightvalue);  
  62.         }  
  63.         else{  
  64.             Query(_node -> lchild,left,right);  
  65.             Query(_node -> rchild,left,right);  
  66.         }  
  67.      }  
  68.   
  69. }  
  70.   
  71. int main(){  
  72.     Node *root;  
  73.     root = Build(root,1,10);  
  74.     inorder(root);  
  75.     printf("区间[2,7]由线段树中以下区间构成:\n");  
  76.     Query(root,2,7);  
  77.     return 0;  
  78. }  


我们以区间[2,7]为例，得出以下运行结果：

 

技术分享

 

（2）.区间修改操作：

在这里我们依然以RMQ问题为例，假如一开始的时候，线段树中每个节点的权值都是1，那么现在我要做的是，指定一个合法

的区间，然后对这个区间内所有的数加上或者减去某个数，如果我们按照区间的内的数一一的去遍历并修改线段树的节点的话，那

么改动的节点数必然远远超过O(logn)个，而且会存在大量的重复遍历操作，那么要怎么样才能提高程序的效率呢？

首先，我们考虑给定的修改区间，按照前面我们讨论过的问题，我们可以把待操作区间变成几个相连的子区间，那么我们试

想，当我们要修改一个给定区间时，我们对其所有子区间进行修改，这样的话不就把整个待修改区间处理完毕了吗？这样的话

我们是否可以只通过修改几个子区间节点的值，而不考虑它们的孩子节点，就完成所有的操作了呢？

实际上，如果不考虑这些子区间的孩子节点的话，是错误的，因为在父亲节点所带的权值发生变化时，比如说上图示中区间

[1,2]中每个值都加上5，那么我们把线段树中表示区间[1,2]的节点修改完毕是否就可以了呢？答案显然是错误的，因为该节点的左孩

子([1,1])和右孩子节点所表示的区间([2,2])中的值也都发生了变化。

所以在这里我们为了方便，我们在节点定义中加入一个标记的量，用来存储对节点的修改情况。显然，当我们自上而下的访

问某节点时，父亲节点的标记要"传给"孩子节点，即修改大的区间，其子区间也必然被改动。

有了以上的分析，我们可以总结操作：

首先找到树中哪几个节点表示的区间，能够组成我们待修改的区间，然后从这些节点开始向下遍历，将以这些节点为根节点

的子树节点权值做相应的改变。（边查找对应子区间，边修改权值）

完整代码如下：

 

[cpp] view plain copy
 
  1. #include<cstdio>  
  2. #include<cstdlib>  
  3.   
  4. typedef struct node Node;  
  5.   
  6. struct node{  
  7.     int leftvalue;  
  8.     int rightvalue;      //分别用来记录节点记录的区间范围  
  9.     Node *lchild;     //左孩子节点  
  10.     Node *rchild;    //右孩子节点  
  11.     int weight;      //表示节点的权值  
  12.     int mark;        //表示当前节点改变的值(权重加减处理)  
  13. };  
  14.   
  15. int flag = 1;      //用于标记当前遍历到哪个节点  
  16. //节点的初始化  
  17. Node *Init(Node *_node,int lvalue,int rvalue){  
  18.     _node = (Node *)malloc(sizeof(Node));  
  19.     _node -> lchild = NULL;  
  20.     _node -> rchild = NULL;  
  21.     _node -> leftvalue = lvalue;  
  22.     _node -> rightvalue = rvalue;  
  23.     _node -> weight = 1;          //为了方便,一开始的时候,线段树每个节点的权值都设为1  
  24.     _node -> mark = 0;            //初始状态时,所有节点的权重均为1,因此一开始的时候,线段树每个节点的标记均为0  
  25.     return _node;  
  26. }  
  27.   
  28. //由区间[left,right]建立一棵线段树  
  29.   
  30. Node *Build(Node *_root,int left,int right){  
  31.     _root = Init(_root,left,right);    //节点初始化  
  32.     if(left != right){            //递归终止条件,表示已经线段树建立到了叶节点  
  33.         _root -> lchild = Build(_root -> lchild,left,(left + right) / 2);  
  34.         _root -> rchild = Build(_root -> rchild,(left + right)/2+1,right);  
  35.     }  
  36.     return _root;        //回溯至最后一层时,则返回整棵树的根节点  
  37. }  
  38.   
  39. //中序遍历,便于从左往右查看各节点存储的线段区间  
  40.   
  41. void inorder(Node *_node){  
  42.     if(_node){  
  43.         inorder(_node -> lchild);  
  44.         printf("\n第%d个遍历的节点,存储区间为:[%d,%d]\n",flag,_node -> leftvalue,_node -> rightvalue);  
  45.         printf("\n第%d个遍历的节点,权值为%d,标记为%d\n",flag++,_node -> weight,_node -> mark);  
  46.         inorder(_node -> rchild);  
  47.     }  
  48. }  
  49.   
  50. /**用于查询一个给定的区间是由线段树中哪几个子区间构成的,为了简化代码, 
  51.  **因此保证输入的区间范围合法,这里就不作输入的合法性判断了 
  52.  */  
  53. void Query(Node *_node,int left,int right){  
  54.     /**要查询一个给定的区间是由线段树中哪几个子区间构成的 
  55.      **首先要满足的是当前遍历到的区间要和待查询区间有交集, 
  56.      **否则的话不再继续往当前节点的孩子节点继续遍历,原因很简单 
  57.      **每个孩子节点存储的区间范围都是包含于父亲节点的,父亲节点与 
  58.      **待查询区间无交集的话,则孩子节点一定无交集 
  59.      **/  
  60.      if(right >= _node -> leftvalue && left <= _node -> rightvalue){  
  61.         /**如果当前遍历到的线段树区间完全属于待查询区间, 
  62.          **那么选取该区间,否则的话,继续缩小范围, 
  63.          **在当前节点的左孩子和右孩子节点继续寻找 
  64.          **/  
  65.         if(left <= _node -> leftvalue && right >= _node -> rightvalue){  
  66.             printf("[%d,%d]\n",_node -> leftvalue,_node -> rightvalue);  
  67.         }  
  68.         else{  
  69.             Query(_node -> lchild,left,right);  
  70.             Query(_node -> rchild,left,right);  
  71.         }  
  72.      }  
  73.   
  74. }  
  75.   
  76. /**对指定区间的值进行增添操作,显然,当某个子区间的值进行修改了之后 
  77.  **以该节点为根节点的子树区间的值均要修改 
  78.  **/  
  79.   
  80. void change(Node *node){  
  81.     if(node){  
  82.         if(node -> lchild){  
  83.             node -> lchild -> mark += node -> mark;  
  84.             node -> lchild -> weight += node -> lchild -> mark;  
  85.             change(node -> lchild);  
  86.         }  
  87.         if(node -> rchild){  
  88.             node -> rchild -> mark += node -> mark;  
  89.             node -> rchild -> weight += node -> rchild -> mark;  
  90.             change(node -> rchild);  
  91.         }  
  92.     }  
  93. }  
  94.   
  95. /**更改某个区间的权值,整棵线段树节点值的变化为了简化代码, 
  96.  **因此保证输入的区间范围合法,这里就不作输入的合法性判断，pos表示增减操作的值 
  97.  **/  
  98. void update(Node *node,int left,int right,int pos){  
  99.   
  100.     //先查找待处理区间的组成区间,再修改区间的权值  
  101.     if(right >= node -> leftvalue && left <= node -> rightvalue){  
  102.         if(left <= node -> leftvalue && right >= node -> rightvalue){  
  103.             node -> mark = pos;  
  104.             node -> weight += node -> mark;  
  105.             //修改以该节点为根的子树所有节点的权值和标记  
  106.             change(node);  
  107.         }  
  108.         else{  
  109.             update(node -> lchild,left,right,pos);  
  110.             update(node -> rchild,left,right,pos);  
  111.         }  
  112.      }  
  113. }  
  114.   
  115.   
  116.   
  117. int main(){  
  118.     Node *root;  
  119.     root = Build(root,1,4);  
  120.     //[1,3]中每个数都加上5;  
  121.     update(root,1,3,5);  
  122.     inorder(root);  
  123.     return 0;  
  124. }  


 

运行结果：

技术分享

 

线段树初学，有错误和不足之处还望指正，O(∩_∩)O谢谢，后续在深入学习的过程中，还会增加更多的关于线段树的文章，

或者对本文中的应用范围再进行扩充。

 

 

线段树（二）

标签：comm   apple   举例   ack   source   value   通过   board   width   

原文地址：http://www.cnblogs.com/Allen-rg/p/7082874.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！