Go语言实现动态开点线段树详解

type SegTreeNode struct {
    lazy  int
    val   int
    left  *SegTreeNode
    right *SegTreeNode
}

type SegTree struct {
    //线段树的范围，0~N
    N    int
    root *SegTreeNode
}
 
// 创建线段树
func CreateSegTree(n int) *SegTree {
    return &SegTree{
        N: n,
        root: &SegTreeNode{
            lazy:  0,
            val:   0,
            left:  nil,
            right: nil,
        },
    }
}

// 递归上推
func (ST *SegTree) Pushup(node *SegTreeNode) {
    node.val = node.left.val + node.right.val
}

// 同步下推
func (ST *SegTree) Pushdown(node *SegTreeNode, leftnum, rightnum int) {
    //创建左右节点
    if node.left == nil {
        node.left = new(SegTreeNode)
    }
    if node.right == nil {
        node.right = new(SegTreeNode)
    }
    //下推节点懒惰标记
    if node.lazy == 0 {
        return
    }
    node.left.val += leftnum * node.lazy
    node.right.val += rightnum * node.lazy
    //下推
    node.left.lazy += node.lazy
    node.right.lazy += node.lazy
    //置零
    node.lazy = 0
}

// 更新操作，更新[left,right]区间的值，start和end是当前处在区间
func (ST *SegTree) Update(node *SegTreeNode, start, end, left, right, val int) {
    if left <= start && end <= right {
        //锁定区间，进行更新
        node.val += (end - start + 1) * val
        node.lazy += val
        return
    }
    //缩小区间
    mid := (start + end) / 2
    //需要找到子节点，先下推懒惰标记
    ST.Pushdown(node, mid-start+1, end-mid)
    if mid >= left {
        ST.Update(node.left, start, mid, left, right, val)
    }
    if mid+1 <= right {
        ST.Update(node.right, mid+1, end, left, right, val)
    }
    //递归
    ST.Pushup(node)
}

// 查询操作，返回区间的值
func (ST *SegTree) Query(node *SegTreeNode, start, end, left, right int) int {
    if left <= start && end <= right {
        return node.val
    }
    mid := (start + end) / 2
    ST.Pushdown(node, mid-start+1, end-mid)
    ans := 0
    if left <= mid {
        ans += ST.Query(node.left, start, mid, left, right)
    }
    if mid+1 <= right {
        ans += ST.Query(node.right, mid+1, end, left, right)
    }
    return ans
}