[数据结构]01字典树实现(ts)

已于 2023-01-27 11:16:55 修改
阅读量547 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 typescript
于 2023-01-24 17:50:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Blue_carrot_/article/details/128757311
版权

--目录--

0.简介

本文介绍了字典树以及01字典树的内容，提供了ts的01字典树实现，执行map接口。需要注意，注意，注意，完成后测试的结果，其实效率不如Map<number,number>，只提供参考了解作用，不建议，不建议，不建议实际使用

1.前言（无关内容可跳过）

在做ts练手时，不清楚map的实现，查询是说用哈希表。考虑到只需要number的，我存储的对象key的结构非常适合用01字典树，所以打算写一个01字典树，接口Map<number,number>

2.字典树与01字典树

字典树通常用来查询字符。和我们去查英语字典一样，比如ground单词，首先会查询首字母，g，然后查r，然后再依次查询。这个字符在树中的表现为 （root为根节点）
root->g-> r->o->u->n->d
如果再插入go单词，那树的结构就会变为，第二行o为g的一个子节点
root->g->r->o->u->n->d
______->o
这样我们可以非常方便的在字典中插入和查询字符，而对于其他的对象，我们也可以通过Hash等方式转化成唯一对应的字符串来，做树的插入和执行处理。
01字典树是字典树的一种特例，每个节点只有0和1两个子节点，01101101这种二进制数字就可以很方便快捷的放入字典中

3.字典树实现（完整代码在6）

（1）树节点
对于树节点，我们需要保存一个value值，以及01指针，如果是不需要的保存value（如果不是实现Map而是set），可以将value定义为bool，用于标志是否有在当前结束的key

class Node {
    Value: number | undefined = undefined
    Child0: Node | undefined = undefined
    Child1: Node | undefined = undefined
}

（2）树结构
树首先会有根节点、数量2个基础属性。clear set get delete has，5个基础的查询、删除、增加的函数。最后是Map接口需要实现的一些迭代器可做遍历处理

export class TreeMap implements Map<number, number> {
    private root: Node = new Node()
	private _size: number = 0
	
	// clear set get delete has
	
	// Iterator、forEach、...
}

（3）节点设置与获取
对于clear set get delete has这5个函数。本质其实是对树节点的一种操作和处理，所以我们首先实现基础树节点操作函数setNode和getNode。主要是靠对key的右移来不断确定，节点是0节点或者1节点，去创建或获取对应的节点，直到key全部左移结束。endCheck: number = ~1，就是为了检测是否所有key的所有位都已经遍历结束

private setNode(key: number): Node {
		let cur: Node = this.root
		if (key & 1) {
			if (cur.Child1 == undefined) {
				cur.Child1 = new Node()
			}
			cur = cur.Child1
		} else {
			if (cur.Child0 == undefined) {
				cur.Child0 = new Node()
			}
			cur = cur.Child0
		}
		while (key & -2) {
			// -2 = ~1
			key = key >>> 1
			// console.log("key:" + key)
			// console.log("node1:" + (key & 1))
			if (key & 1) {
				if (cur.Child1 == undefined) {
					cur.Child1 = new Node()
				}
				cur = cur.Child1
			} else {
				if (cur.Child0 == undefined) {
					cur.Child0 = new Node()
				}
				cur = cur.Child0
			}
		}
		return cur
	}


	private getNode(key: number): Node | undefined {
		let cur: Node | undefined = this.root
		if (key & 1) {
			cur = cur.Child1
		} else {
			cur = cur.Child0
		}
		while (key & -2) {
			// -2 = ~1
			key = key >>> 1
			if (cur == undefined) {
				break
			}
			if (key & 1) {
				cur = cur.Child1
			} else {
				cur = cur.Child0
			}
		}
		return cur
	}

然后再此基础上就能，很方便写出五个函数。get是获取节点，如果有就返回节点保存的数值。set就是设置节点以及数值。has就是获取节点，返回是否获取到。delete是获取节点并删除数值。clear就可以简单，直接将root的01字节点都置空，赋值undefined就可，这样数据就被清空了。如下

    
	public clear(): void {
		this.root.Child0 = undefined
		this.root.Child1 = undefined
		this._size = 0
	}

	public get(key: number): number | undefined {
		return this.getNode(key)?.Value
	}

	public has(key: number): boolean {
		return this.getNode(key)?.Value != undefined
	}

	public set(key: number, value: number): this {
		this.setNode(key).Value = value
		this._size++
		return this
	}

	public delete(key: number): boolean {
		let node = this.setNode(key)
		if (node) {
			this._size--
			node.Value = undefined
			return true
		} else {
			return false
		}
	}

（4）节点遍历
做完前面的操作，map基本也就做完了。本质map并不适合用于做遍历操作，如果有数据需要遍历还是使用数组合适。当然还是会有需要遍历的情况，这个时候其实就和其他的基本一样，用简单的bfs或者dfs就可以了（也只会简单的，苦笑）。
Iterator、forEach，这两种Foreach的话就是每次遍历都调用一下函数就好了。但对于Iterator迭代器来说，需要去继承原IterableIterator的一个接口，这个接口主要是next需要实现，throw和return等处理可以可以补继承。对于next其实是返回包含数据以及是否遍历完成的一个接口，如果还没遍历结束，done就是false，同时value就是数据，如果遍历结束，那么done就为true。就可以不断next来达到迭代的效果。
到这里可以完全实现一个Map接口的01字典树了，关于遍历的代码看就再看最后完整代码部分吧，还挺多的。

4.测试与效率对比

（1）测试
做完之后还是要测试一下是否可以用，写了一个脚本简单测试一下

console.log("# TestTreeEnable")
let tree = new TreeMap()
console.log("[set]")
tree.set(1, 1) // tree.set(-1, 10000)
tree.set(2, 10000)
tree.set(2000, 10000)
console.log("[get]")
console.log(tree.get(1))
console.log(tree.get(2))
console.log(tree.get(2000))
console.log(tree.get(-2000))
console.log("[has]")
console.log(tree.has(1))
console.log(tree.has(2))
console.log(tree.has(2000))
console.log(tree.has(-2000))
console.log("[delete]")
console.log(tree.delete(2000))
console.log(tree.has(2000))
tree.set(2000, 10000)
console.log("[forEach]")
tree.forEach((value: number, key: number, map: Map<number, number>) => {
    console.log(value, key)
})
console.log("[entries]")
console.log(Array.from(tree.entries()))
console.log("[keys]")
console.log(Array.from(tree.keys()))
console.log("[values]")
console.log(Array.from(tree.values()))
console.log("[clear]")
tree.clear()
console.log(Array.from(tree.entries()))
console.log("[tree]")
console.log(tree)

执行结果，来说还是挺好的，完成了目标（其实改了挺多bug）

TestTree.js:11 # TestTreeEnable
TestTree.js:12 [set]
TestTree.js:16 [get]
TestTree.js:17 1
TestTree.js:18 10000
TestTree.js:19 10000
TestTree.js:20 undefined
TestTree.js:21 [has]
TestTree.js:22 true
TestTree.js:23 true
TestTree.js:24 true
TestTree.js:25 false
TestTree.js:26 [delete]
TestTree.js:27 true
TestTree.js:28 false
TestTree.js:30 [forEach]
TestTree.js:32 1 1
TestTree.js:32 10000 2
TestTree.js:32 10000 2000
TestTree.js:34 [entries]
TestTree.js:35 (3) [Array(2), Array(2), Array(2)]
TestTree.js:36 [keys]
TestTree.js:37 (3) [1, 2, 2000]
TestTree.js:38 [values]
TestTree.js:39 (3) [1, 10000, 10000]
TestTree.js:40 [clear]
TestTree.js:42 []
TestTree.js:43 [tree]
TestTree.js:44 TreeMap {root: Node, _size: 0, Symbol(Symbol.toStringTag): "TreeNode"}

（2）效率测试
测试的效率主要是看set，get，delete，和has的效率对比，所以写的脚本如下

console.log("# TestEfficiency")
let count = 20000
let cur = new Date().getTime()
let last = 0

for (let i = 0; i < count; i++) {
    map.set(i, i)
}
last = cur
cur = new Date().getTime()
console.log("[set]time:" + (cur - last))

for (let i = 0; i < count; i++) {
    map.get(i)
}
last = cur
cur = new Date().getTime()
console.log("[get]time:" + (cur - last))

for (let i = 0; i < count; i++) {
    map.has(i)
}
last = cur
cur = new Date().getTime()
console.log("[has]time:" + (cur - last))

for (let i = 0; i < count; i++) {
    map.delete(i)
}
last = cur
cur = new Date().getTime()
console.log("[delete]time:" + (cur - last))

首先是map<number,number>的效率

TestTree.js:48 # TestEfficiency
TestTree.js:57 [set]time:2
TestTree.js:63 [get]time:1
TestTree.js:69 [has]time:1
TestTree.js:75 [delete]time:2

然后是自己写的字典树的效率

TestTree.js:48 # TestEfficiency
TestTree.js:57 [set]time:8
TestTree.js:63 [get]time:5
TestTree.js:69 [has]time:3
TestTree.js:75 [delete]time:4

糟糕，是被比下去的感觉（苦笑），数量提升到2000000，自己写的字典各项时间差距在4-7倍左右。虽然不知道是map怎么去实现的，但效率确实很好，这样我这个算是白写了，只能说了解了一下字典树的处理了

5.结尾（结束啦感谢观看）

注意，仅供实践参考，在实际项目使用需谨慎。这种基础结构，写出错或者有效率问题，对开发影响很大。

6.完整代码

/** 效率不如原本的Map，内存开销未知，存在一个存的数不是正数的问题*/
export class TreeMap implements Map<number, number> {
	private root: Node = new Node()
	private _size: number = 0

	public get size(): number {
		return this._size
	}

	private setNode(key: number): Node {
		let cur: Node = this.root
		if (key & 1) {
			if (cur.Child1 == undefined) {
				cur.Child1 = new Node()
			}
			cur = cur.Child1
		} else {
			if (cur.Child0 == undefined) {
				cur.Child0 = new Node()
			}
			cur = cur.Child0
		}
		while (key & -2) {
			// -2 = ~1
			key = key >>> 1
			// console.log("key:" + key)
			// console.log("node1:" + (key & 1))
			if (key & 1) {
				if (cur.Child1 == undefined) {
					cur.Child1 = new Node()
				}
				cur = cur.Child1
			} else {
				if (cur.Child0 == undefined) {
					cur.Child0 = new Node()
				}
				cur = cur.Child0
			}
		}
		return cur
	}

	private getNode(key: number): Node | undefined {
		let cur: Node | undefined = this.root
		if (key & 1) {
			cur = cur.Child1
		} else {
			cur = cur.Child0
		}
		while (key & -2) {
			// -2 = ~1
			key = key >>> 1
			if (cur == undefined) {
				break
			}
			if (key & 1) {
				cur = cur.Child1
			} else {
				cur = cur.Child0
			}
		}
		return cur
	}

	public clear(): void {
		this.root.Child0 = undefined
		this.root.Child1 = undefined
		this._size = 0
	}

	public get(key: number): number | undefined {
		return this.getNode(key)?.Value
	}

	public has(key: number): boolean {
		return this.getNode(key)?.Value != undefined
	}

	public set(key: number, value: number): this {
		this.setNode(key).Value = value
		this._size++
		return this
	}

	public delete(key: number): boolean {
		let node = this.setNode(key)
		if (node) {
			this._size--
			node.Value = undefined
			return true
		} else {
			return false
		}
	}

	public forEach(callbackfn: (value: number, key: number, map: Map<number, number>) => void, thisArg?: any): void {
		let iterator = new NodeIterableIterator(this.root)
		let cur = iterator.next()
		if (thisArg == undefined) {
			thisArg = this
		}
		while (!cur.done) {
			callbackfn.call(thisArg, cur.value[1], cur.value[0], this)
			cur = iterator.next()
			// console.log(cur)
		}
	}

	public entries(): IterableIterator<[number, number]> {
		return new NodeIterableIterator(this.root)
	}

	public keys(): IterableIterator<number> {
		return new KeyIterableIterator(this.root)
	}

	public values(): IterableIterator<number> {
		return new ValueIterableIterator(this.root)
	}

	public [Symbol.iterator](): IterableIterator<[number, number]> {
		return new NodeIterableIterator(this.root)
	}

	public [Symbol.toStringTag]: string = "TreeNode"
}

class Node {
	Value: number | undefined = undefined
	Child0: Node | undefined = undefined
	Child1: Node | undefined = undefined
}

class NodeIterableIterator implements IterableIterator<[number, number]> {
	private root: Node
	private nodes: Array<Node>
	private keys: Array<number>
	private deeps: Array<number>

	public constructor(root: Node) {
		this.root = root
		this.nodes = new Array<Node>()
		this.keys = new Array<number>()
		this.deeps = new Array<number>()
		this.pushChild(this.root, 0, -1)
	}

	public [Symbol.iterator](): IterableIterator<[number, number]> {
		return new NodeIterableIterator(this.root)
	}

	public next(): IteratorResult<[number, number]> {
		let cur = this.nodes.pop()
		let key = this.keys.pop() as number
		let deep = this.deeps.pop() as number
		let result: IteratorResult<[number, number]> | undefined
		while (cur != undefined) {
			this.pushChild(cur, key, deep)
			if (cur.Value == undefined) {
				cur = this.nodes.pop()
				key = this.keys.pop() as number
				deep = this.deeps.pop() as number
			} else {
				result = {
					done: false,
					value: [key, cur.Value],
				}
				break
			}
		}
		if (result == undefined) {
			result = {
				done: true,
				value: [0, 0],
			}
		}
		return result
	}

	public return(value: any): IteratorResult<[number, number]> {
		console.log("return:" + value)
		let result: IteratorResult<[number, number]> = {
			done: true,
			value: [0, 0],
		}
		return result
	}

	private pushChild(node: Node, key: number, deep: number) {
		deep++
		if (node.Child0 != undefined) {
			this.nodes.push(node.Child0)
			this.deeps.push(deep)
			this.keys.push(key)
		}

		if (node.Child1 != undefined) {
			this.nodes.push(node.Child1)
			this.deeps.push(deep)
			this.keys.push(key + (1 << deep))
		}
	}
}

class ValueIterableIterator implements IterableIterator<number> {
	// value 也可以通过Node做一下装饰器获得
	// 但考虑到不需要key所以使用了放弃了，更加节省内存提高效率

	private root: Node
	private nodes: Array<Node>

	public constructor(root: Node) {
		this.root = root
		this.nodes = new Array<Node>()
		this.pushChild(this.root)
	}

	public [Symbol.iterator](): IterableIterator<number> {
		return new ValueIterableIterator(this.root)
	}

	public next(): IteratorResult<number> {
		let cur = this.nodes.pop()
		let result: IteratorResult<number> | undefined
		while (cur != undefined) {
			this.pushChild(cur)
			if (cur.Value != undefined) {
				result = {
					done: false,
					value: cur.Value,
				}
				break
			} else {
				cur = this.nodes.pop()
			}
		}
		if (result == undefined) {
			result = {
				done: true,
				value: 0,
			}
		}
		return result
	}

	private pushChild(node: Node) {
		if (node.Child0 != undefined) {
			this.nodes.push(node.Child0)
		}
		if (node.Child1 != undefined) {
			this.nodes.push(node.Child1)
		}
	}
}

class KeyIterableIterator implements IterableIterator<number> {
	// Key的功能和Node的基本一致所以就不更改了
	// 做成一个装饰器，虽然会损失一点性能

	private nodeIterator: NodeIterableIterator
	private root: Node

	public constructor(root: Node) {
		this.root = root
		this.nodeIterator = new NodeIterableIterator(root)
	}

	[Symbol.iterator](): IterableIterator<number> {
		return new KeyIterableIterator(this.root)
	}

	next(): IteratorResult<number> {
		let result: IteratorResult<number>
		let cur = this.nodeIterator.next()
		if (cur.done) {
			result = {
				done: true,
				value: 0,
			}
		} else {
			result = {
				done: false,
				value: cur.value[0],
			}
		}
		return result
	}
}
Blue_carrot_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Dictionary.ts
03-06
授权申明 本软件在许可下提供，但仅提供用于非商业目的。 免责申明 本软件及本软件所使用的有一些网上代码及资源以研究或个人/学习交流为目的，声称原公司（作者）允许不要使用任何商业用途，如需商业请自行联系原公司（作者） ）商议商用方案！不要擅自私自商用！否则后果自负！ 本软件及作者不承担因使用，分发，再开发等所带来的替代或其他法律责任。 系统要求 本软件总体只在Win10 20H2 x64测试运行过，理论上可以运行在Linux或Mac OS上，但未测试 安装 安装node.js 推荐安装node-v15.4.0-x64.msi 安装cnpm 输入以下命令 npm install -g cnpm --registry=https://registry.npm.taobao.org 输入cnpm -v输入是否正常 cnpm -v 解决cnpm报错 如果报错：无法加载文件％AppData％\ Roa
Python数据结构与算法之字典树实现方法示例
09-21
字典树（Trie Tree），又称前缀树或字典树，是一种特殊的树形数据结构，主要用于存储关联数组，尤其是字符串。这种数据结构允许我们快速查找具有相同前缀的字符串，例如在搜索引擎中进行关键词匹配或统计词频。 在...
【Web系列二十三】Ts下实现字典
Nicholson的博客
08-17 805
ts下没有原生的字典类，这里手动实现一个类型安全的字典。
字典树（前缀树）1-0字典树
m0_73846167的博客
11-05 36
字典树用于查找和插入一串字符（最常见的字典树便是搜索引擎：例如当在百度搜索莲花楼时：随之出来的会有《莲花楼演员表》《莲花楼演唱会》，搜索引擎将莲花楼当作字符串的前缀，将搜索到的完整字符串显现出来）
js ts 字典 元祖 访问修饰符
bs521521的博客
12-15 383
【代码】js ts 字典 元祖 访问修饰符。
TypeScript 字典
LuckyJoey的博客
03-05 1018
/** * 字典类 * */ namespace Core { export class Dictionary { items: Object; constructor() { this.items = {}; } has(key: any): boolean { return this.items.hasOwnProperty(key); } ...
常见的字典数据结构实现
07-27
本篇文章将深入探讨几种常见的字典数据结构实现，包括二叉搜索树（Binary Search Tree）、红黑树（Red-Black Tree）、平衡树（Balanced Tree）以及跳跃列表（Skip List），同时也将提及有序数组（Sorted Array）作为...
集美大学数据结构课程设计 字典树.zip
最新发布
12-28
集美大学数据结构课程设计 字典树 集美大学数据结构课程设计 字典树 集美大学数据结构课程设计 字典树 集美大学数据结构课程设计 字典树 集美大学数据结构课程设计 字典树 集美大学数据结构课程设计 字典树 集美大学...
数据结构课设三：实现字典查询
04-24
在对树形结构的了解逐渐加深后，会接触到树的更...平衡二叉树便是其中一例，实现字典查询功能可以用平衡二叉树来实现，也可以用哈希表等数据结构实现，该代码便是用平衡二叉树实现。代码在vs2017中可运行，仅供参考。
17.Oracle杂记——数据字典dba_ts_quotas
badman250的专栏
10-29 1636
17.Oracle杂记——数据字典dba_ts_quotas 视图dba_ts_quotas:所有用户表空间限额      描述如下： sys@PDB1> desc dba_ts_quotas  Name                                                                                             
typescript-collections:一组用于 TypeScript 的通用类型集合
08-05
它是一个用 TypeScript 编写的完整的、经过充分测试的数据结构库。 此项目使用 TypeScript 泛型，因此您需要 TS 0.9 及更高版本。 包含的数据结构 链表 字典 - 多词典 关联词典 默认字典 - 二叉搜索树 键值对的二叉搜索树 堆 队列 设置 - 包 二叉堆 优先队列 它还包括几个用于操作数组的函数。 用法 npm install typescript-collections --save ES6 import ... from import * as Collections from 'typescript-collections' ; 或 TypeScript import ... require import Collections = require ( 'typescript-collections' ) ; 或 JavaScript va
TS保存数据的一种方式
wulong710的专栏
08-22 1132
export interface IData { yourName: string; yourAge: number; books: number[]; } export class GameData { private static info: IData;// public static init() { console.log("info = ", GameData.info); GameData.info = JSON.p.
数据结构-树状数组-定义和模板
skyline的分享专栏
01-17 459
草稿 我全忘了之后重新复习 哪些对我有点醒作用 树状数组c[i]的含义： c[i]覆盖的长度是lowbit(i)，存储前lowbit(i)个整数之和。 lowbit(x)是取x的二进制的 最右边的1和它右边所有的0 例如 lowbit(8) = 8D = 1000B 树形图 区间和查询 循环从大到小 [x, 0) >0 i-=lowbit(i) 减去最右边的1 从右至左（16-...
tree树形结构数据用Ts导出Excel合并单元格
SUN981125的博客
03-02 565
tree树形结构数据用Ts导出Excel合并单元格
typescript中使用字典Dictionary
热门推荐
bingheliefeng的专栏
05-27 4万+
//key为string , value为number var map: { [key: string]: number; } = { "t" : 3, "o" : 5, "g" :10 }; for(let k in map){ egret.log(map[k]); }
TypeScript语言使用Dictionary
康的博客
10-31 5206
前言：ts语言其实并没用提供直接的字典关键字让我们直接使用字典，不过字典的原理是key —value键值对，我们据此实现ts的字典功能 export class Player {         public userid:number;         public score:number;         public name:string;         public on...
字典内置函数&方法
qq_34798326的博客
01-11 327
Python字典包含了以下内置函数： 序号 函数及描述 1 cmp(dict1, dict2) 比较两个字典元素。 2 len(dict) 计算字典元素个数，即键的总数。 3 str(dict) 输出字典可打印的字符串表示。 4 type(variable) 返回输入的变量类型，如果变量
TS — Map 对象, Map与字典的区别
sjsjsjsj1010的博客
04-04 6379
TS — Map 对象， Map与字典的区别
TS常用的类型
Frank---7的博客
05-20 1318
// 也可以直接使用字面量进行类型声明 let a: 10; a = 10; // 可以使用 | 来连接多个类型（联合类型） let b: "male" | "female"; b = "male"; b = "female"; let c: boolean | string; c = true; c = 'hello'; // any 表示的是任意类型，一个变量设置类型为any后相当于对该变量关闭了TS的类型检测 // 使用TS时，不建议使用any类型 // let d: any; // 声明变量
c++数据结构字典树
11-19
字典树（Trie）是一种树形结构，用于高效地存储和检索字符串数据集中的键值。它的核心思想是利用字符串之间的公共前缀，将重复的前缀合并在一起，从而减少存储空间和查询时间。下面是一个简单的C++实现： ```c++ #include <iostream> #include <unordered_map> using namespace std; class TrieNode { public: unordered_map<char, TrieNode*> children; bool is_word; TrieNode() { is_word = false; } ~TrieNode() { for (auto& child : children) { delete child.second; } } }; class Trie { public: Trie() { root = new TrieNode(); } ~Trie() { delete root; } void insert(string word) { TrieNode* node = root; for (char c : word) { if (!node->children.count(c)) { node->children[c] = new TrieNode(); } node = node->children[c]; } node->is_word = true; } bool search(string word) { TrieNode* node = root; for (char c : word) { if (!node->children.count(c)) { return false; } node = node->children[c]; } return node->is_word; } bool startsWith(string prefix) { TrieNode* node = root; for (char c : prefix) { if (!node->children.count(c)) { return false; } node = node->children[c]; } return true; } private: TrieNode* root; }; int main() { Trie trie; trie.insert("apple"); cout << trie.search("apple") << endl; // 输出：1 cout << trie.search("app") << endl; // 输出：0 cout << trie.startsWith("app") << endl; // 输出：1 trie.insert("app"); cout << trie.search("app") << endl; // 输出：1 return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值