Java实现链表，队列，稀疏数组

最新推荐文章于 2022-04-28 23:46:37 发布
最新推荐文章于 2022-04-28 23:46:37 发布
阅读量130 收藏
点赞数
文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47171492/article/details/108626813
版权

1.稀疏数组

为了节约空间，引入了稀疏数组！

在一些二维数组中，如果有很多的无效数据，那么转化为稀疏数组无疑是一个好的选择！

package SparseArray;
//稀疏数组
public class SparseArrayDemo {
    //二维数组转稀疏数组
    public static void main(String[] args) {
        int sum = 0;
        int[][] arr = new int[10][10];
        arr[0][1] = 3;
        arr[3][8] = 7;

        for (int x[]:arr){
            for (int y:x){
                sum++;
                System.out.printf("%d\t",y);
                if (sum % 10 == 0){
                    System.out.println();
                }
            }
        }
        int number = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length ; j++) {
                if (arr[i][j] != 0 ){
                    number++;
                }
            }
        }
        //将二维数组转化为稀疏数组
        int sparseArray[][] = new int[number+1][3];
        sparseArray[0][0] = number;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = 11;
        int s = 1;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length ; j++) {
                if (arr[i][j] != 0 ){
                    sparseArray[s][0] = arr[i][j];
                    sparseArray[s][1] = i;
                    sparseArray[s][2] = j;
                    s++;
                }
            }
        }
        System.out.println();
        int num = 0;
        for (int x[]:sparseArray){
            for (int y:x){
                num++;
                System.out.printf("%d\t",y);
                if (num % 3 == 0){
                    System.out.println();
                }
            }
        }
        //将稀疏数组转化为二维数组
        int newArray[][] = new int[sparseArray[0][1]][sparseArray[0][2]];
        for (int i = 1; i < sparseArray.length; i++) {
            for (int j = 0; j < 3 ; j++) {
                newArray[sparseArray[i][1]][sparseArray[i][2]] = sparseArray[i][0];
            }
        }
        int m = 0;
        System.out.println();
        for (int x[]:newArray){
            for (int y:x){
                m++;
                System.out.printf("%d\t",y);
                if (m % newArray[0].length == 0){
                    System.out.println();
                }
            }
        }
    }

}

2.队列

队列遵循的标准是先进先出，后进后出！

第一种是直接使用数组，但是这种方法有弊端，即只能使用一次，不能循环使用

package Queue;

/**
 *    队列：有序列表
 *    遵循先入先出：即先存的先取出，后存的后取出
 *    但是现阶段的数组存在问题，只能用一次就不能再用了
 */
public class queue {
    public static void main(String[] args) {
      queues queues = new queues(5);
      queues.addqueue(3);
      queues.addqueue(4);
      queues.addqueue(2);
      queues.addqueue(11);
      queues.showFirstQueue();
    }
}
//数组模似队列
class queues{
    public int Maxsize;            //队列的最大容量
    public int front = -1;         //指向队列最前列的前一个位置
    public int reas = -1;          //指向队列最后一个位置
    public int arr[];

    public queues(int maxsize){
        Maxsize = maxsize;
        arr = new int[Maxsize];
    }

    public boolean IsEmpty(){      //判断是否为空
        return reas == front;
    }
    public boolean IsFull(){      //判断是否已满
        return reas == Maxsize - 1;
    }
    public void addqueue(int number){     //添加数据
        if (IsFull()){
            System.out.println("队列已经满了，不能添加");
            return;
        }
        reas++;
        arr[reas] = number;
    }
    public void getQueue(){               //取出数据，并且把前指针向后移一个单位
        if (IsEmpty()){
            System.out.println("队列为空，无数据");
            return;
        }
        front++;
        System.out.println(arr[front]);
    }
    public void showQueue(){              //展示所有数据
        if (IsEmpty()){
            System.out.println("队列为空，无数据");
            return;
        }
        for (int x = 0 ; x <= reas;x++) {
            System.out.println(arr[x]);
        }
    }
    public void showFirstQueue(){
        if (IsEmpty()){
            System.out.println("队列为空，无数据");
            return;
        }
        System.out.println(arr[front + 1]);
    }
}

第二种就是使用环形数组，但是这种方法会牺牲一个空间，具体的看代码

package Queue;

import java.util.Scanner;

public class RingQueue {
    public static void main(String[] args) {
        RingQueues ringQueues = new RingQueues(3);
        boolean loop =true;
        //菜单
        while (loop){
            System.out.println("a(add)");
            System.out.println("g(get)");
            System.out.println("s(show)");
            System.out.println("f(first)");
            System.out.println("e(exit)");
            Scanner s = new Scanner(System.in);
            char ls = s.next().charAt(0);
            switch (ls){
                case 'a':
                    System.out.println("请输入插入的数：");
                     int sum =s.nextInt();
                     ringQueues.addqueue(sum);
                     break;
                case 'g':
                     ringQueues.getQueue();
                     break;
                case 's':
                    ringQueues.showQueue();
                    break;
                case 'f':
                    ringQueues.showFirstQueue();
                    break;
                case 'e':
                    loop = false;
                    break;
            }
        }
    }
}
class RingQueues{
    public int Maxsize;            //队列的最大容量
    public int front = 0;         //指向队列最前列的位置
    public int reas = 0;          //指向队列最后一个位置的后一个位置
    public int arr[];

    public RingQueues(int maxsize){
        Maxsize = maxsize;
        arr = new int[Maxsize];
    }
    public boolean IsEmpty(){      //判断是否为空
        return reas == front;
    }
    public boolean IsFull(){      //判断是否已满
        return (reas+ 1) % Maxsize == front;
    }
    public void addqueue(int number){     //添加数据
        if (IsFull()){
            System.out.println("队列已经满了，不能添加");
            return;
        }
        arr[reas] = number;
        reas = (reas + 1) % Maxsize;
    }
    public void getQueue(){               //取出数据，并且把前指针向后移一个单位
        if (IsEmpty()){
            System.out.println("队列为空，无数据");
            return;
        }
        System.out.println(arr[front]);
        front = (front + 1) % Maxsize;
    }
    public void showQueue(){              //展示所有数据
        if (IsEmpty()){
            System.out.println("队列为空，无数据");
            return;
        }
        for (int x = front ; x <= (reas +Maxsize -front) % Maxsize;x++) {
            System.out.println(arr[x]);
        }
    }
    public void showFirstQueue(){
        if (IsEmpty()){
            System.out.println("队列为空，无数据");
            return;
        }
        System.out.println(arr[front]);
    }
}

3.单向链表

Java实现链表，队列，稀疏数组
在这里插入图片描述

package List;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        SingleLinkedList list = new SingleLinkedList();
        list.AddByOrder(new HeroList(1,"李坤","黑旋风"));
        list.AddByOrder(new HeroList(4,"鲁智深","花和尚"));
        list.AddByOrder(new HeroList(2,"吴用","及时雨"));
        list.AddByOrder(new HeroList(3,"毛概","朱芊"));
        list.ShowList();
        list.Updata(new HeroList(3,"龚雷","大朋友"));
        list.ShowList();
        list.Delete(new HeroList(1,"",""));
        list.ShowList();
    }
}
class SingleLinkedList{
    public HeroList head = new HeroList(0,"","");
    //该方法是直接添加到末尾，不是按照序号
    public void AddList(HeroList heroList){
        HeroList demo = head;
        while (true){
            if (demo.next == null){
              demo.next = heroList;
              break;
            }
            demo = demo.next;
        }
    }
    public void Delete(HeroList heroList){
       if (head.next == null){
           System.out.println("链表为空！");
           return;
       }
       boolean flag = false;
       HeroList demo = head;
       while (true){
           if (demo.next == null){
               return;
           }
           else if (heroList.no == demo.next.no){
               flag = true;
               break;
           }
           demo = demo.next;
       }
       if (flag){
          demo.next = demo.next.next;
       }
       else {
           System.out.println("排名未查到");
       }
    }
    public void Updata(HeroList newHerolist){
        if (head.next == null){
            System.out.println("链表为空，不能更新");
            return;
        }
        HeroList demo = head;
        boolean flag = false;
        while (true){
            if (demo.next == null){
                break;
            }
            else if (demo.no == newHerolist.no){
                flag = true;
                break;
            }
            demo = demo.next;
        }
        if (flag){
            demo.name = newHerolist.name;
            demo.Nickname = newHerolist.Nickname;
        }
        else {
            System.out.println("输入的排名未查到！");
        }

    }
    //根据序号来添加
    public void AddByOrder(HeroList heroList){
        HeroList demo = head;
        boolean flag = false;
        while (true){
            if (demo.next == null){
                break;
            }
            else if (demo.next.no == heroList.no){
                flag = true;
                break;
            }
            else if (demo.next.no > heroList.no){
                break;
            }
            demo = demo.next;
        }
        if (flag){
            System.out.println("英雄的排名已经存在，不能加入！");
        }
        else {
            heroList.next = demo.next;
            demo.next = heroList;
        }
    }
    public void ShowList(){

        if (head.next == null){
            System.out.println("链表为空，没有数据");
            return;
        }
        HeroList demo1 = head.next;
        while (true){
            if (demo1 == null){
                break;
            }
            System.out.println(demo1);
            demo1 = demo1.next;
        }
    }
}
class HeroList{
    public int no;
    public String name;
    public  String Nickname;
    public HeroList next;

    public HeroList(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        Nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroList{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", Nickname='" + Nickname + '\'' ;
    }
}

4.双向链表

双向链表和单向链表唯一的差别就是双向链表有两个指针，一个指向前面，一个指向后面,其他和单向链表无巨大差异

package List;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        DoubleLinkedList demo1 = new DoubleLinkedList();
        demo1.AddByOrder(new HeroList1(7,"龚雷","小猪"));
        demo1.AddByOrder(new HeroList1(6,"朱芊","小猪"));
        demo1.AddByOrder(new HeroList1(5,"熊国成","小熊"));
        demo1.AddByOrder(new HeroList1(4,"熊国成","小熊"));
        demo1.AddByOrder(new HeroList1(8,"熊国成","小熊"));
        demo1.ShowList();
    }
}
class DoubleLinkedList{
    public HeroList1 head = new HeroList1(0,"","");

    /**
     * 展示双向链表数据
     */
    public void ShowList(){
        if (head.next == null){
            System.out.println("链表为空，没有数据");
            return;
        }
        HeroList1 demo1 = head.next;
        while (true){
            if (demo1 == null){
                break;
            }
            System.out.println(demo1);
            demo1 = demo1.next;
        }
    }

    /**
     * 直接添加到双向链表末尾
     * @param heroList
     */
    public void AddList(HeroList1 heroList){
        HeroList1 demo = head;
        while (true){
            if (demo.next == null){
                demo.next = heroList;
                break;
            }
            demo = demo.next;
        }
            heroList.pre = demo;
            demo.next = heroList;

    }

    /**
     * 依照序号添加
     * @param heroList
     */
    public void AddByOrder(HeroList1 heroList){
        HeroList1 demo = head;
        boolean flag = false;
        while (true){
            if (demo.next == null){
                break;
            }
            else if (demo.next.no == heroList.no){
                flag = true;
                break;
            }
            else if (demo.next.no > heroList.no){
                break;
            }
            demo = demo.next;
        }
        if (flag){
            System.out.println("英雄的排名已经存在，不能加入！");
        }
        else {
            if (demo == head && head.next == null){
                head.next = heroList;
                heroList.pre = head;
                heroList.next = null;
                return;
            }
            if (demo == head && head.next != null){
                heroList.next = demo.next;
                demo.next.pre = heroList;
                head.next = heroList;
                heroList.pre = head;
                return;
            }
             else if (demo.next == null && head.next != null){
                demo.next = heroList;
                heroList.pre = demo;
                heroList.next = null;
                return;
            }
             demo.next = heroList;
             heroList.pre = demo;
             heroList.next = demo.next;
             demo.next.pre = heroList;
        }
    }

    /**
     * 修改双向链表的值
     * @param newHerolist
     */
    public void Updata(HeroList1 newHerolist){
        if (head.next == null){
            System.out.println("链表为空，不能更新");
            return;
        }
        HeroList1 demo = head;
        boolean flag = false;
        while (true){
            if (demo.next == null){
                break;
            }
            else if (demo.no == newHerolist.no){
                flag = true;
                break;
            }
            demo = demo.next;
        }
        if (flag){
            demo.name = newHerolist.name;
            demo.Nickname = newHerolist.Nickname;
        }
        else {
            System.out.println("输入的排名未查到！");
        }

    }

    /**
     * 删除节点
     * @param heroList
     */
    public void Delete(HeroList1 heroList){
        if (head.next == null){
            System.out.println("链表为空！");
            return;
        }
        boolean flag = false;
        HeroList1 demo = head.next;
        while (true){
            if (demo == null){
                return;
            }
            else if (heroList.no == demo.no){
                flag = true;
                break;
            }
            demo = demo.next;
        }
        if (flag) {
            demo.pre.next = demo.next;
            if (demo.next != null) {    //如果demo为最后一个，会有空指针异常
                demo.next.pre = demo.pre;
            }
        }
        else {
            System.out.println("排名未查到");
        }
    }
}
class HeroList1{
    public int no;
    public String name;
    public  String Nickname;
    public HeroList1 next;
    public HeroList1 pre;

    public HeroList1() {
    }

    public HeroList1(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        Nickname = nickname;
    }

    @Override
    public String toString() {
        return "HeroList1{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", Nickname='" + Nickname + '\'' ;
    }
}

以上知识是自学尚硅谷java数据结构，同时给尚硅谷一个好评！同志们，一起加油！

一只小猪~~~
关注
数据结构（一）线性链表、非线性链表、稀疏数组与队列、单向链表
codinglover5的博客
08-07 3301
数据结构和算法的关系 ➢数据data结 构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了 数据结构.学好数据结构可以编写出更加漂亮更加有效率的代码。 ➢要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决. ➢程序=数据结构+算法 ➢数据结构是算法的基础，换言之，想要学好算法，需要把数据结构学到位。 线性链表和非线性链表 数据结构包括:线性结构和非线性结构。 线性结构 1)线性结构作为最常用的数据结构，其特点是数据元素之间存在- -对- - 的线性关系（a[0]=3
稀疏数组和队列（顺序队列和循环队列）
笔记别偷看
10-05 458
稀疏 sparsearray 数组 基本介绍 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个不同的值 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 为什么要使用稀疏数组？ 稀疏数组可以简单的看作为是压缩，在开发中也会使用到。比如将数据序列化到磁盘上，减少数据量，在IO过程中提高效率等等。 由于稀疏矩阵中存在大量的“空”值，占据了大量的存储空间，而真正有用的数据却少之又少， 且在计算
链表：：稀疏数组
beimuaihui的专栏
02-21 683
http://www.w3.org/TR/html4/strict.dtd">                    Untitled Document                    使用循环链表结构表示稀疏数组                如下所示为一稀疏数组，用循环链表结构表示。由于数组可以直接从行跟列检索，        所以节点需要两个next节点，分别指向行(right)跟列(
稀疏数组的链式存储实现（使用单向链表）
qq_43465706的博客
09-12 381
稀疏数组的链式存储实现（使用单向链表） (1)链表类 public class LinkedList { public int row;//链表存储的，稀疏数组中的有效数据所在的行 public int column;//链表存储的，稀疏数组中的有效数据所在的列 public int data;//链表存储的，稀疏数组中的有效数据 public LinkedList next; public LinkedList() { } public Link
数据结构之稀疏数组 链表---Java版本
xiaososa的博客
12-21 229
数据结构 一、线性结构和非线性结构 1、线性结构 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表为顺序表，顺序表中的存储元素是连续的 链式存储的线性表为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息 线性结构常见的有：数组、队列、链表和栈，后面我们会详细讲解 2、非线性结构 非线性结构包括：二维数组，多维数组，广义表，树结构，图结构 1.稀疏数组sparsearray
Java | 稀疏数组
Oh_MyBug的博客
03-16 154
文章目录数据结构稀疏数组二维数组与稀疏数组之间的转换将稀疏数组保存到磁盘上恢复原来的数组，读取sparseArr.dat进行恢复 数据结构 /* * 数据结构包括：线性结构和非线性结构 * 1. 线性结构： * 1.1 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 * 1.2 线性结构有两种不同的存储结构，即顺序存储结构（数组）和链式存储结构...
Java实现环形队列
qq_46249770的博客
11-22 372
使用Java语言设计一个环形队列 package Queue; import java.io.*; public class RingQueue { public static int front=-1,rear=-1,val; public static int queue[]=new int[5]; public static void main(String args[]) throws IOException{ String strM; BufferedReader keyin=new
【Java数据结构与算法】稀疏数组
01-20
文章目录数据结构类型线性结构与非线性结构稀疏数组实例应用二维数组转稀疏数组的思路稀疏数组转原始的二维数组思路 数据结构类型 数据结构包括：线性结构和非线性结构。 线性结构与非线性结构 线性结构 线性结构...
数据结构：稀疏数组与队列
weixin_44507435的博客
06-12 431
文章目录稀疏数组环形队列（数组实现） 稀疏数组 当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法： 记录数组一共有几行几列，又多少个不同的值； 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模； 二维数组转稀疏数组思路： 遍历二维数组，找出有效数据个数sum； 根据有效数据个数，确定稀疏数组规模sparseArray[sum+1][3]； 将二维数组数据传入稀疏数组； 稀疏数组转原始二维数组思路： 读取稀疏数组第一行，
新星计划Day4【数据结构与算法】 稀疏数组与队列
qq_46272491的博客
04-28 2062
新星计划Day4【数据结构与算法】 稀疏数组与队列 👩‍💻博客主页：京与旧铺的博客主页 ✨欢迎关注🖱点赞🎀收藏⭐留言✒ 🔮本文由京与旧铺原创，csdn首发！ 😘系列专栏：java学习 💻首发时间：🎞2022年4月28日🎠 🎨你做三四月的事，八九月就会有答案，一起加油吧 🀄如果觉得博主的文章还不错的话，请三连支持一下博主哦 🎧最后的话，作者是一个新人，在很多方面还做的不好，欢迎大佬指正，一起学习哦，冲冲冲 🛒导航小助手🎪 文章目录新星计划Day4【数据结构与算法】 稀疏数组与队列在这里插入图片描述🛒导
java模拟环形队列
qq_45624357的博客
08-21 115
/** * 使用数组模拟环形队列 * 思路：队列的头部front指向队列的第一个位置，默认值为0 * 队列的尾部指向了队列的最后一个位置+1（也就是数组的位置）。默认值为0，将数组的一个位置预留出来 */ public class RingQueue { //数组的大小，也就是队列大小-1，减了一个预留位置，比如maxSize为4，表示数组的大小为4，但是队列的大小为3，因为预留了一个位置 private int maxSize; private int front; .
java的数据结构（一） 稀疏矩阵
zhengchaowei5286860的博客
07-19 218
package com.atguigu.sparse; public class SparseArray { public static void main(String[] args){ int chessArr1[][] = new int[11][11]; //表示11行11列 自动初始化，赋值为00 chessArr1[1][2] = 1; chessArr1[2][3] = 2; ...
无锁环形缓冲RingBuffer的原理及Java实现
热门推荐
Jkq的专栏
08-29 2万+
在多线程环境下为了保证线程安全，往往需要加锁，例如读写锁可以保证读写互斥，读读不互斥。有没有一种数据结构能够实现无锁的线程安全呢？答案就是使用RingBuffer循环队列。在Disruptor项目中就运用到了RingBuffer。 RingBuffer的基本原理如下： 在RingBuffer中设置了两个指针，head和tail。head指向下一次读的位置，tail指向的是下一次写的位置。R...
Java 集合深入理解（9）：Queue 队列
weixin_33972649的博客
10-19 1533
点击查看 Java 集合框架深入理解 系列， - ( ゜- ゜)つロ 乾杯~ 今天心情不太好，来学一下 List 吧！ 什么是队列 队列是数据结构中比较重要的一种类型，它支持 FIFO，尾部添加、头部删除（先进队列的元素先出队列），跟我们生活中的排队类似。 队列有两种： 单队列 循环队列 单队列就是常见的队列, 每次添加元素时，都是添...
浅谈高性能无锁并发框架Disruptor
weixin_50205273的博客
09-09 498
Disruptor是一个开源框架，研发的初衷是为了解决高并发下队列锁的问题，最早由LMAX提出并使用，能够在无锁的情况下实现队列的并发操作，并号称能够在一个线程里每秒处理6百万笔订单 目前，包括Apache Storm、Camel、Log4j2在内的很多知名项目都应用了Disruptor以获取高性能 为什么会产生Disruptor框架 「目前Java内置队列保证线程安全的方式：」 ArrayBlockingQueue：基于数组形式的队列，通过加锁的方式，来保证多线程情况下数据的安全； Linked
Java数组实现循环队列的两种方法
西楚小羽的专栏
06-23 6365
用java实现循环队列的方法： 1、增加一个属性size用来记录目前的元素个数。目的是当head=rear的时候，通过size=0还是size=数组长度，来区分队列为空，或者队列已满。 2、数组中只存储数组大小-1个元素，保证rear转一圈之后不会和head相等，也就是队列满的时候，rear+1=head，中间刚好空一个元素。       当rear=head的时候，一定是队列空了。 队列
环形缓冲区(ring buffer)，环形队列(ring queue) 原理
code09的专栏
02-28 2万+
1. 序言 环形缓冲区(ring buffer)，环形队列(ring queue) 多用于2个线程之间传递数据，是标准的先入先出(FIFO)模型。 一般来说，对于多线程共享数据，需要使用mutex来同步，这样共享数据才不至于发生不可预测的修改/读取，然而， mutex的使用也带来了额外的系统开销，ring buffer/queue 的引入，就是为了有效地解决这个问题，因其特殊的结构 及算法
无锁环形队列的一种高效实现
weixin_30875157的博客
03-26 1174
1.环形队列是什么 队列是一种常用的数据结构，这种结构保证了数据是按照“先进先出”的原则进行操作的，即最先进去的元素也是最先出来的元素.环形队列是一种特殊的队列结构，保证了元素也是先进先出的，但与一般队列的区别是，他们是环形的，即队列头部的上个元素是队列尾部，通常是容纳元素数固定的一个闭环。 C代码实现见:https://github.com/dodng/fast_ring_queue ...
Java数据结构基础与稀疏数组应用
学习Java数据结构意味着掌握数据组织的关键原理，如线性与非线性结构的区别及其应用，以及如何灵活运用稀疏数组等高效数据结构来优化特定场景下的算法实现。这不仅有助于提升编程效率，也为理解和设计复杂的算法提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一只小猪~~~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值