数据结构——线段树

最新推荐文章于 2024-04-11 16:28:59 发布
最新推荐文章于 2024-04-11 16:28:59 发布
阅读量513 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： ACM 文章标签： 线段树 数据结构 4n 区间合并
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/selous/article/details/55272415

未完成—2017.2.22号

问：在以数组结构描述线段树的数据结构下，如果原区间的大小为n，为什么线段树的数组需要分配4*n的空间？
线段树的特点：
1.任意节点的左右子树是共同存在的
2.任意节点的左右子树的叶子节点的差的绝对值小于等于1
3.任意节点的左右子树的高度差|H左−H右|≤1

注：满足上述条件的树必满足下面两条类似的说法：
1.如果除去线段树的最后一层的节点，那么余下的节点为完全二叉树
2.如果将倒数第二层的所有叶子节点都补上左右子树（区间为0），那么该树为完全二叉树。

证明：根据以上条件，如图所示为区间大小为5的线段树结构，其所需要的数据空间最大。
这里写图片描述

假设节点数为n；
H−1=log2(n−1)+1
H=log2(n−1)+2
故节点个数为：
nodes=2H−1=2log2(n−1)+2−1=4(n−1)−1=4n−5
故线段树的节点个数一般为其范围的4倍。

单点更新

/*
 ============================================================================
 Name        : enemysoldiers.c
 Author      : selous
 Version     :
 Copyright   : Your copyright notice
 Description : enemy soldiers;segment tree;
 ============================================================================
 */
/*features:
 * 1.节点不记录*/
#include <stdio.h>
#include <stdlib.h>
#define maxind 6

/*[BEGIN,END] is section of segment tree*/
#define BEGIN 1
#define END 5

int array[maxind];
int segTree[maxind*4];

/*build the segment tree*/
void build(int node,int begin,int end){

    if(begin==end){
        segTree[node] = array[begin];
    }else{
        /*recurse build left and right subtree*/
        build(2*node,begin,(begin+end)/2);
        build(2*node+1,(begin+end)/2+1,end);

        /*when recall,calculate father node information*/
        segTree[node] = segTree[2*node]+segTree[2*node+1];
    }
}

/*query giving interval information*/

int query(int node,int begin,int end,int left,int right){

    /*start with first node*/
    int p1;
    int p2;
    /*No intersection*/
    if(begin>right||end<left){
        return 0;
    }
    /*  if the current interval is included in  */
    /*  the query interval return segTree[node]  */
    if(begin>=left&&end<=right){
        return segTree[node];
    }

    /*according order of building*/
    p1 = query(2 * node, begin, (begin + end) / 2, left, right);
    p2 = query(2 * node + 1, (begin + end) / 2 + 1, end, left, right);


    /*return query value;*/
    return p1+p2;
}

/*update the single node information */
/*the section is [begin,end]*/
void update(int node,int begin,int end,int position,int change){

    if(begin==end){
        segTree[node]+=change;
    }else{
        int mid;
        mid = (begin+end) >>1;
        if(mid>position) update(2*node,begin,mid,position,change);
        else update(2*node+1,mid+1,end,position,change);
        /*single node change*/
        /*recall,father node need to change*/
        segTree[node]+=change;
    }

}

int main() {

    int i;
    for(i=0;i<maxind;i++){
        array[i]=i;
    }

    build(1,BEGIN,END);
    update(1,BEGIN,END,5,-5);
    int num = query(1,BEGIN,END,1,5);

    printf("num of emery:%d",num);
    return 0;
}

离散化

成端更新

//============================================================================
// Name        : segmentTree.cpp
// Author      : selous
// Version     :
// Copyright   : Your copyright notice
// Description : segment tree;segment update;lazy method;
//============================================================================


/*whether update or query function,we should not change the section [left,right]*/


/*start from the root node,dichotomy the tree like when building*/
#include <iostream>
using namespace std;

typedef struct Node{

    int right,left;
    int sum;
    int add;
    int mid(){return (right+left)>>1;}

}node;

#define LC(node) node<<1 /*represented left child*/
#define RC(node) (node<<1)+1/*represent right child*/
const int maxind = 400; /*max section*/
int array[maxind];
node nodes[maxind<<2];/*number of nodes*/

void pushUp(int node){
    nodes[node].sum = nodes[LC(node)].sum+nodes[RC(node)].sum;
}

/*has a tag in the node*/
/*[nodes.left,nodes.right]<=[left,right]*/
void pushDown(int node){

    if(nodes[node].add){

        nodes[LC(node)].add+=nodes[node].add;
        nodes[RC(node)].add+=nodes[node].add;

        /*更新左右节点的值*/
        nodes[LC(node)].sum+=nodes[node].add*(nodes[LC(node)].right-nodes[LC(node)].left+1);
        nodes[RC(node)].sum+=nodes[node].add*(nodes[RC(node)].right-nodes[RC(node)].left+1);

        /*delete the tag*/
        nodes[node].add=0;
    }
}


/*rt represent present node number*/
void build(int rt,int begin,int end){
    nodes[rt].left=begin;
    nodes[rt].right=end;
    /*leaf node*/
    if(begin==end){
        nodes[rt].add=0;
        nodes[rt].sum = array[begin];
    /*father node*/
    }else{
        build(LC(rt),begin,nodes[rt].mid());
        build(RC(rt),nodes[rt].mid()+1,end);

        /*recall*/
        pushUp(rt);
        nodes[rt].add=0;
    }
}

/*[left right] the section that need to update */
void update(int rt,int left,int right,int num){

    if(left<=nodes[rt].left&&right>=nodes[rt].right){

        nodes[rt].sum += (nodes[rt].right-nodes[rt].left+1) * num;
        nodes[rt].add += num;
        return;
    }

//  pushDown(rt);

    int m = nodes[rt].mid();

    /*update the right child tree*/
    if(right>m) update(RC(rt),left,right,num);
    /*update the left child tree*/
    if(left<=m) update(LC(rt),left,right,num);

    /*calculate the father node*/
    pushUp(rt);
}

/*only when query,we should invoke the pushDown function*/
int query(int node,int left,int right){

    /*[nodes.left,nodes.right]<=[left,right]*/
    if(nodes[node].left>=left&&nodes[node].right<=right){
        return nodes[node].sum;
    }

    /*if the node has tag,pushdown to its child*/
    pushDown(node);

    int p1=0,p2=0;
    int m = nodes[node].mid();
    if(left<=m)p1=query(LC(node),left,right);

    if(right>m)p2=query(RC(node),left,right);

    return p1+p2;
}

int main() {


    for(int i=1;i<5;i++){
        array[i]=i;
    }
    build(1,1,4);
    update(1,2,3,3);
    update(1,1,2,2);
    update(1,1,2,3);
//  cout<<query(1,2,3)<<endl;

    for(int i=1;i<20;i++){
        cout<<nodes[i].left<<" "<<nodes[i].right<<" "<<nodes[i].sum<<endl;
    }
    return 0;
}

区间合并

//============================================================================
// Name        : villageProblem.cpp
// Author      : selous
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;
const int maxNum=50;

#define Lc(c) c<<1
#define Rc(c) (c<<1)+1
typedef struct Node{
    int left,right;//[left,right] section
    int lseg;//left max continue segment
    int rseg;
    int mseg;//max continuous segment
}node;

node nodes[maxNum];

int array[maxNum];


/*calculate father node information with his child nodes.*/
void pushUp(int i){

    nodes[i].lseg=nodes[Lc(i)].lseg;//left continuous segment
    nodes[i].rseg=nodes[Rc(i)].rseg;//right continuous segment
    nodes[i].mseg=max(max(nodes[Lc(i)].mseg,nodes[Rc(i)].mseg),
            nodes[Lc(i)].rseg+nodes[Rc(i)].lseg);
    /*all in the Lc(i) is empty*/
    if(nodes[Lc(i)].lseg==nodes[Lc(i)].right-nodes[Lc(i)].left+1){
        nodes[i].lseg+=nodes[Rc(i)].lseg;
    }
    /*all in the Rc(i) is empty*/
    if(nodes[Rc(i)].rseg==nodes[Rc(i)].right-nodes[Rc(i)].left+1){
        nodes[i].rseg+=nodes[Lc(i)].rseg;
    }

}

/*build segment tree;initial*/
void build(int start,int begin,int end){

    nodes[start].left=begin;
    nodes[start].right=end;
    nodes[start].lseg=nodes[start].rseg=nodes[start].mseg=end-begin+1;
    if(begin==end){
        return;
    }
    int mid = (begin+end)>>1;
    /*build the left child tree*/
    build(Lc(start),begin,mid);
    /*build the right child tree*/
    build(Rc(start),mid+1,end);
}


/*update single node information*/
void update(int start,int node,int t){

    if(nodes[start].left==nodes[start].right){
        /*t equals 1 means rebuild the village*/
        /*t equals 0 means destroy the village*/
        nodes[start].lseg=nodes[start].rseg=nodes[start].mseg=t;
        return;
    }


    /**/
    int mid = (nodes[start].right+nodes[start].left)>>1;

    if(mid<node){
        update(Rc(start),node,t);
    }else{
        update(Lc(start),node,t);
    }

    pushUp(start);
}

/*query max village section include the ith village*/
int query(int start,int i){
    /*1.node start is a leaf node*/
    /*2.max empty segment is 0 or equal to the size of the segment*/
    if(nodes[start].left==nodes[start].right||
            nodes[start].mseg==0||
            nodes[start].mseg==nodes[start].left-nodes[start].right+1){
        return nodes[start].mseg;
    }

    /*the middle of the node start section*/
    int mid = (nodes[start].left+nodes[start].right)>>1;

    /*if ith locate in the right child tree*/
    if(mid<i){
        if(i<=nodes[Rc(start)].left+nodes[Rc(start)].lseg-1){
            return query(Rc(start),i)+query(Lc(start),mid);
        }else{
            return query(Rc(start),i);
        }

    }else{
        /*i is located in right section*/
        if(i>=nodes[Lc(start)].right-nodes[Lc(start)].rseg+1){
            return query(Lc(start),i)+query(Rc(start),mid+1);
            //return nodes[Lc(start)].rseg+nodes[Rc(start)].lseg;
        }else{
            return query(Lc(start),i);
        }
    }
}


int main() {

    int i;
    for(i=1;i<=10;i++){
        array[i]=i;
    }

    build(1,1,10);
    update(1,4,0);
    update(1,6,0);
    update(1,8,0);
    update(1,6,1);
    for(int i=1;i<=20;i++){
    cout<<i<<":"<<nodes[i].left<<" "<<nodes[i].right<<" "<<nodes[i].lseg
            <<" "<<nodes[i].rseg<<" "<<nodes[i].mseg<<endl;
    }
    cout<<query(1,5)<<endl;
    return 0;
}

扫描线

//============================================================================
// Name        : Rectangular.cpp
// Author      : selous
// Version     :
// Copyright   : Your copyright notice
// Description : Rectangular Area;Rectangle;scanning line
//============================================================================

#include <iostream>
#include<algorithm>
using namespace std;
#define Lc(node) node<<1
#define Rc(node) (node<<1)+1
const int MAXNUM = 50;
/*一次扫描过程就是一次update的过程*/
/*一条下位边就是一个扫描线*/
typedef struct node{
    double sum;//node[1].sum记录扫描线结果的长度。
    int cnt;//记录该线段是否是下位线
}Node;//node of segment tree
typedef struct edge{
    double left;//value of edge's left x1;
    double right;//value of edge's right x2;
    double height;//value of edge's distance relative to x-axes
    int cnt;//上位线1，下位线-1
    edge(){left=right=height=cnt=0;}
    edge(double l,double r,double h,double c){
        left=l;
        right=r;
        height=h;
        cnt=c;
    }
    bool operator < (const edge &edge)const{
        return height<edge.height;
    }
}edge;
edge edges[MAXNUM];
double X[MAXNUM];//储存所有长方形的X坐标
node nodes[MAXNUM<<2];
void pushUp(int root){
    /*如果左右子节点的左右子树的cnt不相同*/
    if(nodes[Lc(root)].cnt==-1||nodes[Rc(root)].cnt==-1){
        nodes[root].cnt=-1;
    /*如果左右子节点的cnt不相同*/
    }else if(nodes[Lc(root)].cnt!=nodes[Rc(root)].cnt){
        nodes[root].cnt=-1;
    }else{
        nodes[root].cnt=nodes[Lc(root)].cnt;//左右子树的任意一个节点值
    }
    //向上推，的sum为左右节点和nodes[root].sum=nodes[Lc(root)].sum+nodes[Rc(root)].sum;
}
void pushDown(int root,int left,int right){
    int m = (left+right)>>1;
    //左右节点的cnt相同，能推下去
    if(nodes[root].cnt!=-1){
        //三个的cnt是相同的    nodes[Rc(root)].cnt=nodes[Lc(root)].cnt=nodes[root].cnt;    nodes[Lc(root)].sum=nodes[Lc(root)].cnt?X[m+1]-X[left]:0;       nodes[Rc(root)].sum=nodes[Rc(root)].cnt?X[right+1]-X[m+1]:0;
    }
}
void build(int root,int begin,int end){
    if(begin == end){
        nodes[root].cnt=0;
        nodes[root].sum=0;
    }
    int mid = (begin+end) >> 1;
    build(Lc(root),begin,mid);
    build(Rc(root),mid+1,end);
    pushUp(root);
}
/*segment update*/
/*[left,right]区间更新值为value*/
/*[begin,end]为root根节点所在的区间*/
void update(int left,int right,int value,int root,int begin,int end){
    if(left<=begin&&right>=end){
        if(nodes[root].cnt!=-1){
            nodes[root].cnt+=value;
            /*如果cnt！=0，为区间之长度*/
            /*如果cnt为0，则该长度不计入总长度*/
            nodes[root].sum=(nodes[root].cnt?X[right+1]-X[left]:0);
        }
    }
    pushDown(root,begin,end);
    int m = (begin+end)>>1;
    if(left<=m) update(left,right,value,Lc(root),begin,m);
    if(right>m) update(left,right,value,Rc(root),m+1,end);
    pushUp(root);
}

int main() {
    int q;//number of rectangle
    cin>>q;
    double x1,x2,y1,y2;
    int i;
    int n=0;//number of edges;
    for(i=0;i<q;i++){
        cin>>x1>>y1>>x2>>y2;
        n++;
        X[n]=x1;
        edges[n]=edge(x1,x2,y1,1);//下位边为1
        n++;
        X[n]=x2;
        edges[n]=edge(x1,x2,y2,-1);//上位边为-1
    }
    sort(X+1,X+n+1);
    sort(edges+1,edges+n+1);
    for(i=1;i<=n;i++){
        cout<<X[i]<<" ";
    }
    //去除X中的重复元素
    int k=1;
    for(i=2;i<=n;i++){
        if(X[i]!=X[i-1]){X[++k]=X[i];}
    }
    //建树
    build(1,1,k-1);

    //求面积
    double square = 0.0;
    cout<<"square of the rectangle is"<<square<<endl;
    return 0;
}
数据结构——线段树入门
m0_62021646的博客
07-22 610
线段树入门知识
点节点更新线段树
05-18
可移植代码，用于单点更新，内有代码移植及运用的详解
线段树的节点数
a123321a1233211的博客
02-10 1406
链接：https://ac.nowcoder.com/acm/problem/205174 来源：牛客网 题目描述 小gay最近学习了线段树这个神奇的数据结构。但爱思考的小gay意识到线段树用数组保存也太浪费空间了。例如，如下一颗n=10的线段树长这个样子~ 其中,[a,b]表示节点表示数据范围，下标表示节点序号。 可以看见，一共用了19个节点，但是标号到了25. 令f(n)表示一颗n个叶子节点的线段树所占的最大数组下标。现在闲得无聊的小gay想让你帮忙求出： f(l) ⊕ f(l+1) ⊕ f(l+
线段树（通过数组的构建方式）
YY_Tina的博客
10-08 311
这里只说最基础的线段树，不涉及lazy标记和延迟修改的操作 用处 面向数组中的数据，针对其中编号是连续的区间进行修改或统计的操作 举一个小栗子，假设我们现在有10000个整数，存在 A[1]−A[10000]A[1]-A[10000]A[1]−A[10000] 中 统计操作： 统计 [L,R][L, R][L,R] 的数字之和 修改操作： 将第 LLL 个数增加 CCC 如果不使用线段树，基本的处理方法有这两种： 法1: 用原始数组进行存储，进行统计操作时候将 R-L+1个数进行相加，进行修改操作时
poj 2886 (线段树 统计左右各有多少个节点.)
Sooowhat
09-03 601
什么是反素数..#include #define N 5000006 #include using namespace std; int div_num[N]; int max_id[N]; char name[N][12]; int n_person; int s_id; i
线段树详解
ling_wang的博客
08-12 7383
一.基本概念 1.线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 （严格来说：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点...
等差数列与数据结构——线段树、树状数组解析
标签涉及信息竞赛、OI、线段树、树状数组和数据结构，内容包括具体题目实例的解析，如区间查询和单点修改等操作。" 线段树是一种高效的数据结构，常用于处理区间查询和修改的问题。其优点在于能够快速地对区间进行...
数据结构——线段树的基本操作
Lucas_FC_的博客
07-23 364
线段树的基本应用
数据结构——线段树c++
Potestatem的博客
08-30 990
线段树概讲 为什么是概讲呢，因为线段树包含的东西太多了，现在我也只搞明白了，线段树的建立 、线段树的查询、线段树的单节点更新，至于颇有难度的 区间更新就简单的写下来以供各位大佬看后一笑。因为线段树的知识本人并未经过系统学习，通过看各位大神的博客方才有了自己一些不成熟的理解。我将会在文章末尾附上学生学习时的链接，供各位老师更进一步。 线段树的几个基础线段树概讲线段树的建立Problem Description线段树的查询线段树的单节点更新线段树的区间更新实践检验真理（来个水题） 线段树的建立 首先要知道什么是
线段树入门---给定多个线段求点的出现个数
dizhuo0219的博客
10-27 259
线段树是一颗二叉树，他的每个节点都是一个区间，此题为线段树的入门题目，只是学习笔记。例题：给定N个线段，给定M个点，求点在多少个线段中出现过，此时如果用传统的方法来求，时间复杂度太高，但是，线段树的时间复杂度还可以接受。 步骤为： 1. 首先找一个区间，能覆盖给定的所有区间， 然后把此区间建立线段树，建立线段树的方式是二分法建立，即它的左孩子是他的左半个区间，右孩子是它的右边那个区间...
210823算法日记：线段树的搜索路径以及4*n节点的建立证明
cjp_kangkang_的博客
08-24 172
[1,10] / \ [1,5] [6,10] / \ / \ [1,3] [4,5] [6,8] [9,10] / \ / \ / \ / \ [1,2] [3] [4] [5] [6,7] [8] [9] [10] ...
线段树&树状数组代码模板
weixin_43111232的博客
11-12 298
参考：线段树介绍 静态线段树 假设大小为n，则至少需要申请大小为4*n的数组，对应力扣：通过指令创建有序数组，代码模板： class SegTree{ int n; int[] arr; SegTree(int n){ this.n = n; this.arr = new int[4*n]; } public void update(int x){ update(1,1,n,x); } public in
线段树基础知识
XiaoZheng的博客
03-11 1463
线段树的概念在一类问题中，我们需要经常处理可以映射在一个坐标轴上的一些固定线段，例如说映射在OX轴上的线段。由于线段是可以互相覆盖的，有时需要动态地取线段的并，例如取得并区间的总长度，或者并区间的个数等等。一个线段是对应于一个区间的，因此线段树也可以叫做区间树。线段树的构造思想 线段树是一棵二叉树，树中的每一个结点表示了一个区间[a,b]。 每一个叶子节点表示了一个单位区间。 根节点表示的是“整体”
线段树(递归+二分的漩涡)
博客
05-23 629
首先放出大佬的博客，写的很好，对每个函数的理解都很清晰，大佬 首先说一下线段树的数组范围是4*N(这个N是区间的长度)，这个由来是一个博客，好像是一个二叉树的什么性质，就这样这个数组范围就这样定了，有的错误就是数组范围太小了，导致一些溢出错误，所以数组开大点就不会溢出了。假设根的高度为1的话，树的最大高度为（n>1）(是向下取整，就是舍弃掉小数点)，然后使用等比数列的公式，2^k-1(k是...
线段树应用（建树、查询任意区间元素个数）
hnjzsyjyj的专栏
12-06 1087
【问题描述】 输入中第一行有两个数m，n。其中m表示有m(m<=100000)笔账，n表示有n个询问，n<=100000。 第二行为m个数，分别是账目的钱数。 后面n行分别是n个询问，每行2个数字表示开始、结束的账目编号。 输出表示给定区间内的账目个数。 【程序代码】 #include<bits/stdc++.h> using namespace std; con...
【算法】线段树
最新发布
weixin_73366312的博客
04-11 1593
几乎是算法竞赛最常用的数据结构了，它主要用于（要求满足结合律）。与树状数组相比，它可以实现的，还可以同时（加、乘），更具通用性。如题，已知一个数列，你需要进行下面两种操作：1.将某区间每一个数加上x2.求出某区间每一个数的和第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。
DAY_4（线段树）
hycccccch的博客
01-18 445
/线段树//延迟更新标记//原始数组f2：（常用）——方便添加元素int val;//节点值//int lazy;//延迟更新标记//可添加更多元素//线段树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值