数据结构之树从入门到如土(三)----字典树 前缀树(TrieTree) Go 实现

最新推荐文章于 2023-06-05 04:50:58 发布
最新推荐文章于 2023-06-05 04:50:58 发布
阅读量390 收藏 4
点赞数 4
分类专栏： Go 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41315492/article/details/104918802
版权
字典树的简介

又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。
根节点不包含字符，除根节点外每一个节点都只包含一个字符； 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串； 每个节点的所有子节点包含的字符都不相同。
Tree 树 是利用空间复杂度作为代价换区时间复杂度的应用,查找复杂度 为 o(Len),空间复杂度 是比较大的。
下面这个图是一个由 RA RC RZ RAC RAD RACE 等等组成 红色的节点 被标记成 了一个单词的结尾。

在这里插入图片描述

字典树的应用场景
  1. 求最近公共祖先，需要利用tire树作为数据结构
  2. 排序：前序遍历tire树，即可以得到一个按字母顺序的排序表
  3. 字符串检索：在搜索引擎中会用的(搜索时会弹出可能的单词结果)，主要是已知一个字符串集合，对这个集合进行预处理生成一个tire树，以后就维护这个tire树即可。

Tire用于统计：

题目：给你100000个长度不超过10的单词。对于每一个单词，我们要判断他出没出现过，如果出现了，求第一次出现在第几个位置。

解法 ：从第一个单词开始构造Tire树，Tire树包含两字段，字符与位置，对于非结尾字符，其位置标0，结尾字符，标注在100000个单词词表中的位置。对词表建造Tire树，对每个词检索到词尾，若词尾的数字字段>0,表示单词已经在之前出现过，否则建立结尾字符标志，下次出现即可得知其首次出现位置，便利词表即可依次计算出每个单词首次出现位置复杂度为O（N×L）L为最长单词长度，N为词表大小

Tire用于排序
题目：对10000个英文名按字典顺序排序
解法：建造Tire树，先序便利即可得到结果。

基本数据结构
type trieNode struct {
	isWord bool//是否单词结尾
	next   map[byte][]*trieNode	//子节点
}

type Trie struct{
	size int	//大小
	root *trieNode	//根节点
}

首先 我们定义了 trie 节点 的基本数据结构,每个节点记录了 所有子节点的指针。 Trie 结构 定义了 大小 和 根节点。

首先 我们构造了一颗 Trie树,初始化Root节点。

//初始化 Trie树
func NewTrie() *Trie{
	node := trieNode{
		isWord: false,
		next:   make(map[byte][]*trieNode,0),
	}
	a := Trie{
		size: 0,
		root: &node,
	}
	return &a
}

结构很简单 就像 一个链表一样 只不过 有点区别 就是 每个节点 都有多个 子节点。

增删改查 我们先实现 增加:
这里面使用了非递归的方式,首先得到 root 下面的 所有节点,然后 遍历 节点

找不到 就新建 找到了 把 当前节点指针cur 改成 下一个节点指针,然后 如果是插入到最后一个字符了 ,就把 isWord 修改成True

//往 节点内 添加内容
func(trie *Trie) Insert(content string){
	node := trieNode{
		isWord: false,
		next:   make(map[byte]*trieNode,0),
	}
	if content == ""{
		panic("error!")
	}
	if  trie.root == nil{
		trie.root = &node
	}
	rootnode := trie.root.next
	var cur *trieNode
	for i,v := range []byte(content){
		var tmpnode *trieNode
		//如果cur为 nil
		if cur == nil{
			if rootnode[v] == nil{
				tmpnode = &trieNode{
					isWord: false,
					next:    make(map[byte]*trieNode,0),
				}

				//如果是字符串 结尾
				if len(content) -1 == i{
					tmpnode.isWord = true
				}
				cur = tmpnode
				rootnode[v] = cur
			}else{
				cur = rootnode[v]
			}

		//如果 cur 已经被初始化
		}else {
			if cur.next[v]  == nil{
				tmpnode = &trieNode{
					isWord: false,
					next:   make(map[byte]*trieNode,0),
				}
				//如果是字符串 结尾
				if len(content) -1 == i{
					tmpnode.isWord = true
				}
				cur.next[v] = tmpnode
				cur = tmpnode
			}else{
				//如果是字符串 结尾
				if len(content) -1 == i{
					cur.isWord = true
				}
				cur = cur.next[v]
			}
		}
	}
}
有了 添加指定字符串,接下来我们再来写一个查找是否包含的方法:

让我们整理下思路,要查找 是否包含指定字符串

先定义一个 指针 记录当前节点
var cur *node
然后遍历 要查找的字符串
for i,key range := str
第一次 当前节点 就直接从根节点拿,
if cur == nil
cur == root.next
否则的话 从 子节点列表 取得 然后 根新为当前节点
else
cur = cur.next[key]

如果 cur 为 空 的话 表明 没找到

然后 如果 找到 字符串最后一个节点,但是字符串没有被 设置为 单词 就认为 没有找到。

上面的步骤其实很简单,比起插入来说。当然 如果用递归 可以跟简介一些。但其实 也差不多。下面给出代码。

func (trie *Trie) Contains(content string) bool{
	if trie.root == nil{
		panic("error nil")
	}
	var cur *trieNode //当前节点指针
	for i,v := range []byte(content){
		if cur == nil{
			//第一次 从root的next子节点获取
			cur = trie.root.next[v]
		}else{
			//当前节点 的next子节点里获取
			cur = cur.next[v]
		}
		//如果 没有 获取到 认为 没有
		if cur == nil{
			return false
		}
		//如果已经 到达了最后一个节点 但是这个节点没有被标记成 单词
		if len(content) -1 ==  i && cur.isWord == false{
			return false
		}

	}
	//如果 上面条件都不满足 则认为 找到了
	return true
}
下面再来写个 遍历所有 Trie树里内容吧

这里我们用 递归 比较方便。 其实就是递归搜索,一直搜索 遍历完 所有 节点 然后 把每个节点记录的 字符 传递到下一个节点,如果是 单词就打印。

func deepSearchx(root *trieNode,deep int,res []byte) {
	if root.isWord{
		//如果 是一个单词 打印
		fmt.Println(string(res))
	}
	for k,v := range root.next{
		//搜索深度
		if deep <= 0{
			return
		}
		tmp := make([]byte,0,0)
		tmp = append(tmp,res...)
		tmp =append(tmp,k)
		//不停递归传递 切片
		deepSearchx(v, deep -1, tmp)
	}
}

下面 是 我测试了下 代码:
在这里插入图片描述

下面顺便实现 下 删除的代码吧

有了上面的代码 要实现这个 是不是跟 玩一样。。。。

分解步骤 只需要两步:
第一步 找到 那个单词的根节点
第二部 判断 是不是单词,如果不是 我们不需要修改返回false 如果 是 单词 修改返回true
这里 我们 参考 ,Contains的代码做一点小修改就好了。
其实 如果 简单的话加上一行删除就好了。但是 如果删除了树 是不是 得回收原来的空间 。所以 我们需要在添加一个方法 递归 把 没用的节点删除了 这个 可以参考Search 的代码 .
在这里插入图片描述
这里用递归的思路
思路是这样的,如果 每个节点 判断 他下面么有挂载单词的节点 了 就认为 下面的 都没用了 那么就设置为 nil。

只要递归玩得好,代码实现 也是很简单的

//将被删除的节点清除掉
func adjust(root *trieNode,ptr *trieNode,key byte,deep int){

	//如果 没有next了 并且 这个节点 没有 记录单词
	if len(root.next) == 0 && root.isWord == false{
		deepSearchforDelete(ptr,nil)
		delete(ptr.next,key)
		return
	}else if len(root.next) == 0{
		return
	}
	//如果 是 单词记录节点
	for k,v := range root.next{
		if deep == 0{
			key = k
		}
		//记录下这个节点
		if root.isWord {
			ptr = root //记录父节点
			key = k//记录子节点 key
		}
		adjust(v,ptr,key,deep + 1)
	}

}

这里每次遇到单词节点 就记录下,如果 到达最后一个节点且最后一个节点 没有 isword 那么 就从 上一个 isword 处的next删除这一段。这里 我们 递归 有 3个参数 一个 不用多说 就是递归子节点,另 2 各参数 是用来保存 上一个 单词节点的 子节点,然后是要删除的key。
在这里插入图片描述

自动索引功能: 你打代码时 不是IDEA 经常 有自动提示吗,还有搜索引擎。

这里我们也实现下吧,其实 还是很简单的

首先是查找节点,然后把节点下所有的 单词打出来 这两个功能在 前面 已经分别实现过了。只要 把它们组合在一起就好啦。

/**
 * Created by @CaomaoBoy on 2020/3/17.
 *  email:<115882934@qq.com>
 */

type trieNode struct {
	isWord bool//是否单词结尾
	next   map[byte]*trieNode	//子节点
}

type Trie struct{
	size int	//大小
	root *trieNode	//根节点
}


//初始化 Trie树
func NewTrie() *Trie{
	node := trieNode{
		isWord: false,
		next:   make(map[byte]*trieNode,26),
	}
	a := Trie{
		size: 0,
		root: &node,
	}
	return &a
}

//如果存在插入
func(trie *Trie) InsertIfContains(content string) bool{
	if !trie.Contains(content){
		trie.Insert(content)
		return true
	}
	return false
}

//往 节点内 添加内容
func(trie *Trie) Insert(content string){
	if content == ""{
		panic("error!")
	}
	if  trie.root == nil{
		node := trieNode{
			isWord: false,
			next:   make(map[byte]*trieNode,0),
		}
		trie.root = &node
	}
	rootnode := trie.root.next
	var cur *trieNode
	for i,v := range []byte(content){
		var tmpnode *trieNode
		//如果cur为 nil
		if cur == nil{
			if rootnode[v] == nil{
				tmpnode = &trieNode{
					isWord: false,
					next:    make(map[byte]*trieNode,0),
				}

				//如果是字符串 结尾
				if len(content) -1 == i{
					tmpnode.isWord = true
					trie.size ++
				}
				cur = tmpnode
				rootnode[v] = cur
			}else{
				cur = rootnode[v]
			}

		//如果 cur 已经被初始化
		}else {
			if cur.next[v]  == nil{
				tmpnode = &trieNode{
					isWord: false,
					next:   make(map[byte]*trieNode,0),
				}
				//如果是字符串 结尾
				if len(content) -1 == i{
					tmpnode.isWord = true
					trie.size ++
				}
				cur.next[v] = tmpnode
				cur = tmpnode
			}else{
				cur = cur.next[v]
				//如果是字符串 结尾
				if len(content) -1 == i{
					cur.isWord = true
					trie.size ++
					return
				}

			}
		}
	}
}

//是否包含 str
func (trie *Trie) Contains(content string) bool{
	if trie.root == nil{
		panic("error nil")
	}
	var cur *trieNode
	for i,v := range []byte(content){
		if cur == nil{
			//第一次 从root的next子节点获取
			cur = trie.root.next[v]
		}else{
			//当前节点 的next子节点里获取
			cur = cur.next[v]
		}
		//如果 没有 获取到 认为 没有
		if cur == nil{
			return false
		}
		//如果已经 到达了最后一个节点 但是这个节点没有被标记成 单词
		if len(content) -1 ==  i && cur.isWord == false{
			return false
		}

	}
	return true
}


//遍历查找所有节点内容
func(trie *Trie) Search(deep int){
	if trie.root == nil{
		panic("root nil")
	}
	//res := make([][]byte,0)
	//deepSearch(trie.root,0,&res)
	//for _,v := range res{
	//	fmt.Println(string(v))
	//}
	deepSearchx(trie.root,deep,nil)
}

深度优先遍历
//func deepSearch(root *trieNode,deep int,res *[][]byte) []byte{
//	if root.isWord{
//		return nil
//	}
//	for k,v := range root.next{
//		tmp := make([]byte,0,0)
//		tmp= append(tmp, k)
//		tmp = append(tmp, deepSearch(v, deep+1, res)...)
//		if deep == 0 {
//			*res = append(*res, tmp)
//			continue
//		}else{
//			fmt.Println(string(tmp))
//			return tmp
//		}
//
//
//	}
//	return nil
//}

//深度优先遍历
func deepSearchx(root *trieNode,deep int,res []byte) {
	if root.isWord{
		fmt.Println(string(res))
	}
	for k,v := range root.next{
		//搜索深度
		if deep == 0 && deep != -1{
			return
		}
		tmp := make([]byte,0,0)
		tmp = append(tmp,res...)
		tmp =append(tmp,k)
		deepSearchx(v, deep -1, tmp)
	}
}

//用来输出显示
func deepSearchforDelete(root *trieNode,res []byte) {
	if len(root.next) == 0{
		fmt.Println("clear:",string(res))
	}
	for k,v := range root.next{
		tmp := make([]byte,0,0)
		tmp = append(tmp,res...)
		tmp =append(tmp,k)
		deepSearchforDelete(v, tmp)
	}
}

//是否包含 str
func (trie *Trie) Delete(content string) bool{
	if trie.root == nil{
		panic("error nil")
	}
	var cur *trieNode
	for i,v := range []byte(content){
		if cur == nil{
			//第一次 从root的next子节点获取
			cur = trie.root.next[v]
		}else{
			//当前节点 的next子节点里获取
			cur = cur.next[v]
		}
		//如果 没有 获取到 认为 没有
		if cur == nil{
			return false
		}
		//如果已经 到达了最后一个节点 但是这个节点没有被标记成 单词
		if len(content) -1 ==  i && cur.isWord == false{
			return false
		}

	}
	cur.isWord = false//找到了 就删除
	trie.Adjust()//删除没用节点
	return true
}


//将被删除的节点清除掉
func(trie *Trie) Adjust(){
	adjust(trie.root,trie.root,0,0)
}
//将被删除的节点清除掉
func adjust(root *trieNode,ptr *trieNode,key byte,deep int){

	//如果 没有next了 并且 这个节点 没有 记录单词
	if len(root.next) == 0 && root.isWord == false{
		deepSearchforDelete(ptr,nil)
		delete(ptr.next,key)
		return
	}else if len(root.next) == 0{
		return
	}
	//如果 是 单词记录节点
	for k,v := range root.next{
		if deep == 0{
			key = k
		}
		//记录下这个节点
		if root.isWord {
			ptr = root //记录父节点
			key = k//记录子节点 key
		}
		adjust(v,ptr,key,deep + 1)
	}

}
//自动提示
func(trie *Trie) Suggess(content string){
	if trie.root == nil{
		panic("error nil")
	}
	var cur *trieNode
	for i,v := range []byte(content){
		if cur == nil{
			//第一次 从root的next子节点获取
			cur = trie.root.next[v]
		}else{
			//当前节点 的next子节点里获取
			cur = cur.next[v]
		}
		//如果 没有 获取到 认为 没有
		if cur == nil{
			fmt.Println("no srarch")
		}
		//如果已经 到达了最后一个节点 但是这个节点没有被标记成 单词
		if len(content) -1 ==  i {
			deepSearchx(cur,-1,nil)
		}

	}

}
func main(){
	t := NewTrie()
	t.Insert("caomao")
	t.Insert("triemap")
	t.Insert("tEST00001")
	t.Insert("tEST0")
	t.Insert("SADASDASDSADASD")
	t.Search(20)
	t.Insert("apple");
	t.Insert("app");
	fmt.Println(t.Contains("app"))
	fmt.Println(t.Contains("tEST0"))
	fmt.Println(t.Contains("apple"))
	t.Delete("app")
	fmt.Println(t.Contains("apple"))
	t.Suggess("tE")


}

初步测试了下,代码应该没什么大问题,由于 随便写的 逻辑应该没问题,代码比较粗糙,随便写的 也没借鉴别人的代码。
在这里插入图片描述

草帽boy7
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
海量数据处理之Tire树（字典树）
田原的学习笔记
08-13 3万+
参考博文：http://blog.csdn.net/v_july_v/article/details/6897097 第一部分、Trie树 1.1、什么是Trie树     Trie树，即字典树，又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：最大限度地减少无谓的字符串比较
Go的数据结构与实现【Trie（前缀树）】
最新发布
ldxxxxll的博客
04-01 896
本文简要介绍了Trie（即前缀树）数据结构，其实现和复杂度分析。
Golang树形结构（实现菜单树）
ellija的博客
04-07 931
【代码】Golang树形结构（实现菜单树）
leetcode字典树算法（特别记录）
qq_43437044的博客
04-14 234
实现前缀树 前缀树是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。 请你实现 Trie 类： Trie() 初始化前缀树对象。 void insert(String word) 向前缀树中插入字符串 word 。 boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。 boolean startsWith(String prefi.
Trie字典树
长期更新Java自学笔记
04-05 491
一、Tire树概念 二、add接口 三、query接口 四、前序遍历接口 五、前缀查询接口 六、删除字符串的接口
trie-dictionary：Patriciaradix树数据结构的实现，存储字典
02-04
trie-dictionary是一个基于Patricia Radix树数据结构的实现，主要用于存储和检索字典中的单词。Patricia Radix树，也称为最小前缀树或PATRICIA树，是一种高效的空间节省的数据结构，用于存储键值对，尤其适用于字符...
Go-trie-单词查找树实现Go实现
08-14
Trie，又称为前缀树或字典树，是一种用于存储动态集合或关联数组的树形数据结构。它的主要特点是通过键的前缀来组织节点，从而快速进行前缀查询和模糊搜索。在Go语言中实现Trie，可以有效地支持字符串集合的增删查改...
HASH(Trie)-.rar_HashTree.h_TRIE_hash树_trie树_字典树
09-20
Trie，又被称为前缀树或字典树，是一种用于存储键值对的数据结构，尤其适用于字符串的查找和管理。 **Trie 树基础知识** Trie 树是一种多叉树，每个节点代表一个字符串的前缀。根节点不包含任何字符，而叶子节点则...
go-succinct-data-structure-trie：Trie的简洁数据结构，用Go编写
02-05
本文将深入探讨一种高效且用途广泛的数据结构——Trie（字典树），以及如何使用Go语言实现一个简洁的Trie数据结构。我们还将讨论Trie在实际应用中的价值，如自动补全功能。 Trie，又称前缀树或字典树，是一种可以...
数据结构实验报告-----trie树
06-05
Trie树，又称为前缀树或字典树，是一种用于存储字符串的有效数据结构。它通过将字符串的字符分解并存储在树的节点中，来实现高效的字符串查找、插入和删除操作。在Trie树中，每个节点代表一个字符串的前缀，叶子节点...
prefixtree：go中的前缀树（trie）实现
02-05
前缀树 prefixtree包实现了一个简单的前缀trie数据结构。 通过树，可以快速搜索与给定前缀唯一匹配的字符串。 该实现允许用户将数据与每个字符串相关联，因此它可以充当一种灵活的键值存储，在该存储中，搜索将以最短的明确键前缀成功进行。 有关godoc格式的API文档，请参见 。 示例：构建前缀树 以下代码将字符串和关联的数据（整数）添加到前缀树。 tree := prefixtree . New () tree . Add ( "apple" , 10 ) tree . Add ( "orange" , 20 ) tree . Add ( "apple pie" , 30 ) tre
golang-- 字典树
hello_bravo_的博客
07-31 490
一.前言 看了百度团队在 infoq 上发表的一篇【如何在秒级完成词表匹配】(https://xie.infoq.cn/article/97b2df7e41456335627ce4cd4)的文章，文章业务背景介绍的很清楚，里面有提到字典树，看到结构图我能明白工作原理，但是总感觉自己处于一种懂与不懂的半懂状态，希望通过写这篇文章我能彻底将字典树闹明白。 二.介绍 概念 字典树是一个存储字符串的树，一个节点的最大子节点数等于字母表的大小。支持在 O(L)时间内的搜索，插入和删除操作，L 是键的长度。 应用场景
Trie树(字典树、前缀树) (小白整理)
licorice1235的博客
06-20 992
此处引路: 字典树(Trie)详解 - Seaway-Fu - 博客园 (cnblogs.com) Trie树（Prefix Tree）介绍_神奕的专栏-CSDN博客_prefix tree Trie树，又叫字典树、前缀树（Prefix Tree）、单词查找树或键树，是一种多叉树结构。（空间换时间） 宽度：范围（例：英文->26） 深度：最长的字母长度加1（root根节点独占顶层） 用处：维护字符串，存储 字典 的一种数据结构。 性质： （1）根节点不包含...
Golang 实现 Trie (前缀树)
terrygmx的博客
03-31 3394
定义 前缀树是N叉树的一种特殊形式。通常来说，一个前缀树是用来存储字符串的。前缀树的每一个节点代表一个字符串（前缀）。每一个节点会有多个子节点，通往不同子节点的路径上有着不同的字符。子节点代表的字符串是由节点本身的原始字符串，以及通往该子节点路径上所有的字符组成的。 下面是前缀树的一个例子： 在上图示例中，我们在节点中标记的值是该节点对应表示的字符串。例如，我们从根节点开始，选择第二条路径 ‘b...
golang 字典树 搜索+sugg 示例
wwhhff11
10-22 1255
package mainimport ( "fmt" "sort" "sync" )type KeyWordKV map[int64]string type CharBeginKV map[string][]*KeyWordTreeNode type PairList []Pairfunc (p PairList) Len() int { return l
算法数据结构——字典树、前缀树、单词查找树（Trie）精讲及python实现
白话机器学习
06-05 1502
字典树（Trie）：又称为前缀树、单词查找树，是一种树形结构。顾名思义，就是一个像字典一样的树。它是字典的一种存储方式。字典中的每个单词在字典树中表现为一条从根节点出发的路径，路径相连的边上的字母连起来就形成对应的字符串。例如下图就是一棵字典树，其中包含有aabcacbaccachbchb这 7 个单词。从图中可以发现，这棵字典树用边来表示字母，从根节点到树上某一节点的路径就代表了一个单词。比如 1 → 2 → 6 → 10 表示的就是单词acc。
Trie树（Prefix Tree）介绍
dbbaq24022的专栏
05-09 508
本文用尽量简洁的语言介绍一种树形数据结构 —— Trie树。 一、什么是Trie树 Trie树，又叫字典树、前缀树（Prefix Tree）、单词查找树 或 键树，是一种多叉树结构。如下图： 上图是一棵Trie树，表示了关键字集合{“a”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”} 。从上图可以归纳...
Trie树进阶：Double-Array Trie原理及状态转移过程详解
weixin_30808575的博客
10-22 794
前言： Trie树本身就是一个很迷人的数据结构，何况是其改进的方案。 在本博客中我会从DAT(Double-Array Tire)的原理开始，并结合其源代码对DAT的状态转移过程进行解析。如果因此你能从我的博客中有所收获或启发，It's my pleasure. 本文链接：http://blog.csdn.net/lemon_tree12138/article/det...
压缩Trie后缀树详解：存储与应用
后缀树是一个特殊的 Trie（字典树或前缀树）变形，它存储了所有字符串的后缀，使得许多字符串处理任务变得更为简单。在基础概念上，后缀树与Trie相似，都是以字符路径表示字符串，但后缀树在某些节点进行了优化，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值