zoukankan      html  css  js  c++  java
  • 线段树

    线段树

    参考:

    一步一步理解线段树 - tenos - 博客园
    http://www.cnblogs.com/TenosDoIt/p/3453089.html

    目录

    概述

    二、从一个例子理解线段树

      创建线段树

      线段树区间查询

      单节点更新

      区间更新

    三、线段树实战

    --------------------------

    一 概述

    线段树,类似区间树,它在各个节点保存一条线段(数组中的一段子数组),主要用于高效解决连续区间的动态查询问题,由于二叉结构的特性,它基本能保持每个操作的复杂度为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     else
    19     {
    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]),就相当于单节点更新,单节点更新只是区间更新的特例。

    三 线段树实战

     求区间的最大值、区间求和等问题都是采用类似上面的延迟标记域。下面会通过acm的一些题目来运用一下线段树。

    等待更新......

    参考资料

    GeeksforGeeks: http://www.geeksforgeeks.org/segment-tree-set-1-range-minimum-query/

    GeeksforGeeks: http://www.geeksforgeeks.org/segment-tree-set-1-sum-of-given-range/

    懂得博客[数据结构之线段树]:http://dongxicheng.org/structure/segment-tree/

    MetaSeed[数据结构专题—线段树]: http://blog.csdn.net/metalseed/article/details/8039326

    NotOnlySuccess[完全版 线段树]: http://www.notonlysuccess.com/index.php/segment-tree-complete/

  • 相关阅读:
    EntityFramework 启用迁移 EnableMigrations 报异常 "No context type was found in the assembly"
    JAVA 访问FTP服务器示例(2)
    NuGet Package Manager 更新错误解决办法
    JAVA 访问FTP服务器示例(1)
    RemoteAttribute 的使用问题
    诡异的 javascript 变量
    javascript apply用法
    Babun 中文乱码
    GSM呼叫过程
    转站博客园
  • 原文地址:https://www.cnblogs.com/Renyi-Fan/p/7499822.html
Copyright © 2011-2022 走看看