数据结构--线段树--洛谷模板线段树1-2

已于 2023-05-15 11:11:43 修改
阅读量325 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 java
于 2023-05-14 13:57:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56717234/article/details/130654606
版权
写在前面：
学习之前需要知道以下内容：
1. 递归
2. 二叉树

文章目录

线段树

介绍

线段树是一种二叉树，也可以归类为二叉搜索树。可以将区间的修改、维护和查询的时间复杂度优化为log级别的。

构成
如一段1-6区间
在这里插入图片描述
可以分开为1-3和4-6然后继续放下拆分直到拆分为一个数的时候。
也就可以用树的标识。
在这里插入图片描述

用途

区间的加法

也可以结合 扫描线 用于二维面积并问题。

建树

存储方式我们使用数组来进行建树。这个要用到的就是二叉树的知识了。（对于 i i i 下标节点，左儿子下标为 2 ∗ i 2*i 2∗i,右儿子下标为 2 ∗ i + 1 2*i +1 2∗i+1 父节点下标为 i / / 2 i//2 i//2）

修改

单点修改

通过二叉树查询下标在进行修改。(二叉树查询为log级别)
然后更新大区间的值。

在这里插入图片描述
如修改下标2为数字3那么则需要更新为
在这里插入图片描述

区间修改

如将1-5的的值+2
则下面部分都需要+2
在这里插入图片描述
但是这样好像也没有啥优势，和数组一个个+2是一样的甚至，还多一些。

我们可以在这加一个缓存技术。
1-5就只需要更新这2个就可以了，然后在其lazy数组上设置为+2.
更新的值为长度*加的值
这里 10 10 10 就是 + 2 ∗ 3 +2*3 +2∗3 而 3 3 3 加上 2 ∗ 2 2*2 2∗2
在这里插入图片描述
每次当要用到子节点的时候就需要将lazy标记下存了。
如现在 [ 1 − 3 ] [1-3] [1−3]的标记为 2 2 2 当我们要用到 [ 1 ] [1] [1]的时候
[ 3 ] [3] [3]就+2
[ 1 − 2 ] [1-2] [1−2]也+2
而 [ 1 − 3 ] [1-3] [1−3] 设置为0
然后继续递归

查询

这里和二叉树查询一样
不过需要注意的是。lazy标记下存的操作，在这里也是需要的。

如查询 [ 1 − 2 ] [1-2] [1−2]的值。
首先在 [ 1 − 6 ] [1-6] [1−6]的左，然后发现在 [ 1 − 3 ] [1-3] [1−3]的左，但是lazy为+2
所以 l z a y [ 1 − 3 ] = 0 , l z a y [ 1 − 2 ] = 2 , l a z y [ 3 ] = 2 lzay[1-3] = 0,lzay[1-2]=2,lazy[3]=2 lzay[1−3]=0,lzay[1−2]=2,lazy[3]=2.
所以 [ 1 − 2 ] = l z a y [ 1 − 2 ] + [ 1 − 2 ] = 2 + 7 = 9 [1-2] = lzay[1-2]+[1-2] = 2+7=9 [1−2]=lzay[1−2]+[1−2]=2+7=9

代码实现。

建树

使用递归来实现

    /**
     * 建树
     * @param l 左边界
     * @param r 右边界
     * @param pos 当前位置
     * @return 当前位置的值
     */
    public long build(int l, int r, int pos) {
        if (l == r) {
            return tree[pos] = mapping[l - 1];
        } else {
            int mid = (l + r) >> 1;
            return tree[pos] = build(l, mid, pos << 1)
                    + build(mid + 1, r, pos << 1 | 1);
        }
    }

更新

每次从根节点开始进行。
如果查询和边界没有交点的时候停止递归
在这里插入图片描述
如果完全包括，那么就将这个区间更新。
更新规则：

  1. 区间值+value*长度
  2. 区间lazy +value

在这里插入图片描述
其他情况就是一部分在一部分不在，那么就进行向子节点查询
注意如果该节点lazy值不为空则需要向下传递。
向下查找完后，需要将子节点添加的值向本节点更新。
在这里插入图片描述

    /**
     * 更新
     * @param l 左边界
     * @param r 右边界
     * @param pos 当前位置
     * @param value 更新值
     * @return 当前位置的值
     */
    public long getUpdate(int l, int r, int pos, int value) {
        if (r < updateL || l > updateR)
            return 0;
        if (l >= updateL && r <= updateR) {
            lazy[pos] += value;
            long v = (long) value * (r - l + 1);
            tree[pos] += v;
            return v;
        } else {
            int mid = (l + r) >> 1;
            updateLazy(l, r, pos, mid);
            long ul = getUpdate(l, mid, pos << 1, value);
            long ur = getUpdate(mid + 1, r, pos << 1 | 1, value);
            tree[pos] += ul + ur;
            return ul + ur;
        }
    }

lazy传递

更新规则如下，

  1. 子节点的lazy设置为本节点的lazy
  2. 子节点数值更新
  3. 本节点lazy设置为0
    /**
     * 更新懒标记
     * @param l 左边界
     * @param r 右边界
     * @param pos 当前位置
     * @param mid 中间位置
     */
    private void updateLazy(int l, int r, int pos, int mid) {
        if (lazy[pos] != 0) {
            lazy[pos << 1] += lazy[pos];
            lazy[pos << 1 | 1] += lazy[pos];
            tree[pos << 1] += lazy[pos] * (mid - l + 1);
            tree[pos << 1 | 1] += lazy[pos] * (r - mid);
            lazy[pos] = 0;
        }
    }

查询

这个没有太多好说的，和更新挺像的
一样需要注意的是lazy值的下移。

    /**
     * 查询
     * @param l 左边界
     * @param r 右边界
     * @param pos 当前位置
     * @return 当前位置的值
     */
    public long getN(int l, int r, int pos) {
        if (l > getR || r < getL)
            return 0;
        if (l >= getL && r <= getR) {
            return tree[pos];
        } else {
            int mid = (l + r) >> 1;
            int i = pos << 1;
            int j = i | 1;
            updateLazy(l,r,pos,mid);
            return getN(l, mid, i) +
                    getN(mid + 1, r, j);
        }
    }

优化一下

emm因为代码是我自己想的，考虑不是特别好。
看到别人的都是把上传单独抽出一个方法，我觉得还是抽出来比较简单明了一些。

public void pushUp(int x) {
    tree[x] = (tree[x << 1] + tree[x << 1 | 1]) % p;
}

然后所有的更新都不需要返回值了
只需要在代码的最后加上一个就可以了

pushUp(pos);

如

    public void getUpdate(int l, int r, int pos, long value) {
        if (r < updateL || l > updateR) return;
        if (l >= updateL && r <= updateR) {
            tree[pos] = (tree[pos] + value * (r - l + 1)) % p;
            add[pos] = (add[pos] + value) % p;
        } else {
            int mid = (l + r) >> 1;
            updateLazy(l, r, pos, mid);
            getUpdate(l, mid, pos << 1, value);
            getUpdate(mid + 1, r, pos << 1 | 1, value);
            pushUp(pos);
        }
    }

练习

洛谷 P3372 【模板】线段树 1

题目描述

如题，已知一个数列，你需要进行下面两种操作：

  1. 将某区间每一个数加上 k k k。
  2. 求出某区间每一个数的和。

输入格式

第一行包含两个整数 n , m n, m n,m，分别表示该数列数字的个数和操作的总个数。

第二行包含 n n n 个用空格分隔的整数，其中第 i i i 个数字表示数列第 i i i 项的初始值。

接下来 m m m 行每行包含 3 3 3 或 4 4 4 个整数，表示一个操作，具体如下：

  1. 1 x y k：将区间 [ x , y ] [x, y] [x,y] 内每个数加上 k k k。
  2. 2 x y：输出区间 [ x , y ] [x, y] [x,y] 内每个数的和。

输出格式

输出包含若干行整数，即为所有操作 2 的结果。

样例 #1

样例输入 #1

5 5
1 5 4 2 3
2 2 4
1 2 3 2
2 3 4
1 1 5 1
2 1 4

样例输出 #1

11
8
20

提示

对于 30 % 30\% 30% 的数据： n ≤ 8 n \le 8 n≤8， m ≤ 10 m \le 10 m≤10。
对于 70 % 70\% 70% 的数据： n ≤ 10 3 n \le {10}^3 n≤103， m ≤ 10 4 m \le {10}^4 m≤104。
对于 100 % 100\% 100% 的数据： 1 ≤ n , m ≤ 10 5 1 \le n, m \le {10}^5 1≤n,m≤105。

保证任意时刻数列中所有元素的绝对值之和 ≤ 10 18 \le {10}^{18} ≤1018。

【样例解释】

题解


import java.io.*;

public class Main {
    static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static final PrintWriter print = new PrintWriter(System.out);

    public static int nextInt() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }

    public static void main(String[] args) throws IOException {
        int n = nextInt();
        int m = nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt();
        }
        SegmentTrees s = new SegmentTrees(a);
        for (int i = 0; i < m; i++) {
            int j = nextInt();
            if (j == 1) {
                s.update(nextInt(), nextInt(), nextInt());
            } else
                print.println(s.get(nextInt(), nextInt()));
        }
        print.flush();
    }
}

class SegmentTrees {
    private final long[] tree;//线段树
    private final int size;
    private final int[] mapping;
    private final long[] lazy;

    public SegmentTrees(int[] mapping) {
        this.size = mapping.length;
        this.mapping = mapping;
        this.tree = new long[size * 4 + 3];
        this.lazy = new long[size * 4 + 3];
        build(1, size, 1);
    }

    /**
     * 建树
     *
     * @param l   左边界
     * @param r   右边界
     * @param pos 当前位置
     * @return 当前位置的值
     */
    public long build(int l, int r, int pos) {
        if (l == r) {
            return tree[pos] = mapping[l - 1];
        } else {
            int mid = (l + r) >> 1;
            return tree[pos] = build(l, mid, pos << 1)
                    + build(mid + 1, r, pos << 1 | 1);
        }
    }

    public void pushUp(int x) {
        tree[x] = (tree[x << 1] + tree[x << 1 | 1]);
    }

    public void update(int l, int r, int value) {
        this.updateL = l;
        this.updateR = r;
        getUpdate(1, size, 1, value);
    }

    private int updateL;
    private int updateR;

    /**
     * 更新
     *
     * @param l     左边界
     * @param r     右边界
     * @param pos   当前位置
     * @param value 更新值
     * @return 当前位置的值
     */
    public void getUpdate(int l, int r, int pos, int value) {
        if (r < updateL || l > updateR) return;
        if (l >= updateL && r <= updateR) {
            lazy[pos] += value;
            tree[pos] += (long) value * (r - l + 1);
        } else {
            int mid = (l + r) >> 1;
            updateLazy(l, r, pos, mid);
            getUpdate(l, mid, pos << 1, value);
            getUpdate(mid + 1, r, pos << 1 | 1, value);
            pushUp(pos);
        }
    }

    /**
     * 更新懒标记
     *
     * @param l   左边界
     * @param r   右边界
     * @param pos 当前位置
     * @param mid 中间位置
     */
    private void updateLazy(int l, int r, int pos, int mid) {
        if (lazy[pos] != 0) {
            lazy[pos << 1] += lazy[pos];
            lazy[pos << 1 | 1] += lazy[pos];
            tree[pos << 1] += lazy[pos] * (mid - l + 1);
            tree[pos << 1 | 1] += lazy[pos] * (r - mid);
            lazy[pos] = 0;
        }
    }

    public long get(int l, int r) {
        this.getL = l;
        this.getR = r;
        return getN(1, size, 1);
    }

    private int getL;
    private int getR;

    /**
     * 查询
     *
     * @param l   左边界
     * @param r   右边界
     * @param pos 当前位置
     * @return 当前位置的值
     */
    public long getN(int l, int r, int pos) {
        if (l > getR || r < getL)
            return 0;
        if (l >= getL && r <= getR) {
            return tree[pos];
        } else {
            int mid = (l + r) >> 1;
            int i = pos << 1;
            int j = i | 1;
            updateLazy(l, r, pos, mid);
            return getN(l, mid, i) +
                    getN(mid + 1, r, j);

        }
    }
}

【模板】线段树 2

题目描述

如题，已知一个数列，你需要进行下面三种操作：

  • 将某区间每一个数乘上 x x x

  • 将某区间每一个数加上 x x x

  • 求出某区间每一个数的和

输入格式

第一行包含三个整数 n , m , p n,m,p n,m,p，分别表示该数列数字的个数、操作的总个数和模数。

第二行包含 n n n 个用空格分隔的整数，其中第 i i i 个数字表示数列第 i i i 项的初始值。

接下来 m m m 行每行包含若干个整数，表示一个操作，具体如下：

操作 1 1 1： 格式：1 x y k 含义：将区间 [ x , y ] [x,y] [x,y] 内每个数乘上 k k k

操作 2 2 2： 格式：2 x y k 含义：将区间 [ x , y ] [x,y] [x,y] 内每个数加上 k k k

操作 3 3 3： 格式：3 x y 含义：输出区间 [ x , y ] [x,y] [x,y] 内每个数的和对 p p p 取模所得的结果

输出格式

输出包含若干行整数，即为所有操作 3 3 3 的结果。

样例 #1

样例输入 #1

5 5 38
1 5 4 2 3
2 1 4 1
3 2 5
1 2 4 2
2 3 5 5
3 1 4

样例输出 #1

17
2

提示

【数据范围】

对于 30 % 30\% 30% 的数据： n ≤ 8 n \le 8 n≤8， m ≤ 10 m \le 10 m≤10
对于 70 % 70\% 70% 的数据：$n \le 10^3 ， ， ， m \le 10^4$
对于 100 % 100\% 100% 的数据：$ n \le 10^5 ， ， ， m \le 10^5$

除样例外， p = 571373 p = 571373 p=571373

（数据已经过加强_）

样例说明：

故输出应为 17 17 17、 2 2 2（ 40   m o d   38 = 2 40 \bmod 38 = 2 40mod38=2 ）

题解

这个题目的难点较于普通的就在于对于乘法的控制了。
一个就是标记的下传。
如果同时有着乘法和加法标记应该怎么来做呢。
我们看到 ( x + d ) ∗ m (x+d)*m (x+d)∗m等价于 x ∗ m + d ∗ m x*m+d*m x∗m+d∗m,那么我们做向下传递的时候就可以传递 d 子 ∗ m + d 父 d_子*m+d_父 d子​∗m+d父​
传递规则如下

  1. 对于区间和： t r e e [ p o s ] = t r e e [ p o s ] ∗ m u l + a d d ∗ l e n % p tree[pos] = tree[pos]*mul+add*len \%p tree[pos]=tree[pos]∗mul+add∗len%p
  2. 对于mul标记： m u l [ p o s ] = m u l [ p o s ] ∗ v a l u e % p mul[pos] = mul[pos]*value\%p mul[pos]=mul[pos]∗value%p
  3. 对于add标记: a d d [ p o s ] = a d d [ p o s ] + a d d [ p o s ] ∗ m u l [ p o s ] % p add[pos] = add[pos]+add[pos]*mul[pos] \%p add[pos]=add[pos]+add[pos]∗mul[pos]%p
import java.io.*;
import java.util.Arrays;

public class Main {
     static final StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
   

    static final PrintWriter print = new PrintWriter(System.out);

    public static int nextInt() throws IOException {
        st.nextToken();
        return (int) st.nval;
    }

    public static void main(String[] args) throws IOException {
        int n = nextInt();
        int m = nextInt();
        int p = nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = nextInt();
        }
        SegmentTrees s = new SegmentTrees(a);
        for (int i = 0; i < m; i++) {
            int j = nextInt();
            if (j == 1) {
                s.update(nextInt(), nextInt(), -nextInt());
            } else if (j == 2) {
                s.update(nextInt(), nextInt(), nextInt());
            } else {
                print.println(s.get(nextInt(), nextInt()) % p);
            }
        }
        print.flush();
    }
}

class SegmentTrees {
    private final long[] tree;//线段树
    private final int size;
    private final int[] mapping;
    private final long[] add;
    private final long[] mul;
    private final int p = 571373;

    public SegmentTrees(int[] mapping) {
        this.size = mapping.length;
        this.mapping = mapping;
        this.tree = new long[size * 4 + 1];
        this.add = new long[size * 4 + 1];
        this.mul = new long[size * 4 + 1];
        Arrays.fill(mul, 1);
        build(1, size, 1);
    }

    /**
     * 建树
     *
     * @param l   左边界
     * @param r   右边界
     * @param pos 当前位置
     * @return 当前位置的值
     */
    public long build(int l, int r, int pos) {
        if (l == r) {
            return tree[pos] = mapping[l - 1] % p;
        } else {
            int mid = (l + r) >> 1;
            return tree[pos] = (build(l, mid, pos << 1)
                    + build(mid + 1, r, pos << 1 | 1)) % p;
        }
    }


    private int updateL;
    private int updateR;

    public void pushUp(int x) {
        tree[x] = (tree[x << 1] + tree[x << 1 | 1]) % p;
    }

    public void update(int l, int r, int value) {
        this.updateL = l;
        this.updateR = r;
        if (value > 0)
            getUpdate(1, size, 1, value);
        else
            getNewUpdate(1, size, 1, -value);
    }
    private void getNewUpdate(int l, int r, int pos, int value) {
        if (r < updateL || l > updateR) return;
        if (l >= updateL && r <= updateR) {
            tree[pos] = (tree[pos] * value) % p;
            mul[pos] = mul[pos] * value % p;
            add[pos] = add[pos] * value % p;
        } else {
            int mid = (l + r) >> 1;
            updateLazy(l, r, pos, mid);
            getNewUpdate(l, mid, pos << 1, value);
            getNewUpdate(mid + 1, r, pos << 1 | 1, value);
            pushUp(pos);

        }

    }

    /**
     * 更新
     *
     * @param l     左边界
     * @param r     右边界
     * @param pos   当前位置
     * @param value 更新值
     * @return 当前位置的值
     */
    public void getUpdate(int l, int r, int pos, long value) {
        if (r < updateL || l > updateR)
            return;
        if (l >= updateL && r <= updateR) {
            tree[pos] = (tree[pos] + value * (r - l + 1)) % p;
            add[pos] = (add[pos] + value) % p;
        } else {
            int mid = (l + r) >> 1;
            updateLazy(l, r, pos, mid);
            getUpdate(l, mid, pos << 1, value);
            getUpdate(mid + 1, r, pos << 1 | 1, value);
            pushUp(pos);
        }
    }

    /**
     * 更新懒标记
     *
     * @param l   左边界
     * @param r   右边界
     * @param pos 当前位置
     * @param mid 中间位置
     */
    private void updateLazy(int l, int r, int pos, int mid) {
        if (add[pos] != 0 || mul[pos] != 1) {
            int ls = pos << 1;
            int lr = ls | 1;
            tree[ls] = (tree[ls] * mul[pos] % p + add[pos] * (mid - l + 1) % p) % p;
            mul[ls] = mul[ls] * mul[pos] % p;
            add[ls] = (add[ls] * mul[pos] % p + add[pos]) % p;

            tree[lr] = (tree[lr] * mul[pos] % p + add[pos] * (r - mid) % p) % p;
            mul[lr] = mul[lr] * mul[pos] % p;
            add[lr] = (add[lr] * mul[pos] % p + add[pos]) % p;

            add[pos] = 0;
            mul[pos] = 1;
        }
    }

    public long get(int l, int r) {
        this.getL = l;
        this.getR = r;
        return getN(1, size, 1);
    }

    private int getL;
    private int getR;

    /**
     * 查询
     *
     * @param l   左边界
     * @param r   右边界
     * @param pos 当前位置
     * @return 当前位置的值
     */
    public long getN(int l, int r, int pos) {
        if (l > getR || r < getL)
            return 0;
        if (l >= getL && r <= getR) {
            return tree[pos];
        } else {
            int mid = (l + r) >> 1;
            int i = pos << 1;
            int j = i | 1;
            updateLazy(l, r, pos, mid);
            return (getN(l, mid, i) +
                    getN(mid + 1, r, j)) % p;
        }
    }
}
一只小余
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构专题 - 学习笔记：线段树分治
Plozia 的小窝
03-30 1536
线段树分治的学习笔记。
数据结构专题-学习笔记：线段树合并
Plozia 的小窝
12-08 757
数据结构专题 - 线段树合并的学习笔记。
洛谷题单【数据结构2-2】线段树与树状数组
Tracy_yi的博客
08-14 428
自用整理
【线段树模板】区间和与区间更新，以洛谷 P3372 【模板】线段树 1为例。
未来就在脚下。
01-09 946
线段树是解决区间查询和更新问题的非常有效的数据结构。理解它的关键点在于理解懒惰更新这一个点，总的来说，这里的线段树其实就是一个完全二叉树，借助懒惰更新实现了更低的复杂度，如果不熟悉线段树就对着代码重新敲一遍，原理很好理解。
【模板】线段树 1（洛谷P3372）
GordrnGhost的博客
04-19 537
【代码】【模板】线段树 1（洛谷P3372）
[数据结构]----[线段树]-----线段树常见操作和例题
Berserker____的博客
12-20 347
基本操作， 单点修改，区间和: 洛谷P3374 【模板】树状数组 1. 区间修改，单点查询: 洛谷P3368 【模板】树状数组 2. 区间修改，区间求和: 洛谷P3372 【模板】线段树 1. 区间最值: 洛谷P1531 I Hate It. 洛谷P1816 忠诚. 洛谷P2880 [USACO07JAN]Balanced Lineup G. 区间布尔值取反： 洛谷P3870 [TJOI2009]开关. 洛谷P2574 XOR的艺术. 区间加，区间乘混合 区间加，区间乘，区间求和: 洛谷P3373 【模板】
洛谷 - P3373 线段树区间-修改(进阶)
weixin_43533544的博客
05-05 258
本题作为模板题实在是太屈才了， 是一道很好的题目，做完以后本人对线段树有了更深的理解。单就此题而言，两种修改操作是互相影响的，修改乘法的时候是要先考虑加法的修改。为了避免这种先加后乘的影响，我们在打 lazy-tag的时候要注意 lson.add = (t[o].add + lson.add * t[o].p) % mod; 即乘法之前先把加法的 lazy_tag 先乘出来，然后再更新加法的l...
数据结构学习笔记 - 线段树（基础）
haobowen的博客
02-09 541
前言 众所周知线段树这个数据结构，比较麻烦。但在解决类似于区间修改和查询这种问题的时候会很方便，其实也没有那么方便。具体来说，之所以不用暴力或者树状数组来进行上述操作，是因为有的题目对算法效率要求高，普通的算法就不行了。总结来说，我们在学习线段树之前，应该要理解我们为什么要学线段树，学了之后在哪种情况下会用到，和怎么把模板变成题目要求的代码。这些问题是我们要考虑到的。 定义 线段树是一种基于分治思想的二叉树结构，用于在区间上进行信息统计。与按照二进制（2的次幂）进行区间划分的树状数组相比，线段树是一种
洛谷题单 206【数据结构2-2】线段树与树状数组
默的博客
12-26 145
文章目录P3374 【模板】树状数组 1P3368 【模板】树状数组 2 P3374 【模板】树状数组 1 单点增加和区间查询 #include <bits/stdc++.h> using namespace std; const int N = 1e6 + 5; typedef long long ll; int n, m, a[N]; // a 为原数组 ll c[N]; // c 为树状数组 // 返回x的二进制数下最小2的次幂 int lowbit(int x) { retu
洛谷精选-树形数据结构例题（1）
12-29
来自洛谷的精选树形数据结构，覆盖线段树、可持久化线段树、树状数组、并查集、平衡树、堆、cdq分治等多种树形数据结构，写完之后轻松掌握树形数据结构！！！
数据结构课程设计-线段树
06-08
线段树作为数据结构中的一种，尤其适用于处理区间查询和更新问题，它在算法设计和复杂性分析中占据着重要的地位。在这个数据结构课程设计中，我们将深入理解线段树的概念、构建方法以及其在实际问题中的应用。 线段...
算法-数据结构- 线段树.rar
09-16
线段树是一种高级的数据结构，主要用于处理区间查询与更新的问题。在计算机科学中，它是一种树形数据结构，能够高效地支持对一个数组的区间查询和修改操作。线段树通常用于解决动态区间求和、查找最值以及区间统计等...
统计的力量-线段树全接触-张昆玮
05-10
线段树是一种高效的数据结构，特别适用于处理动态的区间查询和更新问题。它在计算机科学，尤其是算法竞赛和计算几何领域中有着广泛的应用。线段树通过将一维空间（通常是一组数值或数组）划分为多个重叠的区间来工作...
线段树Java实现-SegmentTree
05-01
线段树Java实现——SegmentTree.txt 与文章中的讲解一致，几乎每句代码均有注释 阅读更方便，详细解析线段树 以区间求和为例进行代码的书写和解析。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1061
可以参考以下视频。
数据结构day3
最新发布
qq_55245263的博客
07-18 283
顺序表实现学生管理系统
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 242
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构初阶·排序算法(内排序)
2301_79697943的博客
07-18 916
目前常见的排序算法有9种，冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，计数排序，基数排序，桶排序。实际生活中排序的应用也是有限的，今天我们介绍其中7个，基数排序和桶排序不介绍。介绍常用的即可。顺带一嘴，本文里面所有的排序都是内排序，也就是在内存里面进行排序的，还有一种排序叫做外排序，即是在磁盘里面进行排序的，这种排序具有记忆性，外排序用到的就是归并排序，因为归并排序有一个特点就是空间复杂度为O(N)。好了正文开始。
ACM-ICPC比赛数据结构模板：二维树状数组与二维线段树
"ACM-ICPC数据结构模板，包括二维树状数组和二维线段树的实现" 在ACM-ICPC（国际大学生程序设计竞赛）中，掌握高效的数据结构和算法是至关重要的。本资源提供的模板主要涉及两种不常见的数据结构：二维树状数组（也...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一只小余

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值