我用Java学数据结构之线段树底层实现 ^-^

最新推荐文章于 2024-04-18 00:57:39 发布
最新推荐文章于 2024-04-18 00:57:39 发布
阅读量201 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sb7474456/article/details/90756206
版权

线段树（SegmentTree）也叫区间树

最经典的线段树问题：区间染色，区间查询

比如说统计某电商网站2017年的消费最高的，这个问题其实是简单的

但是我先看的是2017年至现在的消费情况，它的数据一直是变得，那么线段树是一个不错的选择

它的数据是不断更新的，不断查询的，也可以使用数组实现

我们不考虑在线段树中添加或删除元素，我们所解决的问题是区间本身是固定的，只是区间中的元素可能发生变化

那么线段树具体是什么样子的呢>

线段树不是完全二叉树

线段树是平衡二叉树

 上面这个例子是刚刚存储的数据个数为2^3个

如果说要是存储十个数据会是什么样子呢

线段树的创建：

首先要根据给出的数组构建出一棵线段树，构造中根据自己传入的合并器在构建的时候为要存储的元素的根节点，根节点的根节点....附上值

public interface Merger<E> {
    E merge(E a, E b);
}
    /**
     * 线段树中的元素
     */
    private E[] data;
    /**
     * 将要存储的元素构造为树之后的引用
     */
    private E[] tree;
    private Merger<E> merger;

    public SegmentTree(E[] arr, Merger<E> merger) {
        this.merger = merger;
        //在构造中首先保留一个副本
        data = (E[]) new Object[arr.length];
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }
        //根据计算得出来的结论开辟出存储元素的树结构需要的空间
        tree = (E[]) new Object[4 * arr.length];
        buildSegmentTree(0, 0, arr.length - 1);
    }

    /**
     * 在treeIndex的位置创建  区间【l . . . r】的线段树
     *
     * @param treeIndex 根节点
     * @param l         左端点
     * @param r         右端点
     */
    private void buildSegmentTree(int treeIndex, int l, int r) {
        //做为返回条件，当区间的左右端点相等的时候，
        // 说明已经到达正确的位置，可以将想要放置的值赋值进树中
        if (l == r) {
            tree[treeIndex] = data[l];
            return;
        }
        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIndex = rightChild(treeIndex);
        //mid变量表示所构建的线段树的中间位置
        int mid = l + (r - l) / 2;
        buildSegmentTree(leftTreeIndex, l, mid);
        buildSegmentTree(rightTreeIndex, mid + 1, r);
        //在构建完左右子树的时候，根据业务逻辑为父节点附上值
        //业务逻辑      比如说统计某个区间的所有值之和
        tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
    }

线段树的查询：

    public E query(int queryL, int queryR) {
        if (queryL < 0 || queryL >= data.length ||
                queryR < 0 || queryR >= data.length || queryL > queryR) {
            throw new IllegalArgumentException("Index  is illegal");
        }
        return query(0, 0, data.length - 1, queryL, queryR);
    }

    /**
     * 在以 treeIndex 为根节点的线段树 [l . . . r]中，
     * 搜索 区间[queryL . . . queryR] 范围的值
     */
    private E query(int treeIndex, int l, int r, int queryL, int queryR) {
        //此判断条件表示已经搜索到要找的区间了
        if (l == queryL && r == queryR) {
            return tree[treeIndex];
        }
        int mid = l + (r - l) / 2;
        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIndex = rightChild(treeIndex);

        //当要搜索的区间左侧边界都在要搜索的区间中间的右侧时     直接在右半边搜索就可以了
        if (queryL >= mid + 1) {
            return query(rightTreeIndex, mid + 1, r, queryL, queryR);
        } else if (queryR <= mid) {
            return query(leftTreeIndex, l, mid, queryL, queryR);
        }
        //当左右都有的时候，分别在左右搜索
        E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
        E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
        return merger.merge(leftResult, rightResult);
    }

线段树的更新操作：

    public void set(int index, E e) {
        if (index < 0 || index >= data.length) {
            throw new IllegalArgumentException("Index   is   Illegal");
        }

        set(0, 0, data.length - 1, index, e);
    }

    private void set(int treeIndex, int l, int r, int index, E e) {
        //当区间长度为一的时候，说明已经找到要更新的元素的位置
        if (l == r) {
            tree[treeIndex] = e;
            return;
        }
        int mid = l + (r - l) / 2;
        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIIndex = rightChild(treeIndex);
        if (index >= mid + 1) {
            set(rightTreeIIndex, mid + 1, r, index, e);
        } else /*index <= mid*/ {
            set(leftTreeIndex, l, mid, index, e);
        }
        //更新完成之后，其父节点的值也需要更新，父节点的父节点也是...
        tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIIndex]);
    }

完成基本操作之后，测试一下编写的方法>

public class Main {
    public static void main(String[] args) {
        Integer[] arr = {-2, 0, 3, -5, 2, -1};
        SegmentTree<Integer> segTree = new SegmentTree<Integer>(arr, (a, b) -> a + b);
        System.out.println(segTree.toString());
        System.out.println(segTree.query(2, 5));

        segTree.set(0, 2);
        System.out.println(segTree);
    }
}

整段代码：

public class SegmentTree<E> {
    /**
     * 线段树中的元素
     */
    private E[] data;
    /**
     * 将要存储的元素构造为树之后的引用
     */
    private E[] tree;
    private Merger<E> merger;

    public SegmentTree(E[] arr, Merger<E> merger) {
        this.merger = merger;
        //在构造中首先保留一个副本
        data = (E[]) new Object[arr.length];
        for (int i = 0; i < arr.length; i++) {
            data[i] = arr[i];
        }
        //根据计算得出来的结论开辟出存储元素的树结构需要的空间
        tree = (E[]) new Object[4 * arr.length];
        buildSegmentTree(0, 0, arr.length - 1);
    }

    /**
     * 在treeIndex的位置创建  区间【l . . . r】的线段树
     *
     * @param treeIndex 根节点
     * @param l         左端点
     * @param r         右端点
     */
    private void buildSegmentTree(int treeIndex, int l, int r) {
        //做为返回条件，当区间的左右端点相等的时候，
        // 说明已经到达正确的位置，可以将想要放置的值赋值进树中
        if (l == r) {
            tree[treeIndex] = data[l];
            return;
        }
        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIndex = rightChild(treeIndex);
        //mid变量表示所构建的线段树的中间位置
        int mid = l + (r - l) / 2;
        buildSegmentTree(leftTreeIndex, l, mid);
        buildSegmentTree(rightTreeIndex, mid + 1, r);
        //在构建完左右子树的时候，根据业务逻辑为父节点附上值
        //业务逻辑      比如说统计某个区间的所有值之和
        tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
    }

    public E query(int queryL, int queryR) {
        if (queryL < 0 || queryL >= data.length ||
                queryR < 0 || queryR >= data.length || queryL > queryR) {
            throw new IllegalArgumentException("Index  is illegal");
        }
        return query(0, 0, data.length - 1, queryL, queryR);
    }

    /**
     * 在以 treeIndex 为根节点的线段树 [l . . . r]中，搜索 区间[queryL . . . queryR] 范围的值
     *
     * @param treeIndex 线段树根节点
     * @param l
     * @param r
     * @param queryL
     * @param queryR
     * @return
     */
    private E query(int treeIndex, int l, int r, int queryL, int queryR) {
        //此判断条件表示已经搜索到要找的区间了
        if (l == queryL && r == queryR) {
            return tree[treeIndex];
        }
        int mid = l + (r - l) / 2;
        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIndex = rightChild(treeIndex);

        //当要搜索的区间左侧边界都在要搜索的区间中间的右侧时     直接在右半边搜索就可以了
        if (queryL >= mid + 1) {
            return query(rightTreeIndex, mid + 1, r, queryL, queryR);
        } else if (queryR <= mid) {
            return query(leftTreeIndex, l, mid, queryL, queryR);
        }
        //当左右都有的时候，分别在左右搜索
        E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
        E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
        return merger.merge(leftResult, rightResult);
    }

    public void set(int index, E e) {
        if (index < 0 || index >= data.length) {
            throw new IllegalArgumentException("Index   is   Illegal");
        }

        set(0, 0, data.length - 1, index, e);
    }

    private void set(int treeIndex, int l, int r, int index, E e) {
        //当区间长度为一的时候，说明已经找到要更新的元素的位置
        if (l == r) {
            tree[treeIndex] = e;
            return;
        }
        int mid = l + (r - l) / 2;
        int leftTreeIndex = leftChild(treeIndex);
        int rightTreeIIndex = rightChild(treeIndex);
        if (index >= mid + 1) {
            set(rightTreeIIndex, mid + 1, r, index, e);
        } else /*index <= mid*/ {
            set(leftTreeIndex, l, mid, index, e);
        }
        //更新完成之后，其父节点的值也需要更新，父节点的父节点也是...
        tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIIndex]);
    }


    /**
     * 获取某一个位置的元素
     * @param index
     * @return
     */
    public E get(int index) {
        if (index < 0 || index >= data.length) {
            throw new IllegalArgumentException("Index  is illegal");
        }
        return data[index];
    }

    public int getSize() {
        return data.length;
    }

    /**
     * 计算出左孩子索引
     *
     * @param index
     * @return
     */
    private int leftChild(int index) {
        return 2 * index + 1;
    }

    /**
     * 返回右孩子索引
     *
     * @param index
     * @return
     */
    private int rightChild(int index) {
        return 2 * index + 2;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("[ ");
        for (int i = 0; i < tree.length; i++) {
            if (tree[i] != null) {
                res.append(tree[i]);
            } else {
                res.append("null");
            }
            if (i != tree.length - 1) {
                res.append(", ");
            }
        }
        res.append(" ]");
        return res.toString();
    }
}

 

路^途^遥^远
关注
高级数据结构 - 线段树、权值线段树（Java & JS & Python）
程序员阿甘的博客
08-09 673
线段树、权值线段树
数据结构--Java语言描述
The_last_knight的博客
09-29 831
本篇文章是为了记录自己在学习数据结构时的笔记，会对常见的数据结构做基本的介绍以及使用Java语言进行实现。包括 动态数组 栈 队列 链表 二分搜索树 优先队列和堆 线段树 Trie树 并查集 AVL树 红黑树 哈希表 动态数组 API介绍 数组是一种根据下标操作的数据结构，它的查询速度很快，但是它有缺点，那就是数组的容量一旦在创建时确定，就不能进行更改，所以为了克服这一缺点，我们实现一个自己的...
线段树(Java)
悦悦的狗子
02-05 729
线段树 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。 这不是一棵完全二叉树，也不是满二叉树，是一棵平衡二叉树，如果将这棵树的最后一层不存在的节点定...
用Java实现线段树
xxx
01-21 1261
线段树是为区间更新和区间查询而生的数据结构，旨在快速解决区间问题。​ 一般来说，线段树是不会加节点的，也不支持动态添加节点。线段树也是二叉树的一种，不过它的节点是以一个区间来定义节点的。具有一个单一区间的就是叶子节点。所以线段树，本质上就是一棵区间树。​ 我们在查找的时候，只需要找出结果区间由哪些子区间构成即可。 实现代码 首先定义出基础的结构 public class SegmentTree { private Integer value; private Integer ma
线段树（java）
lpls1
10-15 168
1.相关时间复杂度： 因为总结点个数为2n，因此： 初始化：O(n) 因为不论哪种操作，对于每个深度都最多访问常数个结点，因此： 每次更新：O(logn) 每次求值：O(logn) 2.线段树结构： 线段树结点下标和元素范围下标均从0记。那么： 每个结点存着[l,r)范围内的值。 第0个结点维护[0,n)范围的值。 下标为k的元素的值对应线段树结点下标为n-1+k。 每个结点k的左右叶子结点下标分...
线段树（Java）
最新发布
weixin_45036949的博客
04-18 212
1.懒数组2.懒更新。
java8集合源码分析-Happy-With-Data-Structure:学习数据结构的一些代码，包括数组，链表，二分搜索树，集合，并查集，
06-04
学习数据结构的一些代码，包括数组，链表，二分搜索树，集合，映射，优先队列，并查集，线段树，字典树（前缀树），AVL树，红黑树，哈希表，如有错误，多多指教。 我们在调用set,map等标准库里的东西，大多使用平衡...
leetcode题库-algorithm:基于Java和TypeScript的数据结构，LeetCode题解，欢迎star~
06-29
基础数据结构：会使用Java和TypeScript实现底层的数据结构，并考虑数据结构中每个操作的时间复杂度 leetcode算法：算法主要会记录在本仓库的issue中，leetcode的每一个分类我都以标签的形式标记出来，欢迎参考 学习...
线段树 JAVA
weixin_49725604的博客
04-05 976
class SegmentTree { int[] arr; int[] sign; int len; //建一棵空树 public SegmentTree( int len ) { this.len = len; len *= 4; this.sign = new int[len]; this.arr = new int[len]; } //由一个已知数组来建树 pub.
线段树入门学习(三）懒操作(兼解POJ1823) JAVA
04-14
NULL 博文链接：https://128kj.iteye.com/blog/1739733
java 线段树
qq_43649937的博客
04-05 731
java
java线段树
tomorrow_shoe的博客
05-24 1048
class SegmentTree { //原数组 int[] arr; //线段树数组 int[] tree; public SegmentTree(int[] arr) { this.arr = arr; tree = new int[arr.length * 4]; buildTree(0, 0, arr.length - 1); } private void buildTree(int cur
java,线段树
weixin_30951231的博客
05-01 365
线段树： 　　你可以理解成：线段组成的树，很多人问我，线段树到底有何用处，其实这个问题，你可以自己去刷题，然后总结出检验。 线段的具体理解，我看到一篇很好的博客，我就不展开了。博客地址：https://blog.csdn.net/iwts_24/article/details/81484561 基础题目： hdu1166敌兵布阵： 如果我们没有学过线段树，我们肯定是用模拟+暴...
线段树 java_Java线段树
weixin_39746241的博客
02-12 174
线段树不是完全二叉树，是平衡二叉树堆也是平衡二叉树堆满二叉树：h层，一共有2^h-1个节点(大约是2^h)最后一层(h-1层)有2^(h-1)个节点最后一层的节点数大致等于前面所有层节点之和如果区间有n个元素，数组表示需要4n的空间不考虑添加元素，使用4n的静态空间即可接口：public interface Merger {E merge(E a, E b);}public class Segme...
线段树(JAVA版本)
suo_jia_hao的博客
06-20 180
package com.数据结构.树; /** * 〈线段树〉 * * @author Demi * @createDate 2020/2/13 */ public class SegmentTree<E> { private E[] data;//接收用户传进来的数组 private E[] tree;//线段树 private Merge<E> merge; //初始化数组和线段树并构建线段树 public SegmentT
线段树模板（Java）
Easenyang的博客
12-06 2596
  线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。它的主要优势是对于区间求和、区间求最大值、区间修改和单点修改的速度快，时间复杂度能达到O(logN)O(logN)O(logN)。   若以常规的方法在数组中进行区间求和等操作，时间复杂度会达到O(n)O(n)O(n)，若操作的次数量非常大，那么就很容易超时。线段树的优势就体现出来了   线段树的实现基于一维数组，用数组下标 2∗k+12 * k +12∗k+1 的元素代表左儿子，用下标 2∗k+
线段树【java实现】
weixin_63541561的博客
10-17 244
平衡二叉树，数组中的元素都存储在叶子结点中，如图是一个求区间最大值的线段树。已知数组arr[11,5,3,7,8,2] ，树的高度与数组的长度关系为：为了方便我们用代码实现线段树，将创建的数为满二叉树，如下图举例。
LeetCode 307. 区域和检索 - 数组可修改
weixin_38199770的博客
02-09 165
//解法一：树状数组 class NumArray { int n; int[] tree; int[] a; public NumArray(int[] nums) { this.n = nums.length; a = nums; tree = new int[this.n + 1]; for(int i = 1; i <= this.n; i++) add(i, nums[i.
等差数列与数据结构——线段树、树状数组解析
标签涉及信息竞赛、OI、线段树、树状数组和数据结构，内容包括具体题目实例的解析，如区间查询和单点修改等操作。" 线段树是一种高效的数据结构，常用于处理区间查询和修改的问题。其优点在于能够快速地对区间进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值