数据结构与算法——Java实现 4.数组

最新推荐文章于 2024-10-10 22:59:02 发布
最新推荐文章于 2024-10-10 22:59:02 发布
阅读量606 收藏 18
点赞数 17
分类专栏： 数据结构与算法 —— Java实现 常见算法与知识积累 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73983707/article/details/141969599
版权

目录

一、数组 — 概述

1.定义

2.特点

 3.公式

小测试

二、数组的性能

1.空间占用

2.随机访问

三、动态数组

1.实现动态数组

2.新增元素（最后一个元素位置）

3.新增元素、数组扩容

4.检查数组容量

 5.类中定义的其他方法

① 按索引查找元素

② 返回数组长度

③ 遍历数组

④ 遍历泛型

⑤ 函数式接口遍历

⑥ 迭代器遍历

⑦ Java流的方式遍历

⑧ 删除元素值

⑨ 重写比较方法

 6.整体代码

① 类

② 测试类

7.插入或删除性能

四、二维数组

1.定义格式

2.内存分布及内存占用

五、数组的缓存与局部性原理

局部性原理

上帝，请赐予我平静，去接受我无法改变的；

给予我勇气，去改变我能改变的；

赐我智慧，分辨这两者的区别。

                                                        —— 24.9.8

一、数组 — 概述

1.定义

        在计算机科学中，数组是由一组元素(值或变量)组成的数据结构。每个元素有至少一个索引或键来标识（元素的类型必须一致）

2.特点

        数组内的元素是连续存储的，所以数组中元素的地址，可以通过其索引计算出来，例如:

int[] arr = {1,2,3,4,5}
//           0 1 2 3 4

 3.公式

        知道了数组的数据起始地址BaseAddress，就可以由公式BaseAddress + i * size计算出索引 i 元素的地址

        ① i 即索引，在Java、C等语言中都是从 0 开始

        ② size 是每个元素占用的字节，例如 int 占 4 位，double 占 8 位 

小测试

byte[] array = {1,2,3,4,5};

已知array的数据的起始地址是0x7138f94c8，那么元素3的地址是什么？

        0x7138f94c8 + 2*1 = 0x7138f94ca

        16进制：0123456789abcdef

二、数组的性能

1.空间占用

Java 中数组结构为：

        8字节 markword（记录对象的哈希码、锁的信息等）
        4字节 class 指针(压缩类指针的情况)
        4字节 数组大小(决定了数组最大容量是 232)
        数组元素 + 对齐字节(java 中所有对象大小都是8字节的整数倍，不足的要用对齐字节补足)

例如：

int[] array = {1,2,3,4,5};

8 + 4 + 4 * 5 + 4(alignment)

markdown+指针+元素+对齐字节  

2.随机访问

即根据索引查找元素，与数据规模没有关系，时间复杂度是O(1)

三、动态数组

1.实现动态数组

size —— 逻辑大小，代表数组中有效的元素个数

capacity —— 数组的容量，代表数组中最大可以容纳的元素数

public class demo1ArrayVectorInsert implements Iterable<Integer> {
    // 准备三个属性
    private int size = 0;// 逻辑大小
    private int capacity = 8;// 容量
    // 懒惰初始化思想
    private int[] array = {};
}

2.新增元素（最后一个元素位置）

    public void addLast(int element){
        // size代表数组内有效元素个数
        // array[size] = element;
        // size++;
        add(size,element);
    }

3.新增元素、数组扩容

    // 数组增加元素，需要先进行数组扩容
    // index:插入元素的位置索引，element：插入的元素
    // 如果容量不够，需要先扩容
    public void add(int index,int element){
        // 容量的检查
        checkAndGrow();
        // System.arraycopy(array,index,array,index+1,size-index)：实现数组间的元素复制
        if(index < size && index >= 0) { // 拷贝到0-size-1的区间内
            // 从原始数组array的index索引开始，拷贝到同一个数组array，向后移动一位，拷贝size-index个元素
            System.arraycopy(array, index, array, index + 1, size - index);
        } else if (index == size) {
            array[index] = element;
            size ++;
        } else{
            // 对插入位置合法性进行判断
            System.out.println("Index out of bounds");
            return;
        }
    }

4.检查数组容量

    private void checkAndGrow() {
        // 容量的检查
        if(size == 0){
            // 检查数组容量是否为8
            array = new int[capacity];
        } else if(size == capacity){
            // 数组容量已满，应进行扩容：1.5倍 1.618倍 2倍
            capacity = capacity + (capacity >> 1);
            // 复制到新数组
            int[] newArray = new int[capacity];
            System.arraycopy(array,0,newArray,0,size);
            array = newArray;
        }
    }

 5.类中定义的其他方法

① 按索引查找元素

    // 按索引查找元素
    public int get(int index) {
        return array[index];
    }

② 返回数组长度

    // 返回数组长度
    public int length(){
        return array.length;
    }

③ 遍历数组

    // 遍历数组
    public void forEach(){
        for(int i = 0; i < size; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

④ 遍历泛型

    // 遍历泛型
    public void forEachGenirics(Consumer<Integer> consumer){
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }

⑤ 函数式接口遍历

    // consumer函数式接口，consumer：一个参数，没有返回值
    public void Foreach(Consumer<Integer> consumer){
        for (int i = 0; i < size; i++) {
        //    System.out.print(array[i]+" ");
            // 提供 array[i]
            // 返回 void
            consumer.accept(array[i]);
            System.out.print(" ");
        }
        System.out.println();
    }

⑥ 迭代器遍历

    // 迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            // 匿名内部类的写法
            int i = 0;
            @Override
            // 判断有没有下一个元素
            public boolean hasNext() {
                return i < size;
            }

            @Override
            // 返回当前元素，并移动到下一个元素
            public Integer next(){
                return array[i++];
            }
        };
    }

⑦ Java流的方式遍历

    // Java流的方式进行遍历
    public IntStream stream(){
        return IntStream.of(array);
    }

⑧ 删除元素值

   // 删除元素值
    public int remove(int index){
        if(index < size && index >= 0) {
            int removed = array[index];
            if(index < size - 1){
                System.arraycopy(array, index + 1, array, index, size - index - 1);
            }
            // arraycopy（原始数组，要移动的起始位置，目标数组，目标数组的起始位置），要移动的元素个数
            size--;
            return removed;
        }else {
            System.out.println("Index out of bounds");
            return 0;
        }
    }

⑨ 重写比较方法

    // 重写比较方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        demo1ArrayVectorInsert integers = (demo1ArrayVectorInsert) o;
        return size == integers.size && capacity == integers.capacity && Objects.deepEquals(array, integers.array);
    }

    @Override
    public int hashCode() {
        return Objects.hash(size, capacity, Arrays.hashCode(array));
    }

 6.整体代码

① 类

package Day2Array;

import java.util.Arrays;
import java.util.Iterator;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.stream.IntStream;

// Java自己实现ArrayList动态数组
// 迭代器遍历，实现一个接口Iterable
public class demo1ArrayVectorInsert implements Iterable<Integer> {
    // 准备三个属性
    private int size = 0;// 逻辑大小
    private int capacity = 8;// 容量
    // 懒惰初始化思想
    private int[] array = {};

    // 新增元素
    public void addLast(int element){
        // size代表数组内有效元素个数
        // array[size] = element;
        // size++;
        add(size,element);
    }

    // 数组增加元素，需要先进行数组扩容
    // index:插入元素的位置索引，element：插入的元素
    // 如果容量不够，需要先扩容
    public void add(int index,int element){
        // 容量的检查
        checkAndGrow();
        // System.arraycopy(array,index,array,index+1,size-index)：实现数组间的元素复制
        if(index < size && index >= 0) { // 拷贝到0-size-1的区间内
            // 从原始数组array的index索引开始，拷贝到同一个数组array，向后移动一位，拷贝size-index个元素
            System.arraycopy(array, index, array, index + 1, size - index);
        } else if (index == size) {
            array[index] = element;
            size ++;
        } else{
            // 对插入位置合法性进行判断
            System.out.println("Index out of bounds");
            return;
        }
    }

    private void checkAndGrow() {
        // 容量的检查
        if(size == 0){
            // 检查数组容量是否为8
            array = new int[capacity];
        } else if(size == capacity){
            // 数组容量已满，应进行扩容：1.5倍 1.618倍 2倍
            capacity = capacity + (capacity >> 1);
            // 复制到新数组
            int[] newArray = new int[capacity];
            System.arraycopy(array,0,newArray,0,size);
            array = newArray;
        }
    }

    // 按索引查找元素
    public int get(int index) {
        return array[index];
    }

    // 返回数组长度
    public int length(){
        return array.length;
    }

    // 遍历数组
    public void forEach(){
        for(int i = 0; i < size; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }

    // 遍历泛型
    public void forEachGenirics(Consumer<Integer> consumer){
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }

    // consumer函数式接口，consumer：一个参数，没有返回值
    public void Foreach(Consumer<Integer> consumer){
        for (int i = 0; i < size; i++) {
        //    System.out.print(array[i]+" ");
            // 提供 array[i]
            // 返回 void
            consumer.accept(array[i]);
            System.out.print(" ");
        }
        System.out.println();
    }


    // 迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            // 匿名内部类的写法
            int i = 0;
            @Override
            // 判断有没有下一个元素
            public boolean hasNext() {
                return i < size;
            }

            @Override
            // 返回当前元素，并移动到下一个元素
            public Integer next(){
                return array[i++];
            }
        };
    }

    // Java流的方式进行遍历
    public IntStream stream(){
        return IntStream.of(array);
    }

    // 删除元素值
    public int remove(int index){
        if(index < size && index >= 0) {
            int removed = array[index];
            if(index < size - 1){
                System.arraycopy(array, index + 1, array, index, size - index - 1);
            }
            // arraycopy（原始数组，要移动的起始位置，目标数组，目标数组的起始位置），要移动的元素个数
            size--;
            return removed;
        }else {
            System.out.println("Index out of bounds");
            return 0;
        }
    }

    // 重写比较方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        demo1ArrayVectorInsert integers = (demo1ArrayVectorInsert) o;
        return size == integers.size && capacity == integers.capacity && Objects.deepEquals(array, integers.array);
    }

    @Override
    public int hashCode() {
        return Objects.hash(size, capacity, Arrays.hashCode(array));
    }
}

② 测试类

package Day2Array;

import org.junit.Test;
import org.junit.jupiter.api.DisplayName;

public class test {
    @Test
    @DisplayName("删除遍历")
    public void test1() {
        demo1ArrayVectorInsert demo1ArrayVectorInsert = new demo1ArrayVectorInsert();
        demo1ArrayVectorInsert.addLast(1);
        demo1ArrayVectorInsert.addLast(2);
        demo1ArrayVectorInsert.addLast(3);
        demo1ArrayVectorInsert.addLast(4);
        demo1ArrayVectorInsert.addLast(5);

        int res = demo1ArrayVectorInsert.get(4);
        System.out.println(res);
    }

    @Test
    @DisplayName("删除遍历")
    public void test2() {
        demo1ArrayVectorInsert demo1ArrayVectorInsert = new demo1ArrayVectorInsert();
        demo1ArrayVectorInsert.addLast(1);
        demo1ArrayVectorInsert.addLast(2);
        demo1ArrayVectorInsert.addLast(3);
        demo1ArrayVectorInsert.addLast(4);
        demo1ArrayVectorInsert.addLast(5);

        // 遍历的方法
        // ① 自己写一个for循环，在类中写一个函数返回数组长度
        for (int i = 0; i < demo1ArrayVectorInsert.length(); i++) {
            System.out.print(demo1ArrayVectorInsert.get(i)+" ");
        }
        System.out.println(" ");

        // ② 在数组中写一个遍历的函数，调用函数
        demo1ArrayVectorInsert.forEach();

        // ③ 类定义一个接口，在数组中遍历的函数参数传递一个泛型，在调用函数时进行具体的实现
        demo1ArrayVectorInsert.forEach(element -> {
            demo1ArrayVectorInsert.forEach();
            System.out.print(element+" ");
        });

        // ④ 类定义一个接口，定义一个方法传递泛型类型，调用该方法时时进行具体的实现
        // 将来可以直接调用时修改函数，不需要再函数的定义内部进行代码的修改
        demo1ArrayVectorInsert.forEachGenirics(element -> {
            System.out.println(element);
        });

        // ⑤ 迭代器遍历：实现接口，用增强for循环使用
        demo1ArrayVectorInsert.Foreach(element->{
            demo1ArrayVectorInsert.forEach();
            System.out.print(element+" ");
        });
    }

    @Test
    @DisplayName("删除遍历")
    public void test3() {
        demo1ArrayVectorInsert demo1ArrayVectorInsert = new demo1ArrayVectorInsert();
        demo1ArrayVectorInsert.addLast(1);
        demo1ArrayVectorInsert.addLast(2);
        demo1ArrayVectorInsert.addLast(3);
        demo1ArrayVectorInsert.addLast(4);
        demo1ArrayVectorInsert.addLast(5);

        for (Integer element : demo1ArrayVectorInsert) {// hashNext() next()
            System.out.print(element+" ");
        }
    }

    @Test
    @DisplayName("删除遍历")
    public void test4() {
        demo1ArrayVectorInsert demo1ArrayVectorInsert = new demo1ArrayVectorInsert();
        demo1ArrayVectorInsert.addLast(1);
        demo1ArrayVectorInsert.addLast(2);
        demo1ArrayVectorInsert.addLast(3);
        demo1ArrayVectorInsert.addLast(4);
        demo1ArrayVectorInsert.addLast(5);

        demo1ArrayVectorInsert.stream().forEach(element->{
            System.out.print(element+" ");
        });
    }

    @Test
    @DisplayName("删除测试")
    public void test5() {
        demo1ArrayVectorInsert demo1ArrayVectorInsert = new demo1ArrayVectorInsert();
        demo1ArrayVectorInsert.addLast(1);
        demo1ArrayVectorInsert.addLast(2);
        demo1ArrayVectorInsert.addLast(3);
        demo1ArrayVectorInsert.addLast(4);
        demo1ArrayVectorInsert.addLast(5);

        // 删除第三位，索引为2的元素
        int removed = demo1ArrayVectorInsert.remove(2);
        demo1ArrayVectorInsert.forEach();
        // 验证期望删除值与返回值是否相等
        if(3 == removed){
            System.out.println("true");
        }else{
            System.out.println("false");
        }

        int removed2 = demo1ArrayVectorInsert.remove(3);
        demo1ArrayVectorInsert.forEach();
        // 验证期望删除值与返回值是否相等
        if(5 == removed){
            System.out.println("true");
        }else{
            System.out.println("false");
        }
    }

    @Test
    @DisplayName("扩容数组")
    public void test6() {
        demo1ArrayVectorInsert demo1ArrayVectorInsert = new demo1ArrayVectorInsert();
        for (int i = 0; i < 9; i++) {
            demo1ArrayVectorInsert.addLast(i+1);
        }
        demo1ArrayVectorInsert demo1ArrayVectorInsert1 = new demo1ArrayVectorInsert();
        demo1ArrayVectorInsert1.add(0,1);
        demo1ArrayVectorInsert1.add(1,2);
        demo1ArrayVectorInsert1.add(2,3);
        demo1ArrayVectorInsert1.add(3,4);
        demo1ArrayVectorInsert1.add(4,5);
        demo1ArrayVectorInsert1.add(5,6);
        demo1ArrayVectorInsert1.add(6,7);
        demo1ArrayVectorInsert1.add(7,8);
        demo1ArrayVectorInsert1.add(8,9);

        System.out.println("创建的新数组与目标数组是否相等："+ demo1ArrayVectorInsert1.equals(demo1ArrayVectorInsert));
    }
}

7.插入或删除性能

① 头部位置，时间复杂度是 O(n)

② 中间位置，时间复杂度是 O(n)

③ 尾部位置，时间复杂度是 O(1) (均摊来说)

四、二维数组

1.定义格式

int[][] array = {

        {11,12,13,14,15},

        {21,22,23,24,25},

        {31,32,33,34,35}

};

2.内存分布及内存占用

i：代表外层数组的索引位置

j：代表内层数组的索引位置

五、数组的缓存与局部性原理

局部性原理

这里只讨论空间局部性

       ① cpu读取内存(速度慢)数据后，会将其放入高速缓存(速度快)当中，如果后来的计算再用到此数据在缓存中能读到的话，就不必读内存了

        ② 缓存的最小存储单位是缓存行(cache line)，一般是 64 bytes,一次读的数据少了不划算，因此最少读 64 bvtes 填满一个缓存行，因此读入某个数据时也会读取其临近的数据，这就是所谓空间局部性

        先行后列访问的是连续内存，先列后行访问的是非连续内存，相当于访问链表

先i后j：int[0][0] ——> [0][1] ——> [0][2]... ——> [0][j]

            int[1][0] ——> [1][1] ——> [1[2]... ——> [1][j]

                ……

             int[i][0] ——> [i][1] ——> [i[2]... ——> [i][j]

先j后i：int[0][0]

             int[1][0]

             int[2][0]

                …

             int[i][0]

                ……

             int[][j]

L_cl
关注
专栏目录
数据结构&算法——Java.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
算法和数据结构——左程云.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
Java数据结构与算法02——队列
12-21
Java中的数据结构与算法是编程领域中至关重要的概念，它们为高效地处理和组织数据提供了基础。本篇文章将深入探讨队列这一基本的数据结构，并通过Java实现一个简单的数组模拟队列，以帮助读者理解其工作原理。 队列...
数据结构与算法分析Java3rd英文_数据结构与算法分析_
10-03
数据结构与算法分析是计算机...通过阅读《数据结构与算法分析Java3rd英文》这本书，你可以深入理解这些概念，并学习如何在Java中有效地应用它们。这本书会涵盖各种示例和练习，帮助读者巩固理论知识并提高实践技能。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 416
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1266
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
c语言练习题2(字符串和函数的使用)
最新发布
m0_74859128的博客
10-10 152
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 826
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
C语言动态内存管理(26)
tan180°的博客
10-06 1100
如果未来要想学好数据结构，那么你对指针、结构体还有本篇的动态内存的理解掌握能力是要很高的所以跟我一起开始本篇的学习吧！在C99中，结构体最后一个成员为未知大小的数组，这个被称为柔性数组的成员，帮助用户根据要求自己给大小，更加轻松地处理可变长度的数据结构int i;// 有些编译器可能会编译失败，可以化成nums[]}type_a;几个定语修饰词要搞明白，最后一个成员、未知大小、数组应该不算太难，算修炼内功，但很重要，部分代码必须自己去实践！
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 841
排序是将多个数据，依指定的顺序进行排列的过程。
【算法】---归并排序（递归非递归实现）
何春秋的博客
10-03 1185
归并排序 in Java
【旋转数组】二分法专题
weixin_45962681的博客
10-08 1184
以上两道题我小总结一下，有无重复元素影响的是=加不加，其实第一题也可以加，在无重复元素的时候，开区间加不加其实没所谓，但是当有重复元素的时候，考虑这个很重要我在刚开始学习二分法的时候，背诵的模板的不加等号的if，改的是left，其实我如果照着这个模板写这两道题，就不会错，但是我鬼使神差把不加等号那边改right了，导致一直不过那么可以总结一个有无重复元素通用的模板public:= right){
数据结构与算法——Java实现 32.堆
m0_73983707的博客
10-10 337
如果权值大于最末尾元素，则不断上调与其（最末尾元素，不断更新）父元素比较，直到找到小于堆中某元素的值或更新到堆顶元素。每个节点的总高度除以结点所在每一层的高度 *（高度-1）之和。有关，高度从下往上依次相加，交换次数为h-1，总交换次数为。大顶堆每个分支的上一个节点的权值要大于它的孩子节点。小顶堆每个分支的上一个节点的权值要小于它的孩子节点。不断的向堆中添加节点，添加时与堆最末尾元素进行比较。Floyd建堆算法的时间复杂度为O(n)时间复杂度为O(n*logn)（与其左右孩子节点中的。
C - Separated Lunch
m0_74304371的博客
10-05 471
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
16.最接近的三数之和
weixin_61695887的博客
10-04 326
与三数之和的题类似，首先对数组进行排序。排序后的数组使得我们可以有效地使用双指针法来找到和最接近目标值的三元组。：遍历结束后，返回最接近的三元组的和。，然后通过双指针法来寻找另外两个数。：遍历排序后的数组，固定一个数。中选出三个整数，使它们的和与。假定每组输入只存在恰好一个解。使得三数之和最接近目标值。
【算法】——双指针算法合集（力扣）
阿华的博客
10-09 343
移动零，复写零，快乐数，盛最多水的容器，有效三角形的个数，和为s的两个数（查找总价格为目标值的两个商品 ），三数之和，四数之和
排队打水(贪心)
qq_60510847的博客
10-06 495
有 nn 个人排队到 11 个水龙头处打水，第 ii 个人装满水桶所需的时间是 titi，请问如何安排他们的打水顺序才能使所有人的等待时间之和最小？
LeetCode hot100---数组及矩阵专题(C++语言)
qq_54017644的博客
10-04 345
【代码】LeetCode hot100---数组及矩阵专题(C++语言)
python-FILIP/字符串p形编码/数字三角形
2401_83954530的博客
10-04 961
例如：字符串 122344111 可被描述为 1个1、2个2、1个3、2个4、3个1 ，因此我们说122344111 的 p 型编码串为 1122132431；100200300 可描述为 1个1、2个 0、1个2、2个0、1个3、2个0，因此它的 p 型编码串为 112012201320。对于 100% 的数据，100≤a,b≤999，a,b 不含 0 或不为 0。那么该数的翻转同样有 f 位，最高位为为 af​，第二位为 af−1​，……设原数有 f 位，最高位为 a1​，第二位为 a2​，。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值