线段树(一)

问题：

先抛出一个问题，坐标轴上有若干线段，现在给定若干个点，对于每个点，求出包含点的线段的数量

如果用常规的解法，时间复杂度是O(mn)，空间复杂度是O(m + n)

能不能降低一下时间复杂度呢？答案是肯定的，这些线段里有大量相交或者覆盖的线段，而上面的解法显然没有利用这些信息，导致时间复杂度较高，现在我们引入

一个数据结构，线段树(Segment Tree)，从Wikipedia抄过来定义如下：

In computer science, a segment tree is a tree data structure for storing intervals, or segments. It allows querying which of the 
stored segments contain a given point. It can be implemented as a dynamic structure. A similar data structure is the interval tree.

第一次看我也是一头雾水，什么也没说嘛，下面从给出一个规范化的线段树的定义：

定义1 长度为1的线段称为元线段。
定义2 一棵树被成为线段树，当且仅当这棵树满足如下条件：
（1）   该树是一棵二叉树。
（2）   树中每一个结点都对应一条线段[a,b]。
（3）   树中结点是叶子结点当且仅当它所代表的线段是元线段。
（4）   树中非叶子结点都有左右两个子树，左子树树根对应线段[a , (a + b ) / 2]，右子树树根对应线段[( a + b ) / 2 + 1, b]

 线段树主要有三种操作，建树，插入，查询，先面我们一一看一下这三种操作

 

A. 建树

 

给出8条线段，S[1-8]，区间分别为[1,3],[2,4],[3,5],[4,6],[7,8],[7,9],[9,10],[8,10]，总区间为[1,10]，一棵线段树要覆盖区间，因此用区间[1,10]

建立一棵线段树，如上图，可以看出，线段树是一棵二叉平衡树，简单性质如下：

    1. 对于非叶子节点：r[a,b](a < b) r的左儿子节点的区间为[a,(a + b) / 2]；r的右儿子节点的区间为[(a + b) / 2 + 1, b]

    2. 叶子节点对应一个点，也即r[a,b](a = b)

    3. 线段树把区间上的任意一条线段都分成不超过2logL条线段(L为总区间的长度)[证明可参考论文《线段树在算法中的应用》]

    性质1保证了线段树是一棵平衡二叉树，性质3则能够保证插入，查询操作可在O(logL)的时间复杂度内完成

    

B. 插入线段

那么建立起这样一棵树后，怎么插入一条线段呢？方法很简单，以插入S8为例，看图：

可以看出，方法很简单：

1. 从根节点r(a,b)开始, 待插线段s(c,d)

    1.0 如果a == c && b == d，转到2

    1.1 如果d <= (a + b) / 2，以r的左孩子为根，转到1

    1.2 如果c > (a + b) / 2，以r的右孩子为根，转到1

    1.3 否则搜索r的左孩子和右孩子

2. 节点的值+1, 插入结束

由性质3可以知道，插入线段操作能够在O（logL）次内完成

 

C. 查询

最后查询某个点的包含次数，就非常简单了，沿着根节点搜索到叶子节点，将一路搜索过程中走过节点的值加和即可

 

给出代码：

//线段树节点数据结构
typedef struct {
    int count;//完全包含区间[left, right]次数
    int left;//区间开始
    int right;//区间结束
} ST;

 

/*建树*/
void build_ST(int i, int left, int right) {
    st[i].left = left;
    st[i].right = right;
    st[i].count = 0;
    if(left == right) {
        return; 
    } 
    build_ST(i * 2, left, (left + right) / 2); 
    build_ST(i * 2 + 1, (left + right) / 2 + 1, right);
}

/*插入线段*/
void insert_ST(int i, int left, int right) {
    int l = st[i].left;
    int r = st[i].right;
    if(l == left && r == right) { //刚好覆盖
        st[i].count++;
    }
    else if(right <= (r + l) / 2) {
        insert_ST(i * 2, left, right);
    }
    else if(left > (r + l) / 2) {
        insert_ST(i * 2 + 1, left, right);
    }
    else {
        insert_ST(i * 2, left, (r + l) / 2);
        insert_ST(i * 2 + 1, (r + l) / 2 + 1, right);
    }
}

/* 查询 */
int query_ST(int i, int value) {
    int l = st[i].left;
    int r = st[i].right;
    if(l == r) {
        return st[i].count;
    }
    else if(value <= (r + l) / 2)
        return st[i].count + query_ST(i * 2, value);
    else
        return st[i].count + query_ST(i * 2 + 1, value);
}

//测试函数
#define N 1024
ST st[N] = { 0 };

int main() {
    int n;//区间长度
    int m;//插入线段数

    scanf("%d", &n);
    scanf("%d", &m);

    build_ST(1, 1, n);

    for(int i = 0; i < m; i++) {
        int segs, sege;
        scanf("%d %d", &segs, &sege);
        insert_ST(1, segs, sege);
    }

    for(int i = 0; i < n; i++) {
        printf("%d\n", query_ST(1, i + 1));
    }
    return 0;
}

 

最后看一下复杂度：

操作	时间复杂度	空间复杂度
建树	O(L)	O(L)
插入	O(logL)
查询	O(logL)

 

 

 

 

 

 

由于本人水平有限，文中难免有不当和错误之处，欢迎大家批评指正，愿共同进步！！！