算法数据结构体系学习 第八节

于 2022-08-02 23:11:51 发布
阅读量59 收藏
点赞数
分类专栏： 算法数据结构体系学习 文章标签： 数据结构 算法 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29374433/article/details/126131224
版权
本文介绍了前缀树（Trie）的两种实现方式，包括固定数组和哈希表，并提供了插入、删除、搜索和前缀查询的函数实现。同时，探讨了不基于比较的排序算法，如计数排序和基数排序，它们的时间复杂度为O(N)，适用于特定数据范围。文章通过测试用例验证了前缀树和非比较排序算法的正确性。
摘要由CSDN通过智能技术生成

前缀树（prefix tree trie）

1）单个字符串中，字符从前到后的加到一棵多叉树上
2）字符放在路上，节点上有专属的数据项（常见的是pass和end值）
3）所有样本都这样添加，如果没有路就新建，如有路就复用
4）沿途节点的pass值增加1，每个字符串结束时来到的节点end值增加1

可以完成前缀相关的查询

设计一种结构。用户可以：

1）void insert(String str) 添加某个字符串，可以重复添加，每次算1个
2）int search(String str) 查询某个字符串在结构中还有几个
3) void delete(String str) 删掉某个字符串，可以重复删除，每次算1个
4）int prefixNumber(String str) 查询有多少个字符串，是以str做前缀的

前缀树路的实现方式

1）固定数组实现

2）哈希表实现

	public static class Node1 {
		public int pass;
		public int end;
		public Node1[] nexts;

		// char tmp = 'b'  (tmp - 'a')
		public Node1() {
			pass = 0;
			end = 0;
			// 0    a
			// 1    b
			// 2    c
			// ..   ..
			// 25   z
			// nexts[i] == null   i方向的路不存在
			// nexts[i] != null   i方向的路存在
			nexts = new Node1[26];
		}
	}

	public static class Trie1 {
		private Node1 root;

		public Trie1() {
			root = new Node1();
		}

		public void insert(String word) {
			if (word == null) {
				return;
			}
			char[] str = word.toCharArray();
			Node1 node = root;
			node.pass++;
			int path = 0;
			for (int i = 0; i < str.length; i++) { // 从左往右遍历字符
				path = str[i] - 'a'; // 由字符，对应成走向哪条路
				if (node.nexts[path] == null) {
					node.nexts[path] = new Node1();
				}
				node = node.nexts[path];
				node.pass++;
			}
			node.end++;
		}

		public void delete(String word) {
			if (search(word) != 0) {
				char[] chs = word.toCharArray();
				Node1 node = root;
				node.pass--;
				int path = 0;
				for (int i = 0; i < chs.length; i++) {
					path = chs[i] - 'a';
					if (--node.nexts[path].pass == 0) {
						node.nexts[path] = null;
						return;
					}
					node = node.nexts[path];
				}
				node.end--;
			}
		}

		// word这个单词之前加入过几次
		public int search(String word) {
			if (word == null) {
				return 0;
			}
			char[] chs = word.toCharArray();
			Node1 node = root;
			int index = 0;
			for (int i = 0; i < chs.length; i++) {
				index = chs[i] - 'a';
				if (node.nexts[index] == null) {
					return 0;
				}
				node = node.nexts[index];
			}
			return node.end;
		}

		// 所有加入的字符串中，有几个是以pre这个字符串作为前缀的
		public int prefixNumber(String pre) {
			if (pre == null) {
				return 0;
			}
			char[] chs = pre.toCharArray();
			Node1 node = root;
			int index = 0;
			for (int i = 0; i < chs.length; i++) {
				index = chs[i] - 'a';
				if (node.nexts[index] == null) {
					return 0;
				}
				node = node.nexts[index];
			}
			return node.pass;
		}
	}

	public static class Node2 {
		public int pass;
		public int end;
		public HashMap<Integer, Node2> nexts;

		public Node2() {
			pass = 0;
			end = 0;
			nexts = new HashMap<>();
		}
	}

	public static class Trie2 {
		private Node2 root;

		public Trie2() {
			root = new Node2();
		}

		public void insert(String word) {
			if (word == null) {
				return;
			}
			char[] chs = word.toCharArray();
			Node2 node = root;
			node.pass++;
			int index = 0;
			for (int i = 0; i < chs.length; i++) {
				index = (int) chs[i];
				if (!node.nexts.containsKey(index)) {
					node.nexts.put(index, new Node2());
				}
				node = node.nexts.get(index);
				node.pass++;
			}
			node.end++;
		}

		public void delete(String word) {
			if (search(word) != 0) {
				char[] chs = word.toCharArray();
				Node2 node = root;
				node.pass--;
				int index = 0;
				for (int i = 0; i < chs.length; i++) {
					index = (int) chs[i];
					if (--node.nexts.get(index).pass == 0) {
						node.nexts.remove(index);
						return;
					}
					node = node.nexts.get(index);
				}
				node.end--;
			}
		}

		// word这个单词之前加入过几次
		public int search(String word) {
			if (word == null) {
				return 0;
			}
			char[] chs = word.toCharArray();
			Node2 node = root;
			int index = 0;
			for (int i = 0; i < chs.length; i++) {
				index = (int) chs[i];
				if (!node.nexts.containsKey(index)) {
					return 0;
				}
				node = node.nexts.get(index);
			}
			return node.end;
		}

		// 所有加入的字符串中，有几个是以pre这个字符串作为前缀的
		public int prefixNumber(String pre) {
			if (pre == null) {
				return 0;
			}
			char[] chs = pre.toCharArray();
			Node2 node = root;
			int index = 0;
			for (int i = 0; i < chs.length; i++) {
				index = (int) chs[i];
				if (!node.nexts.containsKey(index)) {
					return 0;
				}
				node = node.nexts.get(index);
			}
			return node.pass;
		}
	}

	public static class Right {

		private HashMap<String, Integer> box;

		public Right() {
			box = new HashMap<>();
		}

		public void insert(String word) {
			if (!box.containsKey(word)) {
				box.put(word, 1);
			} else {
				box.put(word, box.get(word) + 1);
			}
		}

		public void delete(String word) {
			if (box.containsKey(word)) {
				if (box.get(word) == 1) {
					box.remove(word);
				} else {
					box.put(word, box.get(word) - 1);
				}
			}
		}

		public int search(String word) {
			if (!box.containsKey(word)) {
				return 0;
			} else {
				return box.get(word);
			}
		}

		public int prefixNumber(String pre) {
			int count = 0;
			for (String cur : box.keySet()) {
				if (cur.startsWith(pre)) {
					count += box.get(cur);
				}
			}
			return count;
		}
	}

	// for test
	public static String generateRandomString(int strLen) {
		char[] ans = new char[(int) (Math.random() * strLen) + 1];
		for (int i = 0; i < ans.length; i++) {
			int value = (int) (Math.random() * 6);
			ans[i] = (char) (97 + value);
		}
		return String.valueOf(ans);
	}

	// for test
	public static String[] generateRandomStringArray(int arrLen, int strLen) {
		String[] ans = new String[(int) (Math.random() * arrLen) + 1];
		for (int i = 0; i < ans.length; i++) {
			ans[i] = generateRandomString(strLen);
		}
		return ans;
	}

	public static void main(String[] args) {
		int arrLen = 100;
		int strLen = 20;
		int testTimes = 100000;
		for (int i = 0; i < testTimes; i++) {
			String[] arr = generateRandomStringArray(arrLen, strLen);
			Trie1 trie1 = new Trie1();
			Trie2 trie2 = new Trie2();
			Right right = new Right();
			for (int j = 0; j < arr.length; j++) {
				double decide = Math.random();
				if (decide < 0.25) {
					trie1.insert(arr[j]);
					trie2.insert(arr[j]);
					right.insert(arr[j]);
				} else if (decide < 0.5) {
					trie1.delete(arr[j]);
					trie2.delete(arr[j]);
					right.delete(arr[j]);
				} else if (decide < 0.75) {
					int ans1 = trie1.search(arr[j]);
					int ans2 = trie2.search(arr[j]);
					int ans3 = right.search(arr[j]);
					if (ans1 != ans2 || ans2 != ans3) {
						System.out.println("Oops!");
					}
				} else {
					int ans1 = trie1.prefixNumber(arr[j]);
					int ans2 = trie2.prefixNumber(arr[j]);
					int ans3 = right.prefixNumber(arr[j]);
					if (ans1 != ans2 || ans2 != ans3) {
						System.out.println("Oops!");
					}
				}
			}
		}
		System.out.println("finish!");

	}

不基于比较的排序

桶排序思想下的排序：计数排序 & 基数排序

1)桶排序思想下的排序都是不基于比较的排序

2)时间复杂度为O(N)，额外空间负载度O(M)

3)应用范围有限，需要样本的数据状况满足桶的划分

// only for 0~200 value
	public static void countSort(int[] arr) {
		if(arr==null ||arr.length<2){
			return;
		}
		int max=Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			max=Math.max(max,arr[i]);
		}
		int[] bucket=new int[max+1];
		for (int i = 0; i < arr.length; i++) {
			bucket[arr[i]]++;
		}
		int index=0;
		for (int i = 0; i < arr.length; i++) {
			while (bucket[i]-->0){
				arr[index++]=i;
			}
		}
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 150;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			countSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		countSort(arr);
		printArray(arr);

	}

计数排序和基数排序

1）一般来讲，计数排序要求，样本是整数，且范围比较窄

2）一般来讲，基数排序要求，样本是10进制的正整数

一旦要求稍有升级，改写代价增加是显而易见的

// only for no-negative value
	public static void radixSort(int[] arr) {
		if (arr == null || arr.length < 2) {
			return;
		}
		radixSort(arr, 0, arr.length - 1, maxbits(arr));
	}

	public static int maxbits(int[] arr) {
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			max = Math.max(max, arr[i]);
		}
		int res = 0;
		while (max != 0) {
			res++;
			max /= 10;
		}
		return res;
	}

	// arr[L..R]排序  ,  最大值的十进制位数digit
	public static void radixSort(int[] arr, int L, int R, int digit) {
		final int radix = 10;
		int i = 0, j = 0;
		// 有多少个数准备多少个辅助空间
		int[] help = new int[R - L + 1];
		for (int d = 1; d <= digit; d++) { // 有多少位就进出几次
			// 10个空间
		    // count[0] 当前位(d位)是0的数字有多少个
			// count[1] 当前位(d位)是(0和1)的数字有多少个
			// count[2] 当前位(d位)是(0、1和2)的数字有多少个
			// count[i] 当前位(d位)是(0~i)的数字有多少个
			int[] count = new int[radix]; // count[0..9]
			for (i = L; i <= R; i++) {
				// 103  1   3
				// 209  1   9
				j = getDigit(arr[i], d);
				count[j]++;
			}
			for (i = 1; i < radix; i++) {
				count[i] = count[i] + count[i - 1];
			}
			for (i = R; i >= L; i--) {
				j = getDigit(arr[i], d);
				help[count[j] - 1] = arr[i];
				count[j]--;
			}
			for (i = L, j = 0; i <= R; i++, j++) {
				arr[i] = help[j];
			}
		}
	}

	public static int getDigit(int x, int d) {
		return ((x / ((int) Math.pow(10, d - 1))) % 10);
	}

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100000;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			radixSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		radixSort(arr);
		printArray(arr);

	}

排序算法的稳定性

稳定性是指同样大小的样本再排序之后不会改变相对次序

对基础类型来说，稳定性毫无意义

对非基础类型来说，稳定性有重要意义

有些排序算法可以实现成稳定的，而有些排序算法无论如何都实现不成稳定的

以前你的名字
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法 Python语言描述
04-19
根据给定文件的信息，我们...通过上述知识点的梳理，可以看出《数据结构与算法：Python语言描述》是一本内容全面、实践性强的数据结构教材，旨在帮助学习者建立扎实的数据结构基础，并掌握高效的算法设计与实现能力。
Java基础，Java进阶，Java数据结构，十大算法
04-04
本教程涵盖了从基础到高级，再到数据结构和算法的全面Java知识体系，旨在帮助开发者深入理解和掌握这门语言。 首先，我们从“Java基础”开始。Java基础是学习任何编程语言的第一步，主要包括以下几个核心概念： 1....
前缀树（prefix tree trie）
weixin_41642408的博客
07-27 165
前缀树 老规矩，先来几个概念 1）单个字符串中，字符从前到后的加到一棵多叉树上 2）字符放在路上，节点上有专属的数据项（常见的是pass和end值） 3）所有样本都这样添加，如果没有路就新建，如有路就复用 4）沿途节点的pass值增加1，每个字符串结束时来到的节点end值增加1 可以完成前缀相关的查询 show code, create it public class TrieTree { public static class Node1 { public int pass; public.
Trie树（Prefix Tree）介绍
dbbaq24022的专栏
05-09 515
本文用尽量简洁的语言介绍一种树形数据结构 —— Trie树。 一、什么是Trie树 Trie树，又叫字典树、前缀树（Prefix Tree）、单词查找树 或 键树，是一种多叉树结构。如下图： 上图是一棵Trie树，表示了关键字集合{“a”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”} 。从上图可以归纳...
Prefix tree
weixin_30439031的博客
12-04 100
Prefix tree The trie, or prefix tree, is a data structure for storing strings or other sequences in a way that allows for a fast look-up. In its simplest form it can be used as a list of keywords...
【Trie】 (Prefix Tree) - 前缀树、字典树
Bob__yuan的博客
08-11 445
LeetCode - 208. Implement Trie (Prefix Tree)   Trie, 又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点...
Implement_Trie_(Prefix_Tree)
numbstorm的博客
09-11 312
题目描述： Implement a trie(单词查找树:利用字符串的公共前缀来节约存储空间) with insert, search, and startsWith methods. Note:   You may assume that all inputs are consist of lowercase letters a-z. 思路:全在注释里。 public class Im
数据挖掘 机器学习原理与SPSS Clementine应用宝典 第13章 遗传算法 共25页.ppt
07-10
数据挖掘 机器学习原理与SPSS Clementine应用宝典 第8章 聚类分析.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第9章 决策树算法.ppt 数据挖掘 机器学习原理与SPSS Clementine应用宝典 第10章 关联规则.ppt...
Trie(prefix tree，前缀树，字典树)
sherine的博客
12-07 1104
Trie(Prefix tree， 前缀树，字典树)简介在计算机科学中，trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值。
trie树（前缀树，字典树） 入门模板题 （不使用指针，acmer写法）
qq_33969563的博客
04-21 386
trie树 又称单词查找树，字典树，前缀树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。 个人觉得关键是搞明白数组tree[root][id]的意思。(假设用于存仅含小写字母的单词) 若tree[root][id] == 0,表示root这个点没有与表示字符id + 'a'的点相连. 若tree[root][id
算法数据结构（三）---常见数据结构
u011624267的博客
07-23 250
单向链表 //单向链表节点结构（可以实现成范型） public class Node { public int value; public Node next; public Node(int data) { value = data; } } 双向链表 //双向链表节点结构 public class DoubleNode { public int value; public DoubleNode last; publi
Trie (Prefix Tree) 前缀树
l947069962的博客
08-28 2395
1. 什么是Trie?Trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值。 Trie可以看作是一个确定有限状态自动机，尽管边
后端面试常见数据结构1——前缀树（Prefix Tree）
JMW1407的博客
06-25 914
前缀树（Prefix Tree）1、背景2、定义3、特点4、构造4.1、实现 Trie (前缀树)——力扣 2084.2、Trie ——文本词频统计参考 1、背景 节点所有的后代都与该节点相关的字符串有着共同的前缀。这就是前缀树名称的由来。 对于一个字符串数据，我们要从查找某个字符串是否出现过，或者其中以“hell”开头 ，或者以"ive"结尾的字符是否出现以及出现的个数等等操作。我们只需要在定义前缀树的时候加上相应得数据项就可以了。 2、定义 前缀树是N叉树的一种特殊形式。通常来说，一个前缀树是用来
Trie(前缀树,prefix tree)
热门推荐
jia_xiaoxin的专栏
09-11 1万+
        trie或者prefix tree(前缀树),是一种有序树数据结构,它通常被存储在一个以字符串为关键字的联合数组中。于二叉搜索树不同，在树里没有结点存储与结点相关联的关键字。它是用它在树中的位置展示与它相关的关键字。任何一个结点的所有子结点有一个字符串前缀与结点相关联，根与空字符串相关联。值通常跟每个结点不关联。只是叶结点和一些内部的结点与感兴趣的关键字相关。        术
算法数据结构（六）---堆与堆排序
u011624267的博客
07-27 191
比较器 1)比较器的实质就是重载比较运算符 2)比较器可以很好的应用在特殊标准的排序上 3)比较器可以很好的应用在根据特殊标准排序的结构上 4)写代码变得异常容易，还用于范型编程 public static class Student { public String name; public int id; public int age; public Student(String name, int id, int age) { this.name = .
Implement Trie (Prefix Tree)
恒河沙无数
07-27 259
leetcode第208题，字典树的简单实现，上次数学建模比赛的时候就是用的字典树，对于这种数据结构的原理还是比较了解的，不过当时编程水平堪忧，调试了很久。这次我用python来实现字典树，为了实现后缀，我采用字典，这样可以随着动态绑定，另外字典树最重要的还要加入停止标记，来确保单词在什么位置结束。此外，还要考虑到多种情况，比如查找的时候，单词已经遍历完毕，但是树还没有到达结束标记位置，这时候需要
Trie 树模板（字典树，前缀树）
Harington的博客
08-19 222
学习请点这里 主要作用： 词频统计：例如，给定一个由 10 万个单词组成的库，现要你判断一个单词是否有在库中出现，若出现，求出共出现多少次。 前缀匹配：给定字符串，找出以这个字符串开头的所有单词。 插入代码 const int maxn = 1e5; int Tire[maxn][27]; int book[maxn]; int tot = 1; void init(){ memset...
前缀树（trie）实现
qq_39559641的博客
12-31 2408
目录简介性质算法思路插入字符串查找前缀代码实现实现类测试类测试结果参考文档 简介 前缀树（trie）又称字典树、单词查找树。它由字符串键中的所有字符构造而成，允许使用被查找键中的字符进行查找。它的英文单词 trie 来自于 E.Fredkin 在 1960 年玩的一个文字游戏，因为这个数据结构的作用是取出（ retrieval）数据，但发音为 try 是为了避免与 tree 相混淆。 性质 和其它查找树一样，单词查找树也是由链接的结点所组成的数据结构，这些链接可能为空，也可能指向其他结点。每个结点都只可能有
C#语言解析数据结构与算法实战
第1章介绍了基础知识，包括数据结构和算法的基本概念，以及C#语言和必要的数学知识。接下来的章节则深入探讨了各种常用数据结构，如线性表、栈、队列、字符串、数组、树和图，同时讲解了这些数据结构在.NET ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值