JAVA线段树（单点修改，区间修改，区间查询）

樱花山下

于 2024-10-04 13:43:34 发布

阅读量234

点赞数 2

文章标签：算法 java 数据结构蓝桥杯

本文链接：https://blog.csdn.net/2301_79494744/article/details/142702330

版权

//线段树的单点修改，区间查询
import java.util.Scanner;

public class Main {
    static int[] segmentTree;
    static int n;

    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        n=scanner.nextInt();
        int[] nums=new int[n];
        for (int i = 0; i <n; i++) {
            nums[i]= scanner.nextInt();
        }
        NumArray(nums);
        int m=scanner.nextInt();
        for (int j = 0; j < m; j++) {
            int c= scanner.nextInt();
            switch (c){
                case 1:
                    update(scanner.nextInt()-1, scanner.nextInt());
                    break;
                case 2:
                    int ans=sumRange(scanner.nextInt()-1,scanner.nextInt()-1);
                    System.out.println(ans);
                    break;
            }
        }
        scanner.close();
    }

    public static void NumArray(int[] nums) {
        n = nums.length;
        segmentTree = new int[nums.length * 4];
        build(0, 0, n-1, nums);
    }

    public static void update(int index, int val) {
        change(index,val,0,0,n-1);
    }
    public static int sumRange(int left,int right){
        return range(left,right,0,0,n-1);
    }

    private static int range(int left, int right, int node, int l, int r) {
        if(left==l&&right==r){
            return segmentTree[node];
        }
        int mid=(l+r)/2;
        if(right<=mid){
            return range(left,right,node*2+1,l,mid);
        } else if (left>mid) {
            return range(left,right,node*2+2,mid+1,r);
        }else {
            return range(left,mid,node*2+1,l,mid)+range(mid+1,right,node*2+2,mid+1,r);
        }
    }


    public static void build(int node, int l, int r, int[] nums) {
        if (r == l) {
            segmentTree[node] += nums[r];
            return;
        }
        int mid = (r + l) / 2;
        build(node * 2 + 1,l, mid, nums);
        build(node * 2 + 2, mid + 1, r, nums);
        segmentTree[node] = segmentTree[node * 2 + 1] + segmentTree[node * 2 + 2];
    }

    public static void change(int index, int val, int node, int l, int r) {
        if (l == r) {
            segmentTree[node] += val;
            return;
        }
        int mid = (r + l) / 2;
        if (index <= mid) {
            change(index, val, node * 2 + 1, l, mid);
        } else {
            change(index, val, node * 2 + 2, mid + 1, r);
        }
        segmentTree[node] = segmentTree[node * 2 + 1] + segmentTree[node * 2 + 2];
    }

}

//区间修改，区间查询
import java.util.Scanner;

public class Main {
    static long[] segmentTree;
    static int n;
    static long[] label;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        int m = scanner.nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = scanner.nextInt();
        }
        NumArray(nums);
        for (int j = 0; j < m; j++) {
            int c = scanner.nextInt();
            switch (c) {
                case 1:
                    //区间修改
                    int le= scanner.nextInt()-1;
                    int ri= scanner.nextInt()-1;
                    long val= scanner.nextInt();
                    update(le,ri,val);
                    break;
                case 2:
                    long ans = sumRange(scanner.nextInt() - 1, scanner.nextInt() - 1);
                    System.out.println(ans);
                    break;
            }
        }
        scanner.close();
    }

    public static void NumArray(int[] nums) {
        n = nums.length;
        segmentTree = new long[nums.length * 4];
        label = new long[nums.length * 4];
        build(0, 0, n - 1, nums);
    }

    public static void update(int le, int ri, long val) {
        change(le, ri, val, 0, 0, n - 1);
    }

    public static long sumRange(int left, int right) {
        return range(left, right, 0, 0, n - 1,0);
    }


    public static void build(int node, int l, int r, int[] nums) {
        if (r == l) {
            segmentTree[node] += nums[r];
            return;
        }
        int mid = (r + l) / 2;
        build(node * 2 + 1, l, mid, nums);
        build(node * 2 + 2, mid + 1, r, nums);
        segmentTree[node] = segmentTree[node * 2 + 1] + segmentTree[node * 2 + 2];
    }

    public static void change(int le, int ri, long val, int node, int l, int r) {
        segmentTree[node]+=(ri-le+1)*val;//修改值
        if (le == l && ri == r) {
            label[node] += val;//修改标签
            return;
        }
        //寻找目标区间
        int mid = (r + l) / 2;
        if (ri <= mid) {
            change(le, ri, val, node * 2 + 1, l, mid);
        } else if (le > mid) {
            change(le, ri, val, node * 2 + 2, mid + 1, r);
        } else {
            change(le, mid, val, node * 2 + 1, l, mid);
            change(mid + 1, ri, val, node*2+2, mid + 1, r);
        }
    }

    private static long range(int left, int right, int node, int l, int r,long sum) {
        if (left == l && right == r) {
            return segmentTree[node]+sum*(r-l+1);
        }
        sum+=label[node];//更新标记
        int mid = (l + r) / 2;
        if (right <= mid) {
            return range(left, right, node * 2 + 1, l, mid,sum);
        } else if (left > mid) {
            return range(left, right, node * 2 + 2, mid + 1, r,sum);
        } else {
            return range(left, mid, node * 2 + 1, l, mid,sum) + range(mid + 1, right, node * 2 + 2, mid + 1, r,sum);
        }
    }

}