大家好,我是洪爵,今天想给大家讲一个算法:线段树。
线段树是啥,它能干什么呢?
我们先来看下这样一个场景:现在有一个长度为5的数组a。
现在对它有如下几个操作:一个是求区间和,即给一个下标的范围[left, right]然后求数组a[left] ~ a[right]的和,我们把这个操作叫做query。
第二个是对数组a某个位置进行数值更新,比如a[1] = 3,现在把a[1]更新为5,我们把这个操作称为update。
我们可以先来看下常规操作的时间复杂度和空间复杂度是多少,query是求区间[left, right]和,时间复杂度是o(n),然后我们只需要使用一个变量去存储这个答案,所以空间复杂度是o(1)。
update是通过下标直接更新,所以它的时间复杂度o(1)。
总结一下,这种做法query的时间复杂度是o(n),update的时间复杂度是o(1),我们有没有更好的方法呢?
我们来看一下前缀和解法是否适用于这种场景,我们新建一个数组b,长度和a数组一样,b[0] = a[0],b[1] = b[0] + a[1],b[2] = b[1] + a[2]……b[n] = b[n - 1] + a[n]。当我们进行query操作的时候,比如求区间[left, right],那么我们只需要使用b[right] - b[left - 1](left等于0的时候需要处理下,避免数组越界)就能够得到query的答案,所以时间复杂度为o(1)。
但如果要进行update操作,比如更新了a[3]的值,b[3] ~ b[n]的值都需要进行更新,所以它的时间复杂度是o(n)。
使用前缀和算法的话,我们做一个总结,query的操作是o(1),update的操作是o(n),然后因为开了一个长度为n的数组,所以它的空间复杂度为o(n)。
所以不管是比较常规的做法或者是使用前缀和,update和query总有一个的时间复杂度是o(n),那么有没有时间复杂度更低的解决方法呢?我们可不可以把时间复杂度降到**o(logn)**呢?
我们可以先来看下o(n)和o(logn)的曲线:
o(n)曲线
o(logn)曲线
从图中我们可以看出o(n)的时间随着n增大是呈线性增长的,o(logn)时间复杂度随着n增大,增加的趋势不明显,并且随着n越来越大,o(logn)体现的效率会越来越明显,所以我们能得出:如果能把时间复杂度优化到o(logn),将会大大提高运行的效率。
线段树是一个query和update的**时间复杂度都为o(logn)**的数据结构。它是怎么实现的呢?我们还是看这样一个原数组。
我们把这个数组构建成一棵树,但是这棵树和平常的二叉树不同,它的每一个节点保存的信息不是数值,而是left,right的区间范围,还有保存区间值,可能这样说还是比较抽象,我们来看下每个节点是长啥样的:
struct Node {
int left;
int right;
int sum;
};
因为使用的是线段树,我们除了query和update操作,还需要添加一个建树的操作,我们称为build,这个build的操作只需要在一开始的时候初始化一次就ok,后面就不需要在build了。
那么问题来了,这棵树要怎么建才能使得时间复杂度为o(logn)呢,我们可以采用二分的思想,先来看下示意图:
再来看下代码的实现:
//调用build(0, 4, 0);
void build(int left, int right, int root) {
p[root].left = left;
p[root].right = right;
if(left == right) {
p[root].sum = num[left];
return;
}
int mid = (right+left) / 2;
build(left, mid, root * 2);
build(mid + 1, right, root * 2 + 1);
p[root].sum = p[root * 2].sum + p[root * 2 + 1].sum;
}
这样一颗线段树就构建好了,如果说我们要查询[1,1]这个区间的和,只需要遍历下面这几个节点就可以:
如果说我们要更新a[1]也一样,也是上面这几个节点需要更新,这样就能保证不论是query还是update操作都是**o(logn)**的时间复杂度,我们来看下代码实现吧。
友情提示:
root * 2 = root << 1
root * 2 + 1 = root << 1 | 1
#include <bits/stdc++.h>
#define MAXN 50005
using namespace std;
struct Node{
int left;
int right;
int sum;
}p[MAXN * 4]; // 为什么是4倍呢, 大家也可以思考下
int num[MAXN];
void Pushup(int root) {
p[root].sum = p[root << 1].sum + p[root << 1 | 1].sum;
}
// 建树操作
void build(int left, int right, int root) {
p[root].left = left;
p[root].right = right;
if(left == right) {
p[root].sum = num[left];
return;
}
int mid = (right + left) >> 1;
build(left, mid, root << 1);
build(mid + 1, right, root << 1 | 1);
Pushup(root);
}
// 更新a[i]为a[i] + j
void Update(int root, int i, int j) {
p[root].sum += j;
if(p[root].left == i && p[root].right == i) {
return;
}
int mid = (p[root].left + p[root].right) >> 1;
if(i <= mid) {
Update(root << 1, i, j);
}else{
Update(root << 1 | 1, i, j);
}
}
// 查询区间[left, right]的和
int Query(int root, int left, int right) {
if(p[root].left == left && p[root].right == right) {
return p[root].sum;
}
int mid = (p[root].right + p[root].left) >> 1;
if(right <= mid) {
return Query(root << 1, left, right);
}else if(mid < left){
return Query(root << 1 | 1, left, right);
}else{
return Query(root << 1, left, mid) + Query(root << 1| 1, mid + 1, right);
}
}
这里给到一个例题:http://acm.hdu.edu.cn/showproblem.php?pid=1166
思考:
大家也许会很疑惑**为什么要开4倍呢?**在做题的时候,你可能试过开2倍或者3倍,但是都不能过题,但是4倍的话就可以,为啥呢?
我们可以思考下,二叉树和线段树的一个区别,线段树采用二分去分区间,而二叉树是存储每个节点的值,当遇到不能完全平分的时候,就会出现叶子节点不在同一层的情况,而第n层的节点数是1~n-1层节点数的两倍(近似),所以正常是2n - 1个节点,但是需要乘以2,所以大约是4n个节点。
好的。线段树就说到这里啦,希望本篇文章对你有用!
愿每个人都能带着怀疑的态度去阅读文章并探究其中原理。
道阻且长,往事作序,来日为章。
期待我们下一次相遇!