golang实现AVL树算法 【AVL树】【算法】【golang】

已于 2022-01-20 11:41:21 修改
阅读量585 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： golang 文章标签： golang 算法 开发语言
于 2022-01-19 16:28:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43923045/article/details/122584052
本文介绍了一种使用Golang实现的AVL树算法，包括基本的插入、删除、旋转等操作，并通过具体示例展示了如何利用AVL树解决存在重复元素III的问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

golang avl树算法

package main

import (
	"fmt"
	"strings"
)



func abs(val int) int {
	if val < 0 { return -val }
	return val
}




var nodeCnt int

type Node struct {
	val         int
	left, right *Node
	h           int
}

func max(i, j int) int {
	if i > j {
		return i
	}
	return j
}
func min(i, j int) int {
	if i < j {
		return i
	}
	return j
}
func (node *Node) height() int {
	if node == nil {
		return 0
	}
	return node.h
}

// 对节点y进行向右旋转操作，返回旋转后新的根节点x
//        y                              x
//       / \                           /   \
//      x   T4     向右旋转 (y)        z     y
//     / \       - - - - - - - ->    / \   / \
//    z   T3                       T1  T2 T3 T4
//   / \
// T1   T2
func adjustLeft(y *Node) *Node {
	if y == nil {
		panic("invalid node")
	}
	var x = y.left
	y.left = x.right
	x.right = y
	y.h = max(y.left.height(), y.right.height()) + 1
	x.h = max(x.left.height(), x.right.height()) + 1
	return x

}

/*
	  y                =>          x
   a      x                      y
        b    c                     xxxxxx
           e   d
*/

// right 重，左旋转
func adjustRight(y *Node) *Node {
	if y == nil {
		panic("invalid node")
	}
	var x = y.right
	// x  >= y
	y.right = x.left
	x.left = y
	y.h = max(y.left.height(), y.right.height()) + 1
	x.h = max(x.left.height(), x.right.height()) + 1
	return x

}

// left 重， left.right 重
func adjustLeftRight(node *Node) *Node {
	//左子树的右节点
	node.left = adjustRight(node.left)
	// left left rotation
	return adjustLeft(node)
}

// right 重，并且 right.left 重
func adjustRightLeft(node *Node) *Node {
	node.right = adjustLeft(node.right)

	return adjustRight(node)
}

func insertNode(node *Node, val int) *Node {
	if node == nil {
		nodeCnt++
		return &Node{val: val, h: 1}
	}
	switch {
	case node.val < val:
		// current < val , to right find
		node.right = insertNode(node.right, val)
		// 插入 右边节点，只能是  height(right) >= height(left)
		if node.right.height()-node.left.height() == 2 {
			// adjust right
			if val > node.right.val {
				// right 重，right.right也重
				node = adjustRight(node)
			} else {
				// right 重，right.left重
				node = adjustRightLeft(node)
			}
		}
	case node.val > val:
		// 去插入到左边节点
		node.left = insertNode(node.left, val)
		if node.left.height()-node.right.height() == 2 {
			// 判断 left.val < val
			if node.left.val > val {
				// left重，left.left也重， 处理 ll
				node = adjustLeft(node)
			} else {
				//left, left.right重
				node = adjustLeftRight(node)
			}
		}
	default:
		//log.Println("exists")

	}
	node.h = max(node.left.height(), node.right.height()) + 1
	return node
}
func findMinNode(node *Node) *Node {
	if node == nil {
		return nil
	}
	for node.left != nil {
		node = node.left
	}
	return node
}
func findMaxNode(node *Node) *Node {
	if node == nil {
		return nil
	}
	for node.right != nil {
		node = node.right

	}
	return node
}

// >= val => 天花板，下边界
func findFloorNode(node *Node, val int) *Node {
Loop:
	for node != nil {
		if node.val == val {
			//return node
			break Loop
		} else if node.val < val {
			// to right
			node = node.right
		} else {
			//to left, if left is nil , return current Node
			//node = node.right
			left := findFloorNode(node.left, val)
			if left != nil && left.val < node.val {
				node = left
			}
			break Loop
			// left is small

		}
	}
	return node
}

// <= val 的最大节点
func findCeilNode(node *Node, val int) *Node {
	// 早到 比 val 小的
	if node == nil {
		return nil
	}
find:
	for node != nil {
		if node.val == val {
			break find
		} else if node.val > val {
			// 比他大 ， 左边 的 可能也比他大
			node = node.left
		} else {
			// node.val < val , to right find  <= val first
			var s = findCeilNode(node.right, val)
			if s != nil && s.val > node.val {
				node = s
			}
			break find

		}
	}
	return node
}
func adjustNode(node *Node) *Node {
	// adjust node
	switch node.left.height() - node.right.height() {
	case 2:
		// left 重
		//var left = node.left
		if node.left.height() > node.right.height() {
			node = adjustLeft(node)
		} else {
			node = adjustLeftRight(node)
		}

	case -2:
		if node.right.right.height() > node.right.left.height() {
			// right right 重
			node = adjustRight(node)
		} else {
			node = adjustRightLeft(node)
		}

	}
	return node
}

func deleteNode(node *Node, val int) *Node {
	if node == nil {
		return nil
	}
	if node.val < val {
		node.right = deleteNode(node.right, val)
	} else if node.val > val {
		// to left delete
		node.left = deleteNode(node.left, val)
	} else {
		// delete current
		nodeCnt--
		if node.left == nil {
			if node.right == nil {
				//delete one
				node = nil
			} else {
				// return node.right
				node = node.right
			}
		} else {
			if node.right == nil {
				//node.left != nil
				node = node.left
			} else {
				// node.left != nil  node.right !=nil
				//前驱节点
				var nextNode = findMinNode(node.right)
				node.val = nextNode.val
				//委托 删除 minNode ，  这边不好删除，直接 取巧 ，覆盖值即可
				node.right = deleteNode(node.right, nextNode.val)
			}
		}
	}
	if node != nil {
		//跳转高度
		node.h = max(node.left.height(), node.right.height()) + 1
		node = adjustNode(node)
	}
	return node
}

//func rightRotationNode(node *Node) *Node {
//	var right = node.right
//	node.right = node.left
//	node
//}
func ascPrint(node *Node) {
	if node == nil {
		return
	}
	ascPrint(node.left)
	fmt.Printf("%v,", node.val)
	ascPrint(node.right)
}

func (o *Node)String() string {
	return fmt.Sprintf("%v ",o.val)
}
func (o *Node) draw(prefix string, isTail bool, str *strings.Builder) {
	if o.right != nil {
		newPrefix := prefix
		if isTail {
			newPrefix += "│   "
		} else {
			newPrefix += "    "
		}
		o.right.draw(newPrefix, false, str)
	}
	str.WriteString(prefix)
	if isTail {
		str.WriteString("└── ")
	} else {
		str.WriteString( "┌── ")
	}
	str.WriteString(o.String() + "\n")
	if o.left != nil {
		newPrefix := prefix
		if isTail {
			newPrefix += "    "
		} else {
			newPrefix += "│   "
		}
		o.left.draw(newPrefix, true, str)
	}
}

func main() {
	var root *Node
	root = insertNode(root,1)
	root = insertNode(root,1)
	root = insertNode(root,1)
	root = insertNode(root,1)
	for i:=88;i>=1;i-- {
		root = insertNode(root,i)
	}
	var s strings.Builder
	root.draw("  @        ", false, &s)
	fmt.Println(s.String())
}

例题

220. 存在重复元素 III

Difficulty: **给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得 abs(nums[i] - nums[j]) <= t ，同时又满足 abs(i - j) <= k 。 如果存在则返回 true，不存在返回 false。 示例 1： 输入：nums = [1,2,3,1], k = 3, t = 0 输出：true 示例 2： 输入：nums = [1,0,1,1], k = 1, t = 2 输出：true 示例 3： 输入：nums = [1,5,9,1,5,9], k = 2, t = 3 输出：false 提示： 0 <= nums.length <= 2 * 104 -231 <= nums[i] <= 231 - 1 0 <= k <= 104 0 <= t <= 231 - 1 **

给你一个整数数组 nums 和两个整数 k 和 t 。请你判断是否存在 两个不同下标 i 和 j，使得 abs(nums[i] - nums[j]) <= t ，同时又满足 abs(i - j) <= k。

如果存在则返回 true，不存在返回 false。

示例 1：

输入：nums = [1,2,3,1], k = 3, t = 0
输出：true

示例 2：

输入：nums = [1,0,1,1], k = 1, t = 2
输出：true

示例 3：

输入：nums = [1,5,9,1,5,9], k = 2, t = 3
输出：false

提示：

  • 0 <= nums.length <= 2 * 10<sup>4</sup>
  • -2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1
  • 0 <= k <= 10<sup>4</sup>
  • 0 <= t <= 2<sup>31</sup> - 1
Solution

Language: ****

func containsNearbyAlmostDuplicate(nums []int, k int, t int) bool {
   var root *Node
   
    
   //类似滑动窗口的算法
   for i,n := 0,len(nums);i<n;i++ {
      
       // 找到  
       //  abs(nums[i] - nums[x]) <= t  =>  找上界 找小的 =》  nums[i] -t  <=  x <= nums[i] + t
       
       var node = findFloorNode(root,nums[i] - t)
       if node != nil &&  node.val <= nums[i] + t {
           //满足   nums[i] -t <=  node.val <=  nums[i] + t => 即满足  表达式
           return true 
       }
       
       root = insertNode(root,nums[i])

       // then can not find 
       if i>=k {
           //删除划出窗口的元素
           root = deleteNode(root,nums[i-k])
       }

   }
   return false 
}

func abs(val int) int {
   if val < 0 { return -val }
   return val 
}




var nodeCnt int

type Node struct {
   val         int
   left, right *Node
   h           int
}

func max(i, j int) int {
   if i > j {
   	return i
   }
   return j
}
func min(i, j int) int {
   if i < j {
   	return i
   }
   return j
}
func (node *Node) height() int {
   if node == nil {
   	return 0
   }
   return node.h
}

// 对节点y进行向右旋转操作，返回旋转后新的根节点x
//        y                              x
//       / \                           /   \
//      x   T4     向右旋转 (y)        z     y
//     / \       - - - - - - - ->    / \   / \
//    z   T3                       T1  T2 T3 T4
//   / \
// T1   T2
func adjustLeft(y *Node) *Node {
   if y == nil {
   	panic("invalid node")
   }
   var x = y.left
   y.left = x.right
   x.right = y
   y.h = max(y.left.height(), y.right.height()) + 1
   x.h = max(x.left.height(), x.right.height()) + 1
   return x
    
}

/*
     y                =>          x
  a      x                      y
       b    c                     xxxxxx
          e   d
*/

// right 重，左旋转
func adjustRight(y *Node) *Node {
   if y == nil {
   	panic("invalid node")
   }
   var x = y.right
   // x  >= y
   y.right = x.left
   x.left = y
   y.h = max(y.left.height(), y.right.height()) + 1
   x.h = max(x.left.height(), x.right.height()) + 1
   return x

}

// left 重， left.right 重
func adjustLeftRight(node *Node) *Node {
   //左子树的右节点
   node.left = adjustRight(node.left)
   // left left rotation
   return adjustLeft(node)
}

// right 重，并且 right.left 重
func adjustRightLeft(node *Node) *Node {
   node.right = adjustLeft(node.right)

   return adjustRight(node)
}

func insertNode(node *Node, val int) *Node {
   if node == nil {
   	nodeCnt++
   	return &Node{val: val, h: 1}
   }
   switch {
   case node.val < val:
   	// current < val , to right find
   	node.right = insertNode(node.right, val)
   	// 插入 右边节点，只能是  height(right) >= height(left)
   	if node.right.height()-node.left.height() == 2 {
   		// adjust right
   		if val > node.right.val {
   			// right 重，right.right也重
   			node = adjustRight(node)
   		} else {
   			// right 重，right.left重
   			node = adjustRightLeft(node)
   		}
   	}
   case node.val > val:
   	// 去插入到左边节点
   	node.left = insertNode(node.left, val)
   	if node.left.height()-node.right.height() == 2 {
   		// 判断 left.val < val
   		if node.left.val > val {
   			// left重，left.left也重， 处理 ll
   			node = adjustLeft(node)
   		} else {
   			//left, left.right重
   			node = adjustLeftRight(node)
   		}
   	}
   default:
   	//log.Println("exists")

   }
   node.h = max(node.left.height(), node.right.height()) + 1
   return node
}
func findMinNode(node *Node) *Node {
   if node == nil {
   	return nil
   }
   for node.left != nil {
   	node = node.left
   }
   return node
}
func findMaxNode(node *Node) *Node {
   if node == nil {
   	return nil
   }
   for node.right != nil {
   	node = node.right

   }
   return node
}

// >= val => 天花板，下边界
func findFloorNode(node *Node, val int) *Node {
Loop:
   for node != nil {
   	if node.val == val {
   		//return node
   		break Loop
   	} else if node.val < val {
   		// to right
   		node = node.right
   	} else {
   		//to left, if left is nil , return current Node
   		//node = node.right
   		left := findFloorNode(node.left, val)
   		if left != nil && left.val < node.val {
   			node = left
   		}
   		break Loop
   		// left is small

   	}
   }
   return node
}

// <= val 的最大节点
func findCeilNode(node *Node, val int) *Node {
   // 早到 比 val 小的
   if node == nil {
   	return nil
   }
find:
   for node != nil {
   	if node.val == val {
   		break find
   	} else if node.val > val {
   		// 比他大 ， 左边 的 可能也比他大
   		node = node.left
   	} else {
   		// node.val < val , to right find  <= val first
   		var s = findCeilNode(node.right, val)
   		if s != nil && s.val > node.val {
   			node = s
   		}
   		break find

   	}
   }
   return node
}
func adjustNode(node *Node) *Node {
   // adjust node
   switch node.left.height() - node.right.height() {
   case 2:
   	// left 重
   	//var left = node.left
   	if node.left.height() > node.right.height() {
   		node = adjustLeft(node)
   	} else {
   		node = adjustLeftRight(node)
   	}

   case -2:
   	if node.right.right.height() > node.right.left.height() {
   		// right right 重
   		node = adjustRight(node)
   	} else {
   		node = adjustRightLeft(node)
   	}

   }
   return node
}

func deleteNode(node *Node, val int) *Node {
   if node == nil {
   	return nil
   }
   if node.val < val {
   	node.right = deleteNode(node.right, val)
   } else if node.val > val {
   	// to left delete
   	node.left = deleteNode(node.left, val)
   } else {
   	// delete current
   	nodeCnt--
   	if node.left == nil {
   		if node.right == nil {
   			//delete one
   			node = nil
   		} else {
   			// return node.right
   			node = node.right
   		}
   	} else {
   		if node.right == nil {
   			//node.left != nil
   			node = node.left
   		} else {
   			// node.left != nil  node.right !=nil
   			//前驱节点
   			var nextNode = findMinNode(node.right)
   			node.val = nextNode.val
   			//委托 删除 minNode ，  这边不好删除，直接 取巧 ，覆盖值即可
   			node.right = deleteNode(node.right, nextNode.val)
   		}
   	}
   }
   if node != nil {
   	//跳转高度
   	node.h = max(node.left.height(), node.right.height()) + 1
   	node = adjustNode(node)
   }
   return node
}

//func rightRotationNode(node *Node) *Node {
//	var right = node.right
//	node.right = node.left
//	node
//}
func ascPrint(node *Node) {
   if node == nil {
   	return
   }
   ascPrint(node.left)
   fmt.Printf("%v,", node.val)
   ascPrint(node.right)
}
go语言：实现avl 树(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
12-24 59
go语言：实现avl 树(附完整源码)
golang实现高度平衡二叉树(AVL树)
Jinhua_Wei的博客
03-17 1784
AVL树简介 AVL 树是高度相对平衡（abs(height(node.lchild - height(node.rchild) &lt; 2)）的二叉搜索树。它和二叉搜索树主要的区别在AVL是高度平衡的，不会出现二叉搜索树极端情况：线性链表 搜索复杂度为N 。 实现上，AVL树在插入节点和删除节点时要不断调整树，使其处在一个平衡状态。和二叉搜索树相比主要增加树旋转、调整。 实现源码 ...
golang实现AVL树
skh2015java的博客
02-06 1173
AVL树是带有平衡条件的二叉查找树 特点：AVL树中每个节点的左子树和右子树的高度最多差1   旋转：由于插入操作可能会破坏AVL树的平衡特性，故在插入完成之前通过对树进行简单修正来恢复平衡 示例代码如下： package main import ( "fmt" ) type avlTreeNode struct { key int high int
GO数据结构——AVL树
qq_53057924的博客
09-21 377
1. 简介 AVL树是一种严格自平衡的二叉查找树。 定义： 1.二叉查找树 2.任意一个节点的左右子树的最大高度差为1 2. AVL树基本结构 2.1 AVL树基础函数 type AVLNode struct { Data interface{} Right *AVLNode Left *AVLNode Height int } /比较函数 用于对比目标节点与当前节点的高度差 纠正平衡因子 func compare(data,avldata interface{})int{ if
golang AVL树
weixin_30273931的博客
12-10 128
// 代码转载自https://blog.csdn.net/qq_36183935/article/details/80315808, 向原作者致谢 package main import "fmt" type AVL struct { value int //值 height int //深度 left *AVL //左子树 r...
avl树 golang实现
Riak, Spark, Golang, Erlang, 云存储, 云计算, 数据挖掘
08-25 3296
package main import ( "fmt" ) type DataType int type Node AVLTreeNode type AVLTree *AVLTreeNode type AVLTreeNode struct { key   DataType high  int left  *AVLTreeNode right *AVLT
Go-GoLang实现的各种算法用于学习目的
08-14
本资源“Go-GoLang实现的各种算法用于学习目的”是针对Go语言的一个实践集合，主要关注的是数据结构和算法的实现。这个项目可能包含了多种常见的算法，如排序、查找、图算法、树算法等，这些都是计算机科学的基础，...
Go-go-algorithms-使用golang实现不同的算法和数据结构
08-14
本项目"Go-go-algorithms-使用golang实现不同的算法和数据结构"旨在深入探讨如何在Go语言中实现各种经典的数据结构和算法，从而帮助开发者提升编程技能和解决问题的能力。 首先，我们来看看数据结构。数据结构是指...
Golang中实现类型安全的通用AVL树
综上所述，该资源文件描述了一个在Golang中实现的泛型AVL树，这是由于Golang语言在1.18版本后引入泛型特性而成为可能。这种数据结构能够在保持类型安全的前提下，适应不同数据类型的通用需求，同时利用AVL树的自平衡...
算法与数据结构笔记+leetcode刷题笔记+大厂面试算法题（golang和java实现）.zip
10-03
常见的数据结构有数组、链表、栈、队列、哈希表、堆、树（如二叉树、红黑树、AVL树）、图等。理解每种数据结构的特性和操作，如插入、删除、查找的时间复杂度，对于编写高效代码至关重要。 **LeetCode**： LeetCode...
golang ----------- 平衡二叉树-AVL树
田园园野的博客
05-14 1972
平衡二叉树的旋转：有4类，每类中又有两类1、右旋转：当插入的结点为失衡点的左孩子的左孩子，如下图所示，A，B是一种情况，虚线部分表示不存在。这两种情况都是右旋转，代码一样2、左旋转：当插入的结点为失衡点的右孩子的右孩子，如下图所示，A，B是一种情况，虚线部分表示不存在。这两种情况都是右旋转，代码一样3、先右旋转，再左旋转：当插入的结点为失衡点的右孩子的子孩子（左右孩子都行），如下图所示，A，B是一...
【Golang 数据结构与法算】Avl 树
qq_37981903的博客
12-21 203
GitHub完整代码 代码实现 // Package tree AVL树，基于二叉查找树的基础上，新增局部节点施加约束：任意节点的左右子树高度差(平衡因子)不大于2. package tree import ( "data-structures-and-algorithms/contract" ) // Avl Avl树 type Avl struct { Bst } // NewAvl 新建空avl树 func NewAvl(cmps ...contract.Comparator) *Avl.
（21）Go实现AVL树-算法解析
哥斯拉啊啊啊哦的博客
09-04 230
了解avltree树之前先了解几个概念 // 1）什么是二分搜索树； 2）什么是平衡树； 3）什么自平衡二分搜索树； 1）二分搜索树以及缺陷 // 如上图，是一颗二分搜索树，从添加查找节点，时间复杂度均为O(h)，但在极端情况下， 如按顺序向一个空二分搜索树中添加0，1，2，3，4，二分搜索数会退化为单链，这时候时间 时间复杂度会变成O(n)，如下图，为了避免这种情况需要结合平衡树做改进...
2024年Go最全平衡二叉树（AVL）_avl树全称是什么，带你一起探究Golang事件分发机制
2401_84925780的博客
05-14 487
增加高度属性二叉搜索树是否平衡，取决于左右子树的高度差插入节点或删除节点时，想要知道二叉树是否保持平衡，需要计算左右子树的高度计算左右子树的高度，一般通过自顶向下或自底向上的方式，递归计算（不对深度和高度加以区分）这样将会存在一定的时间开销和空间开销因此，需要在原有的TreeNode基础上，增加一个高度字段，用于记录当前节点的高度空节点的高度为0，叶子节点的高度为1，平衡二叉树，树节点的定义如下// 获取某个节点的高度。
AVL 树原理及操作详解
W24的博客
11-12 912
我们已经证明了高度为 hhh 的二叉搜索树上的每个基本操作都可以在 O(h)O(h)O(h) 时间内完成，然而随着元素的插入和删除，二叉搜索树的高度是变化的。例如，如果 nnn 个关键字按照严格递增的次序被插入，则这棵树一定是高度为 nnn 的一条链，在这样的树上进行操作的时间性能是比较低的。也就是说，如果搜索树的高度较低时，这些集合操作会执行得较快；然而如果树的高度较高时，这些集合操作可能并不比在链表上执行的快。也就有了各种各样的 “平衡”搜索树。 AVL 树是最早的自平衡二叉树，相比于后来出现的平衡二叉
GOLANG实现的一个avl tree api
weixin_30746129的博客
10-16 320
用golang实现了一个avl tree的api。 avlTree.go /* ** an avl tree api: //==&gt;&gt; operator tree api: //insert an x to AvlTree, invoker format: t = tree.Insert(t, x) func Insert(tree *AvlNode, x ElementType)...
数据结构八、AVL平衡二叉树(不仅满还完全的二叉树)以及红黑树(单一黑平衡的二叉树)
m0_52540692的博客
07-12 268
文章目录平衡二叉树(1)平衡二叉树描述(2)平衡二叉树的搭建(3)平衡二叉树的初始化(4)判断该树是否为平衡二叉树测试(5)AVL的左旋转和右旋转(5)AVL的增(6)AVL的删 平衡二叉树 (1)平衡二叉树描述 一棵满二叉树和完全二叉树的组合就是平衡二叉树 线段树也是平衡二叉树 平衡二叉树的要求： 对于任意一个结点，左子树和右子树的高度差不能超过1 (2)平衡二叉树的搭建 我们由改版形成,源代码请看二分搜索树 (3)平衡二叉树的初始化 平衡二叉树在二分搜索树中引进了树的高的,平衡因子 在平衡
Golang实现红黑树
只数月亮不数星星的博客
05-02 4454
红黑树基于golang的实现，主要介绍如何实现红黑树的调整。在此中加入了自己在实现过程中的些许感受和在处理逻辑时需要注意的细节。
Go语言调度器深度解析：sysmon的核心作用与实现原理
最新发布
大家好，我是码农老gou，一名专注于编程技术的程序员。在这个博客中，我将与大家分享我在工作和学习中的经验、见解以及一些实用的技术干货。
07-15 742
Go语言调度器深度解析：sysmon的核心作用与实现原理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值