数据结构：链表

最新推荐文章于 2023-03-16 00:43:00 发布
最新推荐文章于 2023-03-16 00:43:00 发布
阅读量173 收藏
点赞数 1
分类专栏： JAVA基础 数据结构 文章标签： java 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peterbearXY/article/details/113866418
版权

介绍

JAVA中有许多的数据结构,例如数组，队列，栈，链表等。与其他数据结构相比，链表具有增删快，充分利用碎片化空间的特点。链表是引用类型数据，它就像一个表格，包含众多节点（内部的数据通过一个个指针链所相连接）。就像下面这张图
在这里插入图片描述链表都是由一个个节点构成，每个节点中包含数据与指针，指针为节点指明方向，即下一个数据或上一个数据。

分类

链表也可以分类

  • 单向链表
  • 双向链表
  • 单向循环链表

单向链表是指链表中每个节点都只能指向下一个节点，不能指向上一个。（上面那张示意图就是单向链表）

双向链表是指链表中每个节点都可以指向上一个节点，同时也可以指向下一个节点，示意图如下
在这里插入图片描述
单向循环链表：一个单向链表的最后一个节点的next指针，指向开头的节点。（示意图如下）

实现链表

对于链表，我们要实现增删改查的功能。
增添数据、删除数据、修改数据、查找数据

单向链表
package DataStructure;

import java.util.Stack;

/**
 * @author 23881
 * 链表的增删改查
 * 合并链表
 * 逆序打印
 *反转链表
 *打印倒是第n个元素
 */
public class SingleLinkedListDemo {

	public static void main(String[] args) {
		SingleLinkedList list = new SingleLinkedList();
//		list.add(new HeroNode(1,"peter","peterbear"));
//		list.add(new HeroNode(3,"tony","hairCutter"));
		System.out.println("\t增添元素");
		list.AddByOrder(new HeroNode(1,"peter","peterbear"));
		list.AddByOrder(new HeroNode(3,"tony","hairCutter"));
		list.AddByOrder(new HeroNode(2,"jerry","printf"));
		list.AddByOrder(new HeroNode(5,"jim","java"));
		list.AddByOrder(new HeroNode(6,"trump","python"));
		list.AddByOrder(new HeroNode(2,"jerry","printf"));
		list.print();
		System.out.println("\t查找元素");
		list.Search(0);
		System.out.println("\t更改元素");
		list.Update(new HeroNode(2,"zhang","专业户"));
		list.print();
		System.out.println("\t删除元素");
		list.Delete(2);
		list.print();
		System.out.println("\t此链表中节点的个数："+list.size());
		System.out.println("\t倒数第n个元素\n"+list.NodeFromLast(3));
		System.out.println("\t反转后的链表");
		list.ReserveNode();
		list.print();
		System.out.println("\t逆序打印");
		list.RevPrint();
		list.ReserveNode();
		System.out.println("\t合并链表");
		System.out.println("链表1：");
		list.print();
		System.out.println("链表2：");
		SingleLinkedList list2 = new SingleLinkedList();
		list2.AddByOrder(new HeroNode(5,"Biden","瞌睡虫"));
		list2.AddByOrder(new HeroNode(8,"John","somebody"));
		list2.print();
		System.out.println("合并后：");
		list.Combine(list2);
		list.print();
		
	}
	
	
}
 
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 "Node[ No: "+this.No+"; Name: "+this.Name+"; NickName: "+this.NickName+" ]";
	}
	@Override
	public boolean equals(Object obj) {
		HeroNode node = (HeroNode)obj;
		return node.No == this.No && node.Name.equals(node.Name) && node.NickName.equals(node.NickName);
	}
	
	
}


class SingleLinkedList{
	//先初始化一个头节点
	public HeroNode Head = new HeroNode(0,"","");
	
	//添加节点
	//找到当前列表的最后一个节点，将最后一个节点的next指向下一个
	public void add(HeroNode node) {
		//head节点不能动，用一个指针指向head
		HeroNode cur = Head;
		//遍历链表
		while(cur.next != null) {
			cur = cur.next;
		}
		cur.next = node;
	}
	
	//按照heronode的编号来存储数据，判断数据是否存在与存储数据
	public void AddByOrder(HeroNode node) {
		HeroNode cur = Head;
		if(isempty()) {
			add(node);
			return;
		}
		while(cur.next != null) {
			if(cur.next.No > node.No) {
				node.next = cur.next;
				cur.next = node;
				break;
			}
			else if(cur.next.No == node.No ) {
				System.out.printf("%s的编号%d 已存在，无法添加\n",node.Name,node.No);
				break;
			}
			cur = cur.next;
			if(cur.next == null) {
				add(node);
				break;
			}
		}
		
	}
	
	//对链表中数据进行反转 
	public void ReserveNode() {
		HeroNode cur = Head.next;

		HeroNode temp = new HeroNode(0,"","");
		while(cur!=null) {
			Head.next = cur.next;
			cur.next = temp.next;
			temp.next = cur;
			cur = Head.next;
		}
		Head = temp;
		//第二种
//		HeroNode next =null;
//		while(cur!=null) {
//			next = cur.next;
//			cur.next = temp.next;
//			temp.next = cur;
//			cur = next;
//		}
//		Head = temp;
	}
	
	//删除信息
	public void Delete(int No) {
		if(isempty()) {
			System.out.println("此链表为空链表，无法删除任何元素");
			return;
		}
		if(No == 0) {
			System.out.println("无法删除头节点");
			return;
		}
		HeroNode cur = Head;
		while(cur.next != null) {
			if(cur.next.No == No) {
				cur.next = cur.next.next;
				return;
			}
			cur = cur.next;
		}
		System.out.println("未找到匹配的信息");
	}
	
	
	//改变信息
	public void Update(HeroNode NewNode) {
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		if(NewNode.No == 0) {
			System.out.println("无法改变头节点的值");
			return;
		}
		HeroNode cur = Head;
		while(cur!=null) {
			if(cur.next.No == NewNode.No) {
				NewNode.next = cur.next.next;
				cur.next = NewNode;
				return;
			}
			cur = cur.next;
		}
	}
	
	//查找信息
	public void Search(int No) {
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		if(No == 0) {
			System.out.println("此节点为头节点");
			return;
		}
		HeroNode cur = Head;
		while(cur!=null) {
			if(cur.No == No) {
				System.out.println("编号 "+No+":"+cur);
				return;
			}
			cur = cur.next;
		}
		System.out.println("未找到匹配信息");
	}
	
	//查找单链表倒数第k个结点
	public HeroNode NodeFromLast(int k) {
		if(k>size()||k<=0) {
			return null;
		}
		HeroNode cur = Head.next;
		for(int i=0;i<(size()-k);i++) {
			cur = cur.next;
		}
		return cur;
	}
	//判空
	public boolean isempty() {
		return Head.next == null;
	}
	
	//遍历打印链表
	public void print() {
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		HeroNode cur = Head.next;
		while (cur != null) {
			System.out.println(cur);
			cur = cur.next;
		}
	}
	
	//从尾到头打印链表
	//1.将单链表反转，然后遍历（会破坏原来的结构）
	//2.利用栈，将各个节点压入到栈中，先进后出的特点，实现逆序打印的效果
	public void RevPrint() {
		if(isempty()) {
			System.out.println("此链表为空");
			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());
		}
	}
	
	//获取链表节点个数
	public int size() {
		int count =0;
		HeroNode cur = Head;
		while(cur.next != null) {
			cur=cur.next;
			count++;
		}
		return count;
	}
	
	//合并链表
	public void Combine(SingleLinkedList list) {
		HeroNode cur = list.Head.next;
		while(cur!=null) {
			list.Head = cur.next;
			cur.next = null;
			this.AddByOrder(cur);
			cur = list.Head;
		}
	}
}

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

双向链表
package DataStructure;


public class DoubleLinkDemo {
	public static void main(String[] args) {
		DoubleLinkList list = new DoubleLinkList();
		list.add(120,"CSSE");
		list.add(399,"ESL");
		list.add(220,"CSSE");
		list.add(399,"ESL");
		list.add(102,"CSSE");
		list.add(221,"MA");
		System.out.println("\tlist的大小："+list.size());
		System.out.println("\t正序打印");
		list.print();
		System.out.println("\t逆序打印");
		list.Rsprint();
		System.out.println("\t查找数据");
		Node[] array = list.search("CSSE");
		for(Node node:array) {
			if(node!=null) {
				System.out.println(node);
			}
		}
		System.out.println("\t删除数据");
		list.del(220);
		list.print();
		System.out.println("\t更改数据");
		list.update(new Node(221,"MA"), new Node(113,"MA"));
		list.print();
		
	}
}

class Node{
	int num;
	String name;
	Node pre;
	Node next;
	Node(int num,String name){
		this.num = num;
		this.name =name;
		pre =null;
		next=null;
	}
	@Override
	public String toString() {
		return name+" "+num;
	}
	@Override
	public boolean equals(Object obj) {
		Node node = (Node)obj;
		return node.num == this.num&&node.name.equals(this.name);
	}
	
	
}

class DoubleLinkList{
	private Node head;
	DoubleLinkList(){
		head =null;
	}
	//判空
	public boolean isempty() {
		return head == null;
	}
	
	//增
	public void add(int num,String name) {
		Node node = new Node(num,name);
		if(isempty()) {
			head = node;
			return;
		}
		Node cur = head;
		while(cur.next!=null) {
			if(cur.equals(node)) {
				System.out.println(node+" 节点已存在，无法添加");
				return;
			}
			cur = cur.next;
		}
		cur.next = node;
		node.pre = cur;
	}
	
	//删
	//根据编号删除数据
	public void del(int num) {
		Node cur = head;
		//数据为空
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		//数据在开头
		if(cur.num == num) {
			head = cur.next;
			return;
		}
		//数据在中间
		while(cur.next!=null) {
			if(cur.num == num) {
				cur.pre.next = cur.next;
				cur.next.pre = cur.pre;
				return;
			}
			cur = cur.next;
		}
		//数据在末尾
		if(cur.num == num) {
			cur.pre.next= null;
			return;
		}
		System.out.println("未找到相关数据");
	}
	
	//改,更改数据
	public void update(Node Oldnode,Node Newnode) {
		Node cur = head;
		//数据为空
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		//数据在开头
		if(cur.equals(Oldnode)) {
			Newnode.next = cur.next;
			cur.next.pre = Newnode;
			head = Newnode;
			return;
		}
		//数据在中间,数据在末尾
		while(cur!=null) {
			if(cur.equals(Oldnode)) {
				Newnode.next = cur.next;
				cur.pre.next = Newnode;
				Newnode.pre = cur.pre;
				return;
			}
			cur = cur.next;
		}
		System.out.println("未找到相关数据");
	}
	
	//查
	//根据name查找数据
	public Node[] search(String name) {
		Node cur = head;
		boolean exist = false;
		Node[] array = new Node[this.size()];
		int count=0;
		//数据为空
		if(isempty()) {
			System.out.println("链表为空");
			return null;
		}
		while(cur!=null) {
			if(cur.name.equals(name)) {
				array[count] = cur;
				exist =true;
				count++;
			}
			cur = cur.next;
		}
		if(!exist) {
			System.out.println("未找到相关数据");
		}
		return array;
	}
	
	//list的大小
	public int size() {
		int count=0;
		Node cur = head;
		while(cur!=null) {
			cur = cur.next;
			count++;
		}
		return count;
	}
	
	//正遍历
	public void print() {
		Node cur = head;
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		while(cur!= null) {
			System.out.println(cur);
			cur = cur.next;
		}
	}
	
	//逆遍历
	public void Rsprint() {
		Node cur = head;
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		while(cur.next!=null) {
			cur = cur.next;
		}
		while(cur!=null) {
			System.out.println(cur);
			cur = cur.pre;
		}
	}
	
}

结果
在这里插入图片描述

单向循环链表
public class CircleLinkedListDemo {
 public static void main(String[] args) {
  CircleLinkedList list = new CircleLinkedList();
  for(int i=0;i<5;i++) {
   list.add(i);
  }
  System.out.println("\t添加数据");
  list.print();
  System.out.println("\t删除头部数据");
  list.del(0);
  list.print();
  System.out.println("\t更改数据");
  list.update(new Node(3), new Node(0));
  list.print();
  System.out.println("\t查找数据，是否包含此数据");
  System.out.println(list.contains(3));
//  System.out.println("\t删除中间数据");
//  list.del(3);
//  list.print();
//  System.out.println("\t删除尾部数据");
//  list.del(4);
//  list.print();
}
}

class Node{
 int num;
 Node next;
 Node(int num){
  this.num = num;
  next = null;
 }
 @Override
 public boolean equals(Object obj) {
  Node node =(Node) obj;
  return node.num == this.num;
 }
 @Override
 public String toString() {
  return num+"";
 }
 
}
class CircleLinkedList{
	private Node head;
	
	public CircleLinkedList() {
		head = null;
	}
	
	//判空
	public boolean isempty() {
		return head == null;
	}
	
	//增
	public void add(int num) {
		Node node = new Node(num);
		//开始为空
		if(isempty()) {
			head = node;
			node.next = head;
			return;
		}
		//开始不为空
		Node cur = head;
		while(cur.next!=head) {
			if(cur.equals(node)) {
				System.out.println("此数据已存在");
				return;
			}
			cur =cur.next;
		}
		cur.next = node;
		node.next = head;
	}
	
	//删
	public void del(int num) {
		Node cur = head;
		//判空
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		
		while(cur.next!=head) {
			if(cur.next.num == num) {
				//数据在尾部
				if(cur.next.next == head) {
					cur.next = head;
					return;
				}
				cur.next = cur.next.next;
				return;
			}
			cur = cur.next;
		}
		//数据在头部,此时指针在尾部
		if(cur.next.num == num) {
			head = head.next;
			cur.next = cur.next.next;
			return;
		}
		System.out.println("未找到相关数据");
	}
	
	//改
	public void update(Node OldNode, Node NewNode) {
		Node cur = head;
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		//中间与尾部
		while(cur.next != head) {
			if(cur.next.equals(OldNode)) {
				NewNode.next = cur.next.next;
				cur.next = NewNode;
				return;
			}
			cur =cur.next;
		}
		//数据在头部
		if(cur.next.equals(OldNode)) {
			NewNode.next = head.next;
			head = NewNode;
			cur.next = head;
			return;
		}
		System.out.println("未找到相关数据");

	}
	
	//查
	public boolean contains(int num) {
		Node cur = head;
		do{
			if(cur.num == num) {
				return true;
			}
			cur=cur.next;
		}while(cur!=head) ;
		return false;
	}
	//遍历
	public void print() {
		Node cur = head;
		if(isempty()) {
			System.out.println("链表为空");
			return;
		}
		do{
			System.out.println(cur);
			cur = cur.next;
		}while(cur!= head); 
	}

结果
在这里插入图片描述

总结

链表的学习比较抽象，刚开始接触会很懵，不知道哪个是哪个。多画图，多分析，对于链表的理解就会更加深刻。

参考资料

尚硅谷的数据结构：https://www.bilibili.com/video/BV1E4411H73v?p=17

待到长发及腰时
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构：链表逆序输出
weixin_43495735的博客
07-14 1775
数据结构（一）：链表逆序输出 题目描述：创建一个链表，并将链表逆序输出，链表中以输入0作为结束 关键代码详解： 附：全部代码 #include<stdio.h> #include<stdlib.h> #include<conio.h> typedef struct node{ int n; struct node *next; }linklist; linklist *CreatList(){ int a; linklist *head,*s,*r,*w
数据结构：链表的合并与直接插入排序
04-03
本人数据结构课设题目：《链表的合并与直接插入排序》
java数据结构03（单向链表）
weixin_55139299的博客
05-30 120
java实现单向链表和双向链表
c++数据结构：链表
qq_45303986的博客
10-13 5748
用一组任意的存储单元存储线性表的数据元素（这些存储单元可以是连续的，也可以是不连续的）
JS 数据结构：链表
weixin_46015333的博客
11-24 4176
本文介绍了什么是链表以及他的优缺点，并分别介绍了单链表、双向链表和循环链表之间的细微差别和各自的特点，一些有明显差异的操作都分别给出了图和代码，更易于理解和实践。
数据结构：链表及其C++实现
热门推荐
forGemini的博客
05-26 1万+
前言 链表是一种非常非常基础的数据结构，本文首先讲解链表的基础知识，然后使用C++的模板实现了一个链表类，并简单实现了常见的插入、删除、查找等算法。 阅读本文需要对C/C++的指针具有一定的了解。 基础知识 链表是一种逻辑上连续，内存上分散的线性表数据结构，其基本单位为结点，每个结点分数据区和指针区，数据区用于存放数据，指针区则用于指向其他结点，通过指针每个结点就被串接成了一条“链子”。
数据结构：链表（Python语言实现）
最新发布
2301_76884567的博客
03-16 5548
本文以单链表为例，用python创建一个单链表数据结构，同时定义链表节点的增加、删除、查询和打印操作。
Python数据结构：链表
Python宋宋的专栏
06-06 3572
链表是一种在存储单元上非连续、非顺序的存储结构。数据元素的逻辑顺序是通过链表中的指针链接次序实现。链表是由一系列的结点组成，结点可以在运行时动态生成。每个结点包含两部分：数据域与指针域。数据域存储数据元素，指针域存储下一结点的指针。单向链表也叫单链表，是链表中最简单的形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。head 保存首地址，item 存储数据，next 指向下一结点地址。链表失去了序列的随机读取优点，同时链表增
数据结构：链表（C语言实现）
秋笙子的菜鸡历程
05-03 4973
介绍链表之前，我们还需要了解一下线性表、数组与链表的关系。 线性表是一种线性结构，它的特点是在数据元素的非空有限集中： 存在唯一的一个被称作“第一个”的数据元素 存在唯一的一个被称作“最后一个”的数据元素 除第一个外，集合中的每个数据元素均只有一个前驱 除最后一个外，集合中每个数据元素均只有一个后继 简单来谈就是数据元素“一个接一个的排列”，且由同一种类型的数据元素构成的线性结构就是线性表。而...
数据结构：链表(Linklist)的定义和它的函数们
qq_49666427的博客
11-28 4367
数据结构：链表(Linklist)的定义和它的函数们 链表的定义： 对整体的定义(相当于一个大括号,保存一头一尾的指针) #define MAXSIZE 100 typedef char ElemType; typedef struct _list { ElemType* head; ElemType* tail; }List; 对结点的定义 typedef struct _node { int index; //链表索引 ELemType data;
数据结构：链表与逻辑问题
Kobe51920的博客
08-18 2738
优点 缺点 链表 1.用多少开多少，直接链上去，没有空间浪费 2.头尾插入效率高 O(1) 不支持随机访问，顺序访问 顺序表 1.支持随机访问,随机访问 1.增容时成倍增长，有空间浪费 2.中间或者头部插入数据时效率不高 O(N) ...
数据结构：链表.ppt
09-17
链表数据结构 链表是一种基本的数据结构，它是一种线性表的链接存储表示。链表的每个元素（结点）由结点（Node）构成，每个结点包含数据域和链域，链域指向下一个结点。链表的特点是每个元素可以连续或不连续存储，...
swift代码-Swift数据结构: 链表(Linked List)
07-14
链表是一种重要的数据结构，它的实现方式与数组不同，它不连续存储元素，而是通过节点之间的引用链接来存储。本篇文章将深入探讨Swift中的链表（Linked List）及其相关知识点。 ### 链表的基本概念 链表由一系列...
Eclipse连接Github，git失败，一直要输入Login密码
peterbearXY的博客
10-19 2347
之前遇到这个问题，十分头疼 后来经过大佬指点发现了问题所在：Github的PAT（personal access token）的问题 解决方法： 跟着以下连接修改自己的Github设置setting Github： https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token 重启项目，重新commit，user选择自己github的us
Scanner 连续输入问题
peterbearXY的博客
03-28 2280
使用Scanner 在while循环中输入choice 起初一直出现问题 后来发现我在其他方法里面也使用了Scanner，并且关闭了scanner 最后这个导致了我程序的崩溃 改正方法： 把scanner作为参数，传入方法中，在方法中不关闭 或者把scanner作为全局变量，当然，不要在方法中关闭，在main函数结束后再关闭 main函数 //定义为全局变量 static Scanner input= new Scanner(System.in); //main函数 int option=0;
JAVA入门万字总结
peterbearXY的博客
02-12 2085
文章目录引言什么是JAVA第一个JAVA程序结果JAVA的数据类型内置数据类型引用数据类型内置数据类型整型浮点型字符型布尔型引用数据类型基础类型转换自动类型转换强制类型转换JAVA符号算数运算符关系运算符逻辑运算符补充JAVA逻辑判断if / elseswitch caseJAVA循环for循环while循环breakcontinuedo while循环判断与循环的应用求最大公因数求100以内的素数不死神兔水仙花数99乘法表求Pi的值JAVA函数格式作用域void关键字函数调用其他函数JAVA数组创建数组访
排序算法部分可视化
peterbearXY的博客
04-26 389
排序算法部分可视化 程序介绍 最近复习排序算法闲着无聊，做了一个可视化小程序，这个程序支持部分排序算法，当然有兴趣可以自己扩展 我将冒泡排序，选择排序，插入排序，希尔排序，快速排序做了可视化，展示一下最终效果 感兴趣可以看看我原来写的排序算法的链接（归并排序，桶排序） https://blog.csdn.net/peterbearXY/article/details/114648428 程序描述 点击相应的按钮可以让下面的图像进行更新，点击重置可以使所有数回到原有位置 我们可以通过看相应的图像变化了解排序
数据结构：栈
peterbearXY的博客
02-23 273
数据结构：栈 介绍 栈和队列一样是一种特殊的线性表结构，它的特点是先进后出（first in last out）。下面有一张图来描述栈 栈有两个常用方法 pop()，出栈，从尾部弹出元素 push(int value)，压栈，把数据压入栈中 实现栈 实现栈的方式有多种，我列举2种：一种是用数组来实现栈，还有一种是用链表来实现栈 ArrayStack（数组） LinkedListStack（链表） ArrayStack package DataStructure; public class Arr
JAVA稀疏数组
peterbearXY的博客
02-15 231
引入 数组是一个很常见的数据存储模式，但是有时使用数组会浪费掉一部分空间；例如在5*5的五子棋中，黑子代表1，白子代表2，而空白的区域代表0；为了表示棋盘中的数据，我们可能会使用二维数组来解决这个问题，最后的结果如下 0 1 0 2 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 此时，在这个数组中，我们会浪费掉一些空间，因为这些空间表示的都是0；为了解决这个问题，避免浪费过多的空间，我们需要使用稀疏数组。 介绍 在稀疏数组中，每行分别有三个元素：行，列，值。在稀疏数组的
数据结构：链表详解与操作
链表是一种重要的数据结构，它在计算机科学中被广泛应用，特别是当需要动态管理内存或对插入和删除操作有高效要求时。链表的核心概念是将数据元素链接在一起，而不是像数组那样通过连续的内存地址来存储。这使得链表...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值