关于常见的各种链表算法题C++代码实现（希望可以持续更新…）

已于 2023-09-06 19:09:37 修改
阅读量1.3k 收藏 4
点赞数
分类专栏： leetcode+newcoder 【C/C++】 【数据结构】 文章标签： 链表 c++ 算法
于 2021-12-07 15:32:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43753894/article/details/121770606
版权

反正就是各种链表

1、定义单链表/双链表

struct ListNode {
	int val;
	ListNode* next;
	ListNode(int x) :val(x),next(NULL) {}
};
struct ListNode{
	ListNode* pre;
	ListNode* next;
	int value;
	ListNode(int _key, int _value):
		pre(nullptr),
		next(nullptr),
		value(_value)
	{}
};

2、单链表的反转

NC78 反转链表

属于是必知必会题了~

ListNode* ReverseList(ListNode* pHead) {
	ListNode* pre = nullptr;
	ListNode* cur = pHead;
	ListNode* nex = nullptr;
	while (cur) {
		nex = cur->next;
		cur->next = pre;
		pre = cur;
		cur = nex;
	}
	return pre;
}

3、判断链表中是否有环

NC4 判断链表中是否有环

经典之快慢指针

bool hasCycle(ListNode *head) {
    if(head == nullptr){
        return false;
    }
    ListNode* fast = head;
    ListNode* slow = head;
    while(fast != nullptr && fast->next != nullptr){
        fast = fast->next->next;
        slow = slow->next;
        if(fast == slow){
            return true;
       }
    }
    return false;
}

4、链表中环的入口结点

NC3 链表中环的入口结点

借助一下set

ListNode* EntryNodeOfLoop(ListNode* pHead) {
	set<ListNode*> s ;
	while (pHead != nullptr) {
		if (!s.empty()) {
			set<ListNode*>::iterator it = s.begin();
			it = s.find(pHead);
			if (it != s.end()) {
				return pHead;
			}
		}
		s.insert(pHead);
		pHead = pHead->next;
	}
	return  pHead;
}

5、两个链表的第一个公共结点

NC66 两个链表的第一个公共结点

ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
     ListNode *ta = pHead1, *tb = pHead2;
     while (ta != tb) {
       ta = ta ? ta->next : pHead2;
       tb = tb ? tb->next : pHead1;
    }
    return ta;
}

6、合并两个排序的链表

NC33 合并两个排序的链表

ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
	if (pHead1 == nullptr && pHead2 == nullptr) {
		return pHead1;
	}
	else if (pHead2 == nullptr && pHead1 != nullptr) {
		return pHead1;
	}
	else if (pHead1 == nullptr && pHead2 != nullptr) {
		return pHead2;
	}

	ListNode* pre = pHead1;
	vector<int> v;
	while (pre != nullptr) {
		v.push_back(pre->val);
		pre = pre->next;
	}
	pre = pHead2;
	while (pre != nullptr) {
		v.push_back(pre->val);
		pre = pre->next;
	}

	sort(v.begin(), v.end());

	ListNode* head;
	head = new ListNode(v[0]);
	ListNode* p = nullptr;
	head->next = p;
	ListNode* cur = head;
	for (size_t i = 1; i < v.size(); ++i) {
		p = new ListNode(v[i]);
		cur->next = p;
		cur = cur->next;
	}
	return head;
}

7、 合并k个已排序的链表

NC51 合并k个已排序的链表

ListNode* mergeKLists(vector<ListNode*>& lists) {
	if (lists.empty()) {
		return nullptr;
	}
	vector<int> cur;
	for (size_t i = 0; i < lists.size(); ++i) {
		ListNode* head = lists[i];
		while (head) {
			cur.push_back(head->val);
			head = head->next;
		}
	}
	sort(cur.begin(), cur.end());
	ListNode* ret = new ListNode(0);
	ListNode* pre = ret;
	for (size_t i = 0; i < cur.size(); ++i) {
		pre->next = new ListNode(cur[i]);
		pre = pre->next;
	}
	return ret->next;
}

8、单链表的排序

NC70 单链表的排序

ListNode* sortInList(ListNode* head) {
	if (head == nullptr) {
		return  nullptr;
	}
	vector<int> v;
	ListNode* next = head->next;
	while (head != nullptr) {
		v.push_back(head->val);
		head = next;
		if (next != nullptr) {
			next = head->next;
		}
		else {
			next = nullptr;
		}
	}
	sort(v.begin(), v.end());
	ListNode* pHead = new ListNode(v[0]);
	pHead->next = nullptr;
	ListNode* cur = pHead;
	for (size_t i = 1; i < v.size(); ++i) {
		ListNode* pre = new ListNode(v[i]);
		pre->next = nullptr;
		cur->next = pre;
		cur = cur->next;
	}
	return pHead;
}

9、链表中的节点每k个一组翻转

NC50 链表中的节点每k个一组翻转

ListNode* reverseKGroup(ListNode* head, int k) {
	if (head == nullptr) {
		return nullptr;
	}
	else if (k == 0) {
		return head;
	}
	ListNode* ret = new ListNode(0);
	stack<int> s;
	int num = 0;
	ListNode* cur = head;
	ListNode* pre = ret;

	while (cur) {
		while (num < k && cur != nullptr) {
			s.push(cur->val);
			cur = cur->next;
			num++;
		}
		if (s.size() == k) {
			while (!s.empty()) {
				pre->next = new ListNode(s.top());
				s.pop();
				pre = pre->next;
			}
		}
		else {
			stack<int> cur_s;
			while (!s.empty()) {
				cur_s.push(s.top());
				s.pop();
			}
			while (!cur_s.empty()) {
				pre->next = new ListNode(cur_s.top());
				cur_s.pop();
				pre = pre->next;
			}
		}
		num = 0;
	}
	return ret->next;
}

10、两个链表生成相加链表

NC40 两个链表生成相加链表

ListNode* addInList(ListNode* head1, ListNode* head2) {
	if (head1 == nullptr && head2 != nullptr) {
		return head2;
	}
	else if ((head1 != nullptr && head2 == nullptr) || (head1 == nullptr && head2 == nullptr)) {
		return head1;
	}
	stack<int> s1;
	stack<int> s2;

	while (head1 != nullptr) {
		s1.push(head1->val);
		head1 = head1->next;
	}
	while (head2 != nullptr) {
		s2.push(head2->val);
		head2 = head2->next;
	}

	stack<int> ret_s;
	int num = max(s1.size(), s2.size());

	int cur = 0;  //标记是否需要进位
	int ret = 0;
	for (int i = 0; i < num; ++i) {
		if (s1.empty()) {
			s1.push(0);
		}
		else if (s2.empty()) {
			s2.push(0);
		}
		ret = s1.top() + s2.top();
		//判断是否需要进位
		if (cur == 1) {
			ret += 1;
			cur = 0;
		}
		//判断下次是否需要进位
		if (ret >= 10) {
			cur = 1;
			ret_s.push(ret % 10);
		}
		else {
			ret_s.push(ret);
		}
		s1.pop();
		s2.pop();
	}
	if (cur == 1) {
		ret_s.push(1);
	}

	ListNode* pHead = new ListNode(ret_s.top());
	ListNode* pCur = nullptr;
	pCur = pHead;
	pHead->next = nullptr;
	ret_s.pop();
	size_t size = ret_s.size();
	for (size_t i = 0; i < size; ++i) {
		ListNode* node = new ListNode(ret_s.top());
		pCur->next = node;
		pCur = node;
		ret_s.pop();
	}
	return pHead;
}

11、删除有序链表中重复的元素-I

NC25 删除有序链表中重复的元素-I

去重！

ListNode* deleteDuplicates(ListNode* head) {
	if (head == nullptr) {
		return  nullptr;
	}
	set<int> s;
	ListNode* ret = new ListNode(0);
	ListNode* cur = head;
	ListNode* pre = ret;
	while (cur) {
		s.insert(cur->val);
		cur = cur->next;
	}

	for (set<int>::iterator it = s.begin(); it != s.end(); ++it) {
		pre->next = new ListNode(*it);
		pre = pre->next;
	}
	return ret->next;
}

12、删除有序链表中重复的元素-II

NC24 删除有序链表中重复的元素-II

有重复就删除！

ListNode* deleteDuplicates2(ListNode* head) {
	if (head == nullptr) {
		return  nullptr;
	}

	ListNode* ret = new ListNode(0);
	ListNode* pre = ret;
	ListNode* cur = head;
	map<int, int> m;
	while (cur) {
		map<int, int>::iterator it = m.find(cur->val);
		if (it != m.end()) {
			it->second += 1;
		}
		else {
			m.insert(make_pair(cur->val, 1));
		}
		cur = cur->next;
	}
	
	for (map<int, int>::iterator it = m.begin(); it != m.end(); ++it) {
		if (it->second == 1) {
			ListNode* nex = new ListNode(it->first);
			pre->next = nex;
			pre = pre->next;
		}
	}
	return ret->next;
}

13、链表内指定区间反转

NC21 链表内指定区间反转

ListNode* reverseBetween(ListNode* head, int m, int n) {
	if (head == nullptr || m == n) {
		return head;
	}

	ListNode* ret = new ListNode(0);
	ListNode* cur = ret;

	vector<int> v;
	stack<int> s;

	int num = 1;
	while (head != nullptr) {
		if (num < m) {
			v.push_back(head->val);
		}
		else if (num >= m && num <= n) {
			s.push(head->val);
		}
		else {
			while (!s.empty()) {
				v.push_back(s.top());
				s.pop();
			}
			v.push_back(head->val);
		}
		head = head->next;
		num++;
	}
	if (!s.empty()) {
		while (!s.empty()) {
			v.push_back(s.top());
			s.pop();
		}
	}
	for (size_t i = 0; i < v.size(); ++i) {
		ListNode* pre = new ListNode(v[i]);
		cur->next = pre;
		cur = cur->next;
	}
	return ret->next;
}

14、 排序奇升偶降链表

NC207 排序奇升偶降链表
面试题，要求只能通过链表操作来完成！！！（不然可以放到数组里sort）

ListNode* sortLinkedList(ListNode* head) {
	if (head == nullptr) {
		return nullptr;
	}
	ListNode* pre = head;
	ListNode* jHead = new ListNode(0);
	ListNode* oHead = new ListNode(0);
	
	//奇数位升序，偶数位降序, 返回升序
	ListNode* cur1 = jHead;
	int num = 1;
	while (pre) {
		if (num % 2 != 0) {
			ListNode* node = new ListNode(pre->val);
			cur1->next = node;
			cur1 = cur1->next;
		}
		else if (num % 2 == 0) { 
			ListNode* cur2 = oHead;
			ListNode* node = new ListNode(pre->val);
			if(cur2->next == nullptr){
				cur2->next = node;
			}
			else {
				ListNode* next = cur2->next;
				cur2->next = node;
				node->next = next;
			}
		}
		pre = pre->next;
		num++;
	}

	//两个有序链表合并
	
	ListNode* pre2 = oHead->next;
	while (pre2) {
		ListNode* pre1 = jHead->next;
		ListNode* cur = jHead;
		while (pre1) {
			if (pre2->val < pre1->val) {
				ListNode* node = new ListNode(pre2->val);
				cur->next = node;
				node->next = pre1;
				break;
			}
			if (pre1->next != nullptr) {
				if ((pre2->val > pre1->val) && (pre2->val < pre1->next->val)) {
					ListNode* next = pre1->next;
					ListNode* node = new ListNode(pre2->val);
					pre1->next = node;
					node->next = next;
					break;
				}
			}
			else {
				ListNode* node = new ListNode(pre2->val);
				pre1->next = node;
				node->next = nullptr;
				break;
			}
			pre1 = pre1->next;
			cur = cur->next;
		}
		pre2 = pre2->next;
	}
	return jHead->next;
}

15、判断一个链表是否为回文结构

NC96 判断一个链表是否为回文结构

bool isPail(ListNode* head) {
	if (head == nullptr || head->next == nullptr) {
		return true;
	}
	vector<int> vec;
	while (head) {
		vec.push_back(head->val);
		head = head->next;
	}

	for (size_t i = 0; i < sizeof(vec); ++i) {
		if (vec[i] == vec[vec.size() - 1 - i]) {
			if (i >= vec.size() - 1 - i) {
				break;
			}
			else {
				continue;
			}
		}
		else {
			return false;
		}
	}
	return true;
}

16、链表的奇偶重排

NC133 链表的奇偶重排

ListNode* oddEvenList(ListNode* head) {
	if (head == nullptr) {
		return head;
	}
	ListNode* jHead = new ListNode(0);
	ListNode* oHead = new ListNode(0);
	ListNode* cur1 = jHead;
	ListNode* cur2 = oHead;

	int num = 1;
	while (head) {
		ListNode* node = new ListNode(head->val);
		if (num % 2 != 0) {
			cur1->next = node;
			cur1 = cur1->next;
		}
		else{
			cur2->next = node;
			cur2 = cur2->next;
		}
		num++;
		head = head->next;
	}

	cur1->next = oHead->next;
	return jHead->next;
}

17、给单链表加一

NC189 给单链表加一

ListNode* reverseList(ListNode* head) {
	ListNode* pre = head;
	ListNode* cur = nullptr;
	ListNode* nex = nullptr;
	while (pre) {
		nex = pre->next;
		pre->next = cur;
		cur = pre;
		pre = nex;
	}
	return cur;
}

ListNode* plusOne(ListNode* head) {
	if (head == nullptr) {
		ListNode* node = new ListNode(1);
		return node;
	}
	ListNode* pHead = reverseList(head);
	ListNode* cur = pHead;

	int cur_num = 0; //进位标识位
	int num = 0;     //记录数据

	num = pHead->val + 1;
	if (num == 10) {
		cur_num = 1;
		pHead->val = 0;
		while (cur_num) {
			if (cur->next == nullptr) {
				ListNode* node = new ListNode(1);
				cur->next = node;
				cur_num = 0;
			}
			else {
				num = cur->next->val + 1;
				if (num < 10) {
					cur->next->val = num;
					cur_num = 0;
				}
				else {
					cur->next->val = 0;
				}
			}
			cur = cur->next;
		}
	}
	else {
		pHead->val = num;
	}
	return reverseList(pHead);
}

18、环形链表的约瑟夫问题

NC132 环形链表的约瑟夫问题

struct SListNode {
	int val;
	SListNode* pre;
	SListNode* nex;
	SListNode(int x) :
		val(x),
		pre(nullptr),
		nex(nullptr)
	{}
};

int ysf(int n, int m) {
	SListNode* root = new SListNode(0);
	SListNode* cur = root;
	for (int i = 1; i <= n; ++i) {
		SListNode* node = new SListNode(i);
		cur->nex = node;
		node->pre = cur;
		cur = cur->nex;
	}

	root = root->nex;
	root->pre = cur;
	cur->nex = root;
	
	cur = cur->nex;
	while (cur->nex != cur) {
		for (int i = 1; i <= m; ++i) {
			cur = cur->nex;
		}
		SListNode* node = cur->pre->pre;
		cur->pre = node;
		node->nex = cur;
	}
	return cur->val;
}

19、划分链表

NC23 划分链表

ListNode* partition(ListNode* head, int x) {
	if (head == nullptr) {
		return head;
	}
	
	ListNode* cur = head;
	ListNode* ret = new ListNode(0);
	ListNode* head_s = new ListNode(0);
	ListNode* head_b = new ListNode(0);
	ListNode* cur_a = head_s;
	ListNode* cur_b = head_b;

	int size_s = 0;
	int size_b = 0;

	while (cur) {
		if (cur->val < x) {
			ListNode* node = new ListNode(cur->val);
			cur_a->next = node;
			cur_a = cur_a->next;
			size_s++;
		}
		else if (cur->val >= x) {
			ListNode* node = new ListNode(cur->val);
			cur_b->next = node;
			cur_b = cur_b->next;
			size_b++;
		}
		cur = cur->next;
	}

	if (size_s && size_b) {
		cur_a->next = head_b->next;
		ret->next = head_s->next;
	}
	else {
		ret->next = head;
	}
	return ret->next;
}

20、删除链表的倒数第n个节点

BM9 删除链表的倒数第n个节点

ListNode* removeNthFromEnd(ListNode* head, int n) {
    // write code here
    ListNode* ret = new ListNode(0);
    ret->next = head;
    ListNode* slow = ret;
    ListNode* cur = head;
    ListNode* pre = head;
    while(n > 0){
        cur = cur->next;
        n--;
    }
    while(cur){
        cur = cur->next;
        slow = slow->next;
        pre = pre->next;
    }
    slow->next = pre->next;
    return ret->next;
}
_ClivenZ
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
链表经典算法题
Frank的博客
10-03 1692
定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。
C/C++每日一练(20230508) 链表专题
汉阳Hann's Home
05-08 725
1. 相交链表🌟🌟🌟 　 2. 排序链表🌟🌟 　 3. 重排链表🌟🌟
C C++最新5道入门单链表初阶题目_链表入门的简单题目，2024年最新你值得拥有
最新发布
2401_84973592的博客
05-15 819
/设置一个newhead指针指向NULL，然后将cur->next指向newhead。//头插之前设置一个next，保留原链表剩余的结点。//从头指针开始，默认不带哨兵位。//更新newhead，next赋值给cur。//n1变为新链表的头。//带哨兵位的头结点（简化尾插）//空链表逆置还是空。
【数据结构】链表经典算法题集锦
林慢慢的博客
09-12 9585
前言：本章将分享十一道来自LeetCode/牛客网中的经典链表算法题来介绍数据结构中链表在算法题中的应用。 文章目录1.删除链表元素思路分析：题解：2.反转链表思路分析：题解：3.链表中间结点思路分析（快慢指针法）：题解：4.链表中倒数第K个结点思路分析（快慢指针法）：题解：5.合并两个有序链表思路分析：题解：6.链表分割思路分析：题解：7.链表的回文结构(第2题和第3题的综合)思路分析：题解：8.相交链表思路分析：题解：9.环形链表I思路分析：题解：10.环形链表II思路分析：题解：11.复制带随机指针
六道链表经典算法题，带你体验链表算法魅力
2301_80157147的博客
02-08 1013
给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点这道题读完题目的话很多人的思路是遍历链表，根据节点个数，然后返回中间节点但今天我们讲的思路称之为快慢指针既然是快慢指针，那么一定有两个指针，并且两个指针的前进速度也不相同所以在这里，快指针一次前进两个节点，慢指针一次前进一个节点这样的话，当节点是奇数时，快指针的next指向NULL时，慢指针刚好在中间位置当节点是偶数是，当快指针指向为NULL时，慢指针也在第二个中间节点这样代码就完成了。
链表经典算法题总结(一)
zag666的博客
06-14 736
136. 只出现一次的数字 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 说明：算法应该具有线性时间复杂度，不使用额外空间来实现. 示例 1: 输入: [2,2,1] 输出: 1 示例 2: 输入: [4,1,2,1,2] 输出: 4 思路： 不需要额外空间的方法，就往位运算上想 相同的数异或为0 任何数与0异或为任何数 异或运算满足交换律和结合律 题解： class Solution { public int singleNumber(
C++实现oj算法代码-贪心算法.zip
10-28
在C++中，贪心算法的实现通常涉及数据结构，如数组、链表、栈、队列、优先队列（priority_queue）等。C++标准模板库（STL）提供丰富的容器和算法，能简化代码编写和优化性能。例如，`std::priority_queue`可以用来...
编程C++算法实现代码集.zip
10-18
本资料集"编程C++算法实现代码集.zip"包含了丰富的C++算法实现，旨在帮助开发者理解和掌握各种常见算法的编写技巧。 一、基础算法 C++的基础算法包括排序、搜索、数据结构等。例如，快速排序、归并排序、二分查找...
C++ 数据结构链表的实现代码
08-31
链表是一种重要的数据结构，它在...通过理解和掌握这些概念，你可以轻松地在C++中创建和操作链表，这对于学习数据结构和算法至关重要。在实际编程中，链表常用于动态存储，例如队列、栈、哈希表等复杂数据结构的实现。
C++版本从头到尾或者从尾到头打印链表原理及代码实现
07-02
C++版本从头到尾或者从尾到头打印链表原理及代码实现
链表-使用C++链表实现的多文件目录管理系统.zip
03-13
通过理解和实现这个系统，开发者可以加深对链表和C++编程的理解，同时提升在数据结构和算法方面的技能。在实际工作中，这样的数据结构经常用于构建复杂的数据管理系统，如文件系统、数据库索引等。
c++链表习题
10-18
单链表的删除 ，插入。删除具体数。删除非递减有序数列的相同元素。
链表算法题
printf_hao的博客
08-01 129
1.链表反转 leetcode链接 利用栈先入先出 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ class Solution { public: ListNode* reverseList(ListNode* head)
链表类算法题
qq_33690342的博客
02-19 601
1、反转链表leetcode 206： // ListNode Definition for singly-linked list. type ListNode struct { Val int Next *ListNode } func reverseList(head *ListNode) *ListNode { if head == nil || head.Next == nil { return head } var prev *Li
C++链表基本用法及LeetCode经典链表题目汇总
whocare的博客
05-02 3231
链表基本用法： 目录 链表基本用法： C++链表及基本操作 LeetCode链表经典题目汇总： 2. 两数相加 19. 删除链表的倒数第 N 个结点 21. 合并两个有序链表 23. 合并K个升序链表 24. 两两交换链表中的节点 25. K 个一组翻转链表 61. 旋转链表 92. 反转链表 II 141. 环形链表 142. 环形链表 II 160. 相交链表 328. 奇偶链表 C++链表及基本操作 1 2 ...
c++练习(10)：链表练习
@bangbang的博客
07-31 913
寻找特定位置,runner以两倍速前进,chaser一倍速，当runner到达tail时，chaser即为所求解。给定一个链表和一个数值，写一个函数重新排序链表，使得小于给定值的节点排在链表的左边,大于给点值的节点排在链表右侧。在head之前并指向head只要涉及操作head节点，当头节点操作不确定的时候，不妨创建dummynode;并且可以用一个简单的小testcase来验证(例如长度为4和5的list)对于寻找list某个特定位置的问题，不妨用两个变量。链表的头节点是否为。...
链表 http://hi.baidu.com/silverxinger/item/3adfff97fcff3245f14215a6
coding for life
12-05 1094
数据结构-链表-奇思妙想 基本函数 1，构造节点：  //定义节点类型 struct Node { int value; Node*next; };   2，分配节点 //之所以要分配节点原因是需要在分配函数中进行初始化，并且也利于判断是否分配成功。 Node* applyNode();   3，在头部增加节点 //增加节点在头部（无头结点）,返回值的原因是由于传入并
链表的算法题
flyingcloud6的博客
01-19 1426
不用太在乎空间复杂度，一切为了时间复杂度。时间复杂度依然放在第一位，但一定要找到空间最省的办法。
数据结构 作业答案 第2章 线性表
热门推荐
HKD_WCY的博客
06-14 1万+
第2章 线性表 1．选择题 （1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ ）。 A．110 B．108 C．100 D．120 答案：B 答案解析：顺序表中的数据连续存储，所以第5个元素的地址为：100+2*4=108。 （2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（ ）。 A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n） B．在第i个结点后插入一个新结点（1
Kruskal算法用链表判断回路C++实现不使用vector完整代码
05-26
以下是使用链表实现Kruskal算法判断回路的C++代码，不使用vector： ```c++ #include #include using namespace std; const int MAXN = 10005; const int MAXM = 100005; struct Edge { int u, v, w; bool ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_ClivenZ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值