第二篇 链表

最新推荐文章于 2024-10-26 11:45:02 发布
最新推荐文章于 2024-10-26 11:45:02 发布
阅读量321 收藏
点赞数
分类专栏： Java-数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43710486/article/details/118882233
版权
本文介绍了单链表和双向链表的数据结构，包括节点定义、链表建立、增删改查操作。通过实例展示了如何按编号顺序插入节点、删除指定节点、修改节点信息以及查找倒数第K个节点。此外，还讨论了单链表的逆置方法，如栈实现和头插法，并展示了两个有序单链表的合并。最后，探讨了约瑟夫问题的循环链表实现。
摘要由CSDN通过智能技术生成

链表

单链表

定义节点

class HeroNode {
	public int no;
	public String name;
	public String nickname;
	public HeroNode next;
	public HeroNode(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}
	@Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname +
                '}';
    }
}

建立单链表

class SingleLinkedList {
	//头节点
	private HeroNode head = new HeroNode(0, "", "");
	public HeroNode getHead() {
		return head;
	}
	public void setHead(HeroNode head) {
		this.head = head.next;
	}
	//添加节点
	public void add(HeroNode heroNode) {
		HeroNode temp = head;
		while (true) {
			if (temp.next == null) {
				break;
			}
			temp = temp.next;
		}
		temp.next = heroNode;
	}
	//按编号顺序添加节点
	public void addByOrder(HeroNode heroNode) {
		HeroNode temp = head;
		boolean flag = false;
		while (true) {
			if (temp.next == null) {
				break;
			}
			if (temp.next.no > heroNode.no) {
				break;
			} else if (temp.next.no == heroNode.no) {	
				flag = true;
				break;			
			}
			temp = temp.next;
		}
		if (flag) {
			System.out.println("编号已存在 不能插入");
		} else {
			heroNode,next = temp.next;
			temp.next = heroNode;	
		}
	}
	//更新节点
	public void update(HeroNode newHeroNode) {
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode temp = head.next;
		boolean flag = false;
		while (true) {
			if (temp == null) {
				break;
			}
			if (temp.no == newHeroNode.no) {
				flag = true;
				break;	
			}
			temp = temp.next;
		}
		if (flag) {
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		} else {
			System.out.println("没找到 不能修改");
		}
	}
	//打印链表
	public void list() {
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode temp = head.next;
		while (true) {
			if (temp == null) {
				break;
			}
			System.out.println(temp);
			temp = temp.next;
		}
	}
	public void del(int no) {
		HeroNode temp = head;
		boolean flag = false;
		while (true) {
			if (temp.next == null) {
				break;
			}
			if (temp.next.no == no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if (flag) {
			temp.next = temp.next.next;
		} else {
			System.out.println("要删除的节点不存在");
		}
	}
}

测试代码 建立单链表(按照节点输入顺序)

public class SingleLinkedListDemo {
	public static void main(String[] args) {
		HeroNode hero1 = new HeroNode(1, "aaa", "aaa1");
		HeroNode hero2 = new HeroNode(3, "bbb", "bbb1");
		HeroNode hero3 = new HeroNode(5, "ccc", "ccc1");
		HeroNode hero4 = new HeroNode(7, "ddd", "ddd1");
	}
	SingleLinkedList singleLinkedList1 = new SingleLinkedList();
	singleLinkedList1.add(hero1);
	singleLinkedList1.add(hero2);
	singleLinkedList1.add(hero3);
	singleLinkedList1.add(hero4);
	singleLinkedList1.list();
	
}

在这里插入图片描述

测试代码 建立单链表(按照节点编号顺序)

		HeroNode hero1 = new HeroNode(1, "aaa", "aaa1");
        HeroNode hero2 = new HeroNode(7, "bbb", "bbb1");
        HeroNode hero3 = new HeroNode(5, "ccc", "ccc1");
        HeroNode hero4 = new HeroNode(3, "ddd", "ddd1");
        SingleLinkedList singleLinkedList1 = new SingleLinkedList();

        singleLinkedList1.addByOrder(hero1);
        singleLinkedList1.addByOrder(hero2);
        singleLinkedList1.addByOrder(hero3);
        singleLinkedList1.addByOrder(hero4);
        singleLinkedList1.list();

在这里插入图片描述

删除节点

		System.out.println("删除3号节点:");
        singleLinkedList1.del(3);
        singleLinkedList1.list();

在这里插入图片描述

修改节点

		System.out.println("修改5号节点");
        HeroNode newHeroNode = new HeroNode(5, "eee", "eee1");
        singleLinkedList1.update(newHeroNode);
        singleLinkedList1.list();

在这里插入图片描述

获取链表长度

public static int getLength(HeroNode head) {
	if (head.next == null) {
		return 0;
	}
	int length = 0;
	HeroNode cur = head.next;
	while (cur != null) {
		length++;
		cur = cur.next;
	}
	return length;
}

测试代码：

System.out.println("链表长度为： " + getLength(singleLinkedList1.getHead()));

在这里插入图片描述

查找倒数第K个节点

public static HeroNode findLastIndexNode(HeroNode head, int index) {
	if (head.next == null) {
		return null;
	}
	int size = getLength(head);
	if (index <= 0 || index > size) {
		return null;
	}
	HeroNode cur = head.next;
	for (int i = 0; i < size - index; i++) {
		cur = cur.next;
	}
	return cur;
}

测试代码：

		System.out.println("查看倒数第1个节点");
        HeroNode res = findLastIndexNode(singleLinkedList1.getHead(), 1);
        System.out.println(res);

在这里插入图片描述

单链表逆置

利用栈实现链表逆置

public static void reversePrint(HeroNode head) {
	if (head.next == null) {
		return;
	}
	Stack<HeroNode> stack = new Stack<~>();
	HeroNode cur = head.next;
	while (cur != null) {
		stack.push(cur);
		cur = cur.next;
	}
	while (stack.size() > 0) {
		System.out.println(stack.pop());
	}
}

测试代码：

		singleLinkedList1.list();
        System.out.println("逆置后：");
        reversePrint(singleLinkedList1.getHead());

在这里插入图片描述

头插法实现链表逆置

public static void reverseList(HeroNode head) {
	if (head.next == null || head.next.next == null) {
		return;
	}
	HeroNode cur = head.next;
	HeroNode next = null;
	HeroNode reverseHead = new HeroNode(0, "", "");
	while (cur != null) {
		next = cur.next;
		cur.next = reverseHead.next;
		reverseHead.next = cur;
		cur = next;
	}
	head.next = reverseHead.next;
}

测试代码：

		System.out.println("逆置后：");
        reverseList(singleLinkedList1.getHead());
        singleLinkedList1.list();

在这里插入图片描述

单链表合并（两个有序单链表 合并之后依然有序）

public static HeroNode SingleLinkedListMerge(HeroNode list1, HeroNode list2) {
	HeroNode temp = new HeroNode(0, "", "");
	HeroNode head = temp;
	while (list1 != null && list2 != null) {
		if (list1.no < list2.no) {
			temp.next = list1;
			list1 = list1.next;
		} else {
			temp.next = list2;
			list2 = list2.next;
		}
		temp = temp.next;
	}
	if (list1 == null) {
		temp.next = list2;
	}
	if (list2 == null) {
		temp.next = list1;
	}
	return head.next;
}

测试代码：

HeroNode hero1 = new HeroNode(1, "aaa", "aaa1");
        HeroNode hero2 = new HeroNode(3, "bbb", "bbb1");
        HeroNode hero3 = new HeroNode(5, "ccc", "ccc1");
        HeroNode hero4 = new HeroNode(7, "ddd", "ddd1");
        HeroNode hero5 = new HeroNode(2, "aaa", "aaa2");
        HeroNode hero6 = new HeroNode(4, "bbb", "bbb2");
        HeroNode hero7 = new HeroNode(6, "ccc", "ccc2");
        HeroNode hero8 = new HeroNode(8, "ddd", "ddd2");

        SingleLinkedList singleLinkedList1 = new SingleLinkedList();

        singleLinkedList1.add(hero1);
        singleLinkedList1.add(hero2);
        singleLinkedList1.add(hero3);
        singleLinkedList1.add(hero4);
        System.out.println("单链表：");
        singleLinkedList1.list();

        SingleLinkedList singleLinkedList2 = new SingleLinkedList();

        singleLinkedList2.add(hero5);
        singleLinkedList2.add(hero6);
        singleLinkedList2.add(hero7);
        singleLinkedList2.add(hero8);
        System.out.println("单链表：");
        singleLinkedList2.list();

        System.out.println("合并后：");
        SingleLinkedList singleLinkedList3 = new SingleLinkedList();
        HeroNode newHead = SingleLinkedListMerge(singleLinkedList1.getHead(), singleLinkedList2.getHead());
        singleLinkedList3.setHead(newHead);
        singleLinkedList3.list();

在这里插入图片描述

双链表

定义节点

class HeroNode2 {
	public int no;
	public String name;
	public String nickname;
	public HeroNode2 next;
	public HeroNode2 pre;
	public HeroNode2(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}
	 @Override
    public String toString() {
        return "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

建立双向链表

class DoubleLinkedList {
	private HeroNode2 head = new HeroNode2(0, "", "");
	public HeroNode2 getHead() {
		return head;
	}
	public void list() {
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode2 temp = head.next;
		while (true) {
			if (temp == null) {
				break;
			}
			System.out.println(temp);
			temp = temp.next;
		}
	}
	public void addByOrder(HeroNode2 heroNode) {
		HeroNode2 temp = head;
		boolean flag = false;
		while (true) {
			if (temp.next == null) {
				break;
			}
			if (temp.next.no > heroNode.no) {
				break;
			} else if (temp.next.no == heroNode.no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if (flag) {
			System.out.println("编号已存在 不能插入");
		} else {
			if (temp.next == null) {
				temp.next = heroNode;
				heroNode.pre = temp;
			} else {
				heroNode,next = temp.next;
				temp.next.pre = heroNode;
				heroNode.pre = temp;
				temp.next = heroNode;
			}
		}
	}
	//添加一个节点到双向链表的最后
	public void add(HeroNode2 heroNode) {
		HeroNode2 temp = head;
		while(true) {
			if (temp.next == null) {
				break;
			}
			temp = temp.next;
		}
		temp.next = heroNode;
		heroNode.pre = temp;
	}
	public void update(HeroNode2 newHeroNode) {
		if (head.next == null) {
			System.out.println("链表为空");
			return;	
		}
		HeroNode2 temp = head.next;
		boolean flag = false;
		while (true) {
			if (temp == null) {
				break;
			}
			if (temp.no == newHeroNode.no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if (flag) {
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		} else {
			System.out.println("没找到");
		}
	}
	public void del(int no) {
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode2 temp = head.next;
		boolean flag = false;
		while (true) {
			if (temp == null) {
				break;
			}
			if (temp.no == no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if (flag) {
			temp.pre.next = temp.next;
			if (temp.next != null) {
				temp.next.pre = temp.pre;
			}
		} else {
			System.out.println("要删除的节点不存在");
		}
	}
}

测试

建立双向链表(按节点加入顺序)
public class DoubleLinkedListDemo {
	public static void main(String[] args) {
		HeroNode2 hero1 = new HeroNode2(1, "a", "a1");
		HeroNode2 hero2 = new HeroNode2(4, "b", "b1");
        HeroNode2 hero3 = new HeroNode2(3, "c", "c1");
        HeroNode2 hero4 = new HeroNode2(5, "e", "e1");
        HeroNode2 hero5 = new HeroNode2(2, "d", "d1");
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);
        doubleLinkedList.add(hero5);
        doubleLinkedList.list();
	}
}

在这里插入图片描述

建立双向链表(按节点编号顺序)
		HeroNode2 hero1 = new HeroNode2(1, "a", "a1");
        HeroNode2 hero2 = new HeroNode2(4, "b", "b1");
        HeroNode2 hero3 = new HeroNode2(3, "c", "c1");
        HeroNode2 hero4 = new HeroNode2(5, "e", "e1");
        HeroNode2 hero5 = new HeroNode2(2, "d", "d1");


        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.addByOrder(hero2);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero4);
        doubleLinkedList.addByOrder(hero5);
        doubleLinkedList.list();

在这里插入图片描述

修改节点
		HeroNode2 newHeroNode = new HeroNode2(4, "e", "e1");
        doubleLinkedList.update(newHeroNode);
        System.out.println("修改后");
        doubleLinkedList.list();

在这里插入图片描述

删除节点
		doubleLinkedList.del(3);
        System.out.println("删除后:");
        doubleLinkedList.list();

在这里插入图片描述

约瑟夫问题(循环链表)

场景

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码实现

定义节点

class Boy {
	private int no;
	private Boy next;
	public Boy(int no) {
		this.no = no;
	}
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public Boy getNext() {
		return next;
	}
	public void setNext(Boy next) {
		this.next = next;
	}
}

循环链表

class CircleSingleLinkedList {
	private Boy first = null;
	public void addBoy(int nums) {
		if (nums < 1) {
			System.out.println("nums的值不正确");
			return;
		}
		Boy curBoy = null;
		for (int i = 1; i <= nums; i++) {
		Boy boy = new Boy(i);
		if (i == 1) {
			first = boy;
			first.setNext(first);
			curBoy = first;
		} else {
			curBoy.setNext(boy);
			boy.setNext(first);
			curBoy = boy;
		}
	}
	}
	public void showBoy() {
		if (first == null) {
			System.out.println("没有任何小孩");
			return;
		}
		Boy curBoy = first;
		while (true) {
			System.out.printf("小孩的编号 %d\n", curBoy.getNo());
			if (curBoy.getNext() == first) {
				break;
			}
		curBoy = curBoy.getNext();
		}
	}
	public void countBoy(int startNo, int countNum, int nums) {
		if (first == null || startNo < 1 || startNo > nums) {
			System.out.println("参数有误");
			return;
	}
	Boy helper = first;
	while (true) {
		if (helper.getNext() == first) {
				break;
		}
		helper = helper.getNext();
	}
	for (int j = 0; j < startNo - 1; j++) {
		first = first.getNext();
		helper = helper.getNext();
	}
	while (true) {
		if (helper == first) {
			break;
		}
		for (int j = 0; j < countNum - 1; j++) {
			first = first.getNext();
			helper = helper.getNext();
		}
		System.out.printf("小孩%d出圈\n", first.getNo());
		first = first.getNext();
		helper.setNext(first);
	}
		System.out.printf("最后留在圈中的小孩编号%d\n", first.getNo());
	}
}

测试

public class Josefu {
	public static void main(String[] args) {
		CircleSingLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
		circleSingleLinkedList.addBoy(5);
		circleSingleLinkedList.showBoy();
		circleSingleLinkedList.countBoy(1, 2, 5);
	}
}

在这里插入图片描述

java复习篇 数据结构：链表第二节 哨兵
Jc_Stu的博客
01-23 1010
链表头插、尾插等，一文掌握
链表第二篇
buhuisuanfa的博客
09-28 3281
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
二、链表篇
qq_45721233的博客
10-25 706
详细介绍了链表的多种操作，包括节点表示、移除链表元素、设计链表、翻转链表、两两交换链表中的节点、删除链表的倒数第N个节点、链表相交以及环形链表II的检测。文章通过Java代码示例，展示了如何实现这些操作，并提供了递归和迭代两种方法。特别地，文章强调了虚拟头结点方法在简化头结点处理中的优势。
算法通关村第二篇——反转链表
weixin_75149154的博客
07-20 1171
我的理解是 struct ListNode* prev = NULL等于新开了一个空链表 然后改变指针方向。注意：需要新建一个next结点用来储存cur->next 然后在一轮遍历后 通过cur=next重新遍历。构造虚拟节点的方法是创造一个ans 然后让原有的链表接入上去的一种做法。} 为什么struct ListNode* prev = NULL;总结思路：反转链表有两种思路 一种是构造虚拟结点，一种则是直接反转。
链表相关面试题第一篇
森明帮大于黑虎帮的博客
05-11 1006
系列文章目录 文章目录系列文章目录前言一、移除链表元素1.题目描述2.解题思路二、反转单链表1.题目描述2.解题思路三、链表的中间节点1.题目描述2.解题思路四、链表的倒数第k个节点1.题目描述2.解题思路总结 前言 一、移除链表元素 移除链表元素 1.题目描述 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 2.解题思路 解题方法1： 判断头节点是否为空 定义两指针，一指针prev=NULL，.
链表相关面试题第二篇
森明帮大于黑虎帮的博客
05-14 946
系列文章目录 文章目录系列文章目录前言一、合并有序链表1.题目描述2.解题思路二、链表分割1.题目描述2.解题思路三、链表回文结构1.题目描述2.解题思路四、链表公共节点1.题目描述2.解题思路总结 前言 一、合并有序链表 合并两个有序链表 1.题目描述 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 2.解题思路 取两个链表中值小的一个当为头节点 然后一直取两个链表中小的节点尾插到头节点后面 注意判断结束条件 代码如下： /** .
代码随想录二刷链表篇
weixin_62360776的博客
10-28 376
代码随想录二刷链表篇
代码随想录之链表篇
shepi_666的博客
10-26 1029
代码随想录之链表篇：总结了常见的链表算法，例如移除指定的节点、反转链表、判断相交节点、判断链表是否有环等等。
【算法刷题】第二篇——链表（一）
赵四司机的博客
09-20 3898
主要介绍链表部分的常见算法题
链表相关面试题第三篇
森明帮大于黑虎帮的博客
05-16 877
系列文章目录 文章目录系列文章目录前言一、环形链表1.题目描述2.解题思路二、环形链表进阶1.题目描述2.解题思路三、复杂带随机指针的链表1.题目描述2.解题思路四、对链表进行插入排序1.题目描述2.解题思路五、删除链表中重复节点，重复节点不保留1.题目描述2.解题思路总结 前言 一、环形链表 环形链表 1.题目描述 给定一个链表，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连.
算法之链表篇---相交链表
qq_44392499的博客
03-14 397
链接：https://leetcode.cn/problems/intersection-of-two-linked-lists/description/?其实看到这题我最先想到的做法，就是在链表中维护一个计数器，然后遍历两个链表，当便利到某个节点计数器 + 1 等于2时，就进行返回；两链表相交，节点从是否相交来分类，其实就是两种一种是有共同节点，一种是没有共同节点；指针B遍历完链表2后遍历链表1，两指针最后结果都为null。设链表1长度为a，链表2长度为b，链表相交长度为c。时间复杂度 ：O(n)
C语言实现输出链表中倒数第k个节点
09-04
本篇将详细讲解如何实现输出链表中倒数第k个节点的C语言程序。 首先，我们需要定义链表节点的结构体。在示例代码中，`Node` 结构体包含两个成员：`item` 存储数据元素，`next` 是指向下一个节点的指针。结构体初始...
Java算法篇-链表去重与合并.pptx.pptx
12-18
2. 对于每个输入的有序链表，找到最小的元素并将其插入新链表，然后移除该元素。 3. 重复步骤2，直到所有链表都被遍历完。 4. 返回合并后的新链表。 这个过程的关键在于如何高效地找到每个链表的最小元素。可以使用...
(源码)基于QT框架的云存储系统.zip
11-13
# 基于QT框架的云存储系统 ## 项目简介 本项目是一个基于QT框架开发的云存储系统，旨在为用户提供一个安全、高效的文件存储和分享平台。系统采用CS架构，客户端通过QT框架搭建，服务端运行在Centos 7环境下。用户可以通过系统进行文件的上传、下载、分享，以及与好友的私聊和文件分享。 ## 项目的主要特性和功能 好友管理支持添加、删除好友，私聊好友，以及分享文件给好友。 文件管理提供文件夹的创建、删除、移动、重命名操作，支持文件的上传、下载、移动和分享。 用户界面使用QT框架搭建用户界面，提供友好的交互体验。 网络通信通过自定义的交互协议实现客户端与服务器的高效数据交互。 并发处理服务器端采用多路复用、内存池、线程池等技术，确保在并发环境下的稳定运行。 ## 安装使用步骤 1. 下载源码从项目仓库下载源码文件。 2. 配置开发环境 服务端安装Centos 7，并配置vim、G++、gdb等开发工具。
2010-2023国自科立项名单管理学部.xlsx
最新发布
11-13
1、资源内容地址：https://blog.csdn.net/2301_79696294/article/details/143636809 2、数据特点：今年全新，手工精心整理，放心引用，数据来自权威，且标注《数据来源》，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 3、适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 3、课程引用: 经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理
二、现有一份上市企业年度财务报告文本中管理层讨论与分析文本大数据，请测度以下相关的数据(60分)
11-13
二、现有一份上市企业年度财务报告文本中管理层讨论与分析文本大数据，请测度以下相关的数据(60分)
多个SVCTTS的C推理库.zip
11-13
c语言
1991-2022年国家社科基金项目数据公布.xlsx
11-13
1、资源内容地址：https://blog.csdn.net/2301_79696294/article/details/143636809 2、数据特点：今年全新，手工精心整理，放心引用，数据来自权威，且标注《数据来源》，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 3、适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 3、课程引用: 经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理
B.5-本科毕业生就业满意度分析.pdf
11-13
B.5-本科毕业生就业满意度分析.pdf
用c语言写一篇奇偶链表
11-16
// 定义偶数链表头指针，初始指向第二个节点 while (even != NULL && even->next != NULL) { // 遍历链表，将奇数节点和偶数节点分别连接起来 odd->next = even->next; // 奇数节点的next指针指向下一个奇数节点 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值