线段树和Tire

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量335 收藏
点赞数 2
分类专栏： 数据结构 文章标签： java maven 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48019875/article/details/121602287
版权
本文介绍了线段树这一数据结构，用于解决区间最值问题和区间求和。线段树非完全二叉树，而是平衡二叉树，可以用数组表示。文章详细讲解了线段树的构建过程，包括确定高度、节点数量以及避免边界问题的方法。同时，提到了查询和更新操作，并提供了完整的代码实现。
摘要由CSDN通过智能技术生成

目录

一、线段树能解决的问题

RMQ（区间最值问题）
区间求和
eg：如下图：区间求和[1:3] 答：42
区间[1:4]的最大值 答：22
在这里插入图片描述

二、构建线段树

（1）线段树不是完全二叉树，是平衡二叉树。可以使用数组表示树的节点
（2）给定一个数组arr ，获取生成线段树的高度
eg：2^(h-1) >=arr.length 的最小值
2^(h-1) >=8
h-1 >=log2^(8)
h>=4
所以生成线段树的高度为4
（3）节点个数最多为 ： 2^(h) -1
（4）生成线段树

    /**
     * 构建线段树
     * @param start 区间的开始
     * @param end   区间的结尾
     * @param index 线段树对应的[start:end] 区间的索引
     */
    public void buildingSegmentTree(int start, int end, int index) {
        //1、递归到底的情况
        if (start == end) {
            this.data[index] = this.source[start];
            return;
        }
        //2、递归操作
        int mid = start + (end - start) / 2;
        int lefindex = 2 * index + 1;
        int rightindex = lefindex + 1;
        buildingSegmentTree(start, mid, lefindex);
        buildingSegmentTree(mid + 1, end, rightindex);
        this.data[index] = this.merger.merge(this.data[lefindex], this.data[rightindex]);
    }

int mid = (start + end )/2;可能会超范围，所以使用int mid = start +（end - start）/2
此构建线段树的方法只支持求和操作，为了具有通用性，可以设计一个融合接口 Merge

public interface Merger<T> {
    T merge(T a,T b);
}


    private T[] source;//源数组
    private T[] data;//线段树对应的的数组
    private Merger<T> merger;

    public SegmentTree(T[]arr, Merger<T> merger) {
        this.merger = merger;
        if (arr!=null){
            this.source = Arrays.copyOf(arr,arr.length);
            int height =(int) Math.ceil(Math.log(this.source.length)/ Math.log(2) +1);
            int datalength =(int) Math.pow(2,height)-1;
            this.data = (T[])(new Object[datalength]);
            buildingSegmentTree(0,this.source.length-1,0);
        }
    }

三、查询操作

 /**
     * 进行查询操作
     * @param start  线段树节点所表示区间的start
     * @param end    线段树节点所表示区间的end
     * @param index  线段树上节点的索引
     * @param form   查询区间的开始
     * @param to     查询区间的结尾
     * @return
     */
    private   T query(int start,int end,int index,int form,int to){
        //1、递归到底的情况
        if (start == form&& end == to ){
            return this.data[index];
        }
        //2、递归操作 【1】完全不包含左边 【2】完全不包含右边 【3】左右两边都包含
        int leftIndex =2*index +1;
        int rightIndex =leftIndex+1;
        int mid =start +(end -start)/2;
        if (form>mid){
            return query(mid+1,end,rightIndex,form,to);
        }else  if (to<=mid){
            return query(start,mid,leftIndex,form,to);
        }else {
            //左边
            T leftValue = query(start,mid,leftIndex,form,mid);
            T rightValue = query(mid+1,end,rightIndex,mid+1,to);
            return  this.merger.merge(leftValue,rightValue);
        }

    }

在这里插入图片描述

四、更新操作

 /**
     * 更新源数组索引为index位置的值为val
     * @param site  源数组的索引
     * @param val   值
     */
    public  T  update(int site,T val){
        if (site<0||site>=this.source.length){
            throw  new IllegalArgumentException("index in invalid!");
        }
        //重新渲染线段树
     return    update(0,this.source.length-1,0,site,val);
    }

    private T update(int start, int end, int index, int orindex, T val) {
        //递归到底
        if (start==end&&start==orindex){
           return this.source[orindex]=this.data[index]=val;
           // return ;
        }
        //递归操作
        int mid = start +(end-start)/2;
        int leftIndex = 2*index +1;
        int rightIndex = leftIndex+1;
        if (mid<orindex){
            update(mid+1,end,rightIndex,orindex,val);
        }else {
            update(start,mid,leftIndex,orindex,val);
        }
      return   this.data[index] =this.merger.merge(this.data[leftIndex],this.data[rightIndex]);
    }

在这里插入图片描述

五、完整代码

package lesson7;

import java.util.Arrays;

public class SegmentTree<T> {
    public static void main(String[] args) {
        Integer[] arr = {19, 2, 18, 22, 5};
        SegmentTree<Integer> segmentTree = new SegmentTree<>(arr, (Integer a, Integer b) -> a + b);
        System.out.println(segmentTree);
        Integer result = segmentTree.getRangValue(1, 3);
        //索引从1-3的数组的和
        System.out.println("arr[1:3]的和=" + result);

        Integer integer= segmentTree.update(2,6);
        System.out.println("更新索引为2的值为6");
        System.out.println("arr数组最大值:"+integer);
        System.out.println(segmentTree);

    }
    private T[] source;//源数组
    private T[] data;//线段树对应的的数组
    private Merger<T> merger;

    public SegmentTree(T[]arr, Merger<T> merger) {
        this.merger = merger;
        if (arr!=null){
            this.source = Arrays.copyOf(arr,arr.length);
            int height =(int) Math.ceil(Math.log(this.source.length)/ Math.log(2) +1);
            int datalength =(int) Math.pow(2,height)-1;
            this.data = (T[])(new Object[datalength]);
            buildingSegmentTree(0,this.source.length-1,0);
        }
    }

    /**
     * 构建线段树
     * @param start 区间的开始
     * @param end   区间的结尾
     * @param index 线段树对应的[start:end] 区间的索引
     */
    public void buildingSegmentTree(int start, int end, int index) {
        //1、递归到底的情况
        if (start == end) {
            this.data[index] = this.source[start];
            return;
        }
        //2、递归操作
        int mid = start + (end - start) / 2;
        int lefindex = 2 * index + 1;
        int rightindex = lefindex + 1;
        buildingSegmentTree(start, mid, lefindex);
        buildingSegmentTree(mid + 1, end, rightindex);
        this.data[index] = this.merger.merge(this.data[lefindex], this.data[rightindex]);
    }


    public T getRangValue(int form, int to) {
        if (form < 0 || to >= this.source.length || form > to) {
            throw new IllegalArgumentException("eorror");
        }
        return query(0, this.source.length - 1, 0, form, to);
    }

    /**
     * 进行查询操作
     * @param start  线段树节点所表示区间的start
     * @param end    线段树节点所表示区间的end
     * @param index  线段树上节点的索引
     * @param form   查询区间的开始
     * @param to     查询区间的结尾
     * @return
     */
    private   T query(int start,int end,int index,int form,int to){
        //1、递归到底的情况
        if (start == form&& end == to ){
            return this.data[index];
        }
        //2、递归操作 【1】完全不包含左边 【2】完全不包含右边 【3】左右两边都包含
        int leftIndex =2*index +1;
        int rightIndex =leftIndex+1;
        int mid =start +(end -start)/2;
        if (form>mid){
            return query(mid+1,end,rightIndex,form,to);
        }else  if (to<=mid){
            return query(start,mid,leftIndex,form,to);
        }else {
            //左边
            T leftValue = query(start,mid,leftIndex,form,mid);
            T rightValue = query(mid+1,end,rightIndex,mid+1,to);
            return  this.merger.merge(leftValue,rightValue);
        }

    }

    /**
     * 更新源数组索引为index位置的值为val
     * @param site  源数组的索引
     * @param val   值
     */
    public  T  update(int site,T val){
        if (site<0||site>=this.source.length){
            throw  new IllegalArgumentException("index in invalid!");
        }
        //重新渲染线段树
     return    update(0,this.source.length-1,0,site,val);
    }

    private T update(int start, int end, int index, int orindex, T val) {
        //递归到底
        if (start==end&&start==orindex){
           return this.source[orindex]=this.data[index]=val;
           // return ;
        }
        //递归操作
        int mid = start +(end-start)/2;
        int leftIndex = 2*index +1;
        int rightIndex = leftIndex+1;
        if (mid<orindex){
            update(mid+1,end,rightIndex,orindex,val);
        }else {
            update(start,mid,leftIndex,orindex,val);
        }
      return   this.data[index] =this.merger.merge(this.data[leftIndex],this.data[rightIndex]);
    }


    @Override
    public String toString() {
      StringBuilder sb =new StringBuilder("[");
      if (this.data!=null&&this.data.length!=0){
          Arrays.stream(this.data).forEach(item->{
              sb.append(item+",");
          });
      }
     /* sb.deleteCharAt(sb.length()-1);
      sb.append("]");
      return sb.toString();*/
        return sb.deleteCharAt(sb.length() - 1).append("]").toString();
    }
}
高朵
关注
专栏目录
模板 - AC自动机
繁凡さん的博客
05-16 1597
AC自动机模板
线段树和Trie
m0_53680228的博客
12-19 178
Trie
【集训】Tire & 线段树
Kiritow的学园
08-18 451
每日集训，为自己而战！
线段树学习笔记
hacker__man的博客
07-21 209
线段树学习笔记
线段树的理论学习
qq_51340293的博客
08-31 192
​ 用途：线段树主要用来搜寻一个区间里的最大或者最小值亦或者一个区间内的数据之和，线段树是一种，与相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点，使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度未2N，实际应用时一般还要开4N的数组已免越界，因此有时候需要离散化让空间压缩。...
tire树，树状数组，线段树模板
Scanew
10-27 805
tire树 ，分为插入过程中的V用来保存权值 val[i]!=0表示这是个单词节点。 struct tire { ch[100000][26]; val[100000]; int sz; tire(){memset(ch,0,sizeof(ch));sz=1;} int id(char c) {
HDU 4417 线段树离线查询
LinzhiQQQ的博客
09-02 311
Super Mario Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 7230    Accepted Submission(s): 3116 Problem Description Mario is world
字典树、线段树
mtxxyd的博客
01-05 987
改一个值的时间复杂度是O(n),查找一段数据的值的和时间度是O(1),因为sum_query是一个记录之前数的和的数组。字典树，顾名思义，也就是像字典一样的树。字典中的每个单词在字典树中表现为一条从根节点出发的路径，路径相连的边上的字母连起来就形成对应的字符串。线段树的根节点存储的值是所有值的和，左节点是当前父节点的一半值的和，右节点也是一半的值的和，不过左节点是前半段，右节点是后半段。**：利用空间换时间，利用字符串的公共前缀来降低查询时间的开销，最大限度的减少无谓的字符串比较，以达到提高效率的目的。
[BZOJ3166][Heoi2013]Alo（可持久化线段树+可持久化tire树）
zyf2000
12-15 730
题目描述传送门题解xorxor的操作很容易想到可持久化trie树，但是关键是次大值比较头疼。 可以发现，如果可以维护出来每一个点向前和向后第一个以及第二个比它大的值的位置就可以确定区间了。 实际上，可以用可持久化线段树的思想来搞。将所有的值从大到小排序，然后按照每一个点的位置插入线段树，相当于对于每一个点，比它大的点已经都插入进去了。每一次查询就是从权值大于当前点的线段树里找出当前点前驱的前驱，
Hysbz 回转寿司 权值线段树+动态开点
yangzijiangac的博客
12-18 321
Hysbz: 动态开点+权值线段树 避免炸空间的离线做法和在线做法 对于操作权值线段树，避免炸内存，有在线做法和离线做法，离散化是离线做法，但是离散化需要的是，我们对数据大小不做考虑，仅考虑数据数量，而且数据数量比较少，方可离散化，而在线做法的动态开点则显得更加有优势，他既能考虑数据大小，又能不炸空间 普通线段树和动态开点线段树比较 普通的线段树，先把要的所有空间开出来，而动态开点线段树，是...
【CodeForces - 163E】：e-Government【AC自动机fail树上dfs序+树状数组】
KobeDuu
10-08 346
题目: CodeForces - 163E：e-Government 题意： 给出 K个模式串，N 次操作：（1）删除一个模式串（2）添加一个模式串（K个中的某一个）（3）给出一个主串，问模式串在主串中总共出现了多少次 笔记: fail树： AC自动机上每一个节点都有唯一的fail指针，那么将fail指针逆转后，所有的 fail指针和节点将形成一颗有根树 根据 fail指针的定义...
字符串算法总结——字典树
LiuKairui的博客
06-09 1396
字典树 好不容易不用学EXKMP，开森，实际上字典树很简单，我们看： 已知有 n 个长度不一定相同的母串，以及一个长度为 m 的模式串 T，求该模式串是否是其中一个母串的前缀。如果将模式串 T 挨个去比较，则算法复杂度会很高，达到 O(n×m)，是否有高效的方法呢？ 已知一个长度为 n 的字符串 S，求该字符串有多少个不相同的子串。朴素的做法，可以先枚举出所有的子串，这样时间复杂度为 O(n...
P3293 [SCOI2016]美味 （主席树）
qq_45288870的博客
10-09 131
传送门 要求最大的异或值，最先想到的就是tire树了，又有区间的限制，就试了试可持久化tire树，然后发现+x没办法处理，遂自闭。题解的思路真是妙啊，还是借助tire的思想，假设 b 的第 i 位是0，那么就找 a[j]+x是否存在第 i 位是1 的数，反之亦然，要保证异或值最大嘛。 怎么去找呢，定义一个变量num表示第 i 位之前使异或值最大的那个数（仅考虑第i位之前的 a[j]+x），第 i 位如果是0，a[j]+x的第 i 位就尽量填1，就是a[j]+x要属于区间 [ 2i2^i2i,2i+1−12^
01Trie/可持久化01Trie学习笔记
Lolierl的博客
08-15 1796
01Trie是什么？它是一种较为特殊的权值线段树，可以解决一类与按位运算有关的问题。
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 138
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 814
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 874
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
基于Mysql、JavaScript、PHP、ajax开发的MBTI性格测试网站（前端+后端）
2302_79553009的博客
10-29 1434
本项目旨在构建一个基于MBTI（迈尔斯-布里格斯性格分类指标）理论的在线平台——“16Personalities”。该平台利用PHP、MySQL、JavaScript等技术栈开发，旨在帮助用户更好地理解和运用MBTI理论来评估个人性格类型，并应用于职业规划、团队建设和人际交往等多个方面。用户端功能 包括账号注册与登录、在线性格测试、性格类型浏览、团队评估及在线交友等模块。用户可以通过完成性格测试来获得详细的MBTI性格分析，并通过平台提供的功能与其他具有不同性格类型的用户互动。
SpringSession源码分析
lkr_lkr的博客
11-01 252
默认对常规Session的理解和使用，如何使用Set-Cookie。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值