六 二叉树

最新推荐文章于 2021-06-22 20:50:25 发布
原创 最新推荐文章于 2021-06-22 20:50:25 发布 · 622 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

六 二叉树

树结构概述

在这里插入图片描述
为什么使用树？其中一个原因：

  • 顺序表查找方便，插入删除麻烦
  • 链表，插入删除简单，但是查找麻烦
  • 树综合考虑了以上问题，他的修改和查找能力比较中和。

基本概念：
在这里插入图片描述

二叉树的概述

在这里插入图片描述
在这里插入图片描述
能连续数满就是完全二叉树
在这里插入图片描述

创建二叉树

  • 二叉树的五种形态：

在这里插入图片描述

package demo5;

public class Node {
	//节点的权
	int value;
	//左儿子
	Node leftNode;
	//右儿子
	Node rightNode;
	
	public Node(int value) {
		this.value=value;
	}
	
	//设置左儿子
	public void setLeftNode(Node leftNode) {
		this.leftNode = leftNode;
	}
	//设置右儿子
	public void setRightNode(Node rightNode) {
		this.rightNode = rightNode;
	}
	
	//前序遍历
	public void frontShow() {
		//先遍历当前节点的内容
		System.out.println(value);
		//左节点
		if(leftNode!=null) {
			leftNode.frontShow();
		}
		//右节点
		if(rightNode!=null) {
			rightNode.frontShow();
		}
	}

	//中序遍历
	public void midShow() {
		//左子节点
		if(leftNode!=null) {
			leftNode.midShow();
		}
		//当前节点
		System.out.println(value);
		//右子节点
		if(rightNode!=null) {
			rightNode.midShow();
		}
	}

	//后序遍历
	public void afterShow() {
		//左子节点
		if(leftNode!=null) {
			leftNode.afterShow();
		}
		//右子节点
		if(rightNode!=null) {
			rightNode.afterShow();
		}
		//当前节点
		System.out.println(value);
	}

	//前序查找
	public Node frontSearch(int i) {
		Node target=null;
		//对比当前节点的值
		if(this.value==i) {
			return this;
		//当前节点的值不是要查找的节点
		}else {
			//查找左儿子
			if(leftNode!=null) {
				//有可能可以查到，也可以查不到，查不到的话，target还是一个null
				target = leftNode.frontSearch(i);
			}
			//如果不为空，说明在左儿子中已经找到
			if(target!=null) {
				return target;
			}
			//查找右儿子
			if(rightNode!=null) {
				target=rightNode.frontSearch(i);
			}
		}
		return target;
	}
	
	//删除一个子树
	public void delete(int i) {
		Node parent = this;
		//判断左儿子
		if(parent.leftNode!=null&&parent.leftNode.value==i) {
			parent.leftNode=null;
			return;
		}
		//判断右儿子
		if(parent.rightNode!=null&&parent.rightNode.value==i) {
			parent.rightNode=null;
			return;
		}
		
		//递归检查并删除左儿子
		parent=leftNode;
		if(parent!=null) {
			parent.delete(i);
		}
		
		//递归检查并删除右儿子
		parent=rightNode;
		if(parent!=null) {
			parent.delete(i);
		}
	}

}


package demo5;

public class BinaryTree {

	Node root;
	
	//设置根节点
	public void setRoot(Node root) {
		this.root = root;
	}
	
	//获取根节点
	public Node getRoot() {
		return root;
	}

	public void frontShow() {
		if(root!=null) {
			root.frontShow();
		}
	}

	public void midShow() {
		if(root!=null) {
			root.midShow();
		}
	}

	public void afterShow() {
		if(root!=null) {
			root.afterShow();
		}
	}

	public Node frontSearch(int i) {
		return root.frontSearch(i);
	}

	public void delete(int i) {
		if(root.value==i) {
			root=null;
		}else {
			root.delete(i);
		}
	}
	


package demo5;

public class TestBinaryTree {

	public static void main(String[] args) {
		//创建一颗树
		BinaryTree binTree = new BinaryTree();
		//创建一个根节点
		Node root = new Node(1);
		//把根节点赋给树
		binTree.setRoot(root);
		//创建一个左节点
		Node rootL = new Node(2);
		//把新创建的节点设置为根节点的子节点
		root.setLeftNode(rootL);
		//创建一个右节点
		Node rootR = new Node(3);
		//把新创建的节点设置为根节点的子节点
		root.setRightNode(rootR);
		//为第二层的左节点创建两个子节点
		rootL.setLeftNode(new Node(4));
		rootL.setRightNode(new Node(5));
		//为第二层的右节点创建两个子节点
		rootR.setLeftNode(new Node(6));
		rootR.setRightNode(new Node(7));
		//前序遍历树
		binTree.frontShow();
		System.out.println("===============");
		//中序遍历
		binTree.midShow();
		System.out.println("===============");
		//后序遍历
		binTree.afterShow();
		System.out.println("===============");
		//前序查找
		Node result = binTree.frontSearch(5);
		System.out.println(result);
		
		System.out.println("===============");
		//删除一个子树
		binTree.delete(4);
		binTree.frontShow();
		
	}

}

遍历二叉树

在这里插入图片描述

A：根节点、B：左节点、C：右节点，前序顺序是ABC（根节点排最先，然后同级先左后右）；中序顺序是BAC(先左后根最后右）；后序顺序是BCA（先左后右最后根）。

  • 实例：

在这里插入图片描述

二叉树中节点的查找

删除二叉树的子树

顺序存储的二叉树的概述

  • 顺序存储二叉树

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

但其实

在这里插入图片描述
在这里插入图片描述

顺序存储的二叉树的遍历

package demo6;

public class ArrayBinaryTree {

	int[] data;
	
	public ArrayBinaryTree(int[] data) {
		this.data=data;
	}
	
	public void frontShow() {
		frontShow(0);
	}
	
	//前序遍历
	public void frontShow(int index) {
		if(data==null||data.length==0) {
			return;
		}
		//先遍历当前节点的内容
		System.out.println(data[index]);
		//2*index+1:处理左子树
		if(2*index+1<data.length) {
			frontShow(2*index+1);
		}
		//2*index+2:处理右子树
		if(2*index+2<data.length) {
			frontShow(2*index+2);
		}
	}
	
}


package demo6;

public class TestArrayBinaryTree {

	public static void main(String[] args) {
		int[] data = new int[] {1,2,3,4,5,6,7};
		ArrayBinaryTree tree = new ArrayBinaryTree(data);
		//前序遍历
		tree.frontShow();
	}

}

常用排序算法之堆排序

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

package demo4;

import java.util.Arrays;

public class HeapSort {
	
	public static void main(String[] args) {
		int[] arr = new int[] {9,6,8,7,0,1,10,4,2};
		heapSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	public static void heapSort(int[] arr) {
		//开始位置是最后一个非叶子节点，即最后一个节点的父节点
		int start = (arr.length-1)/2;
		//调整为大顶堆
		for(int i=start;i>=0;i--) {
			maxHeap(arr, arr.length, i);
		}
		//先把数组中的第0个和堆中的最后一个数交换位置，再把前面的处理为大顶堆
		for(int i=arr.length-1;i>0;i--) {
			int temp = arr[0];
			arr[0]=arr[i];
			arr[i]=temp;
			maxHeap(arr, i, 0);
		}
	}
	
	public static void maxHeap(int[] arr,int size,int index) {
		//左子节点
		int leftNode = 2*index+1;
		//右子节点
		int rightNode = 2*index+2;
		int max = index;
		//和两个子节点分别对比，找出最大的节点
		if(leftNode<size&&arr[leftNode]>arr[max]) {
			max=leftNode;
		}
		if(rightNode<size&&arr[rightNode]>arr[max]) {
			max=rightNode;
		}
		//交换位置
		if(max!=index) {
			int temp=arr[index];
			arr[index]=arr[max];
			arr[max]=temp;
			//交换位置以后，可能会破坏之前排好的堆，所以，之前的排好的堆需要重新调整
			maxHeap(arr, size, max);
		}
	}

}

线索二叉树的概述

在这里插入图片描述

线索二叉树代码实现

package demo7;

public class ThreadedNode {
	//节点的权
	int value;
	//左儿子
	ThreadedNode leftNode;
	//右儿子
	ThreadedNode rightNode;
	//标识指针类型
	int leftType;
	int rightType;
	

	public ThreadedNode(int value) {
		this.value=value;
	}
	
	//设置左儿子
	public void setLeftNode(ThreadedNode leftNode) {
		this.leftNode = leftNode;
	}
	//设置右儿子
	public void setRightNode(ThreadedNode rightNode) {
		this.rightNode = rightNode;
	}
	
	//前序遍历
	public void frontShow() {
		//先遍历当前节点的内容
		System.out.println(value);
		//左节点
		if(leftNode!=null) {
			leftNode.frontShow();
		}
		//右节点
		if(rightNode!=null) {
			rightNode.frontShow();
		}
	}

	//中序遍历
	public void midShow() {
		//左子节点
		if(leftNode!=null) {
			leftNode.midShow();
		}
		//当前节点
		System.out.println(value);
		//右子节点
		if(rightNode!=null) {
			rightNode.midShow();
		}
	}

	//后序遍历
	public void afterShow() {
		//左子节点
		if(leftNode!=null) {
			leftNode.afterShow();
		}
		//右子节点
		if(rightNode!=null) {
			rightNode.afterShow();
		}
		//当前节点
		System.out.println(value);
	}

	//前序查找
	public ThreadedNode frontSearch(int i) {
		ThreadedNode target=null;
		//对比当前节点的值
		if(this.value==i) {
			return this;
		//当前节点的值不是要查找的节点
		}else {
			//查找左儿子
			if(leftNode!=null) {
				//有可能可以查到，也可以查不到，查不到的话，target还是一个null
				target = leftNode.frontSearch(i);
			}
			//如果不为空，说明在左儿子中已经找到
			if(target!=null) {
				return target;
			}
			//查找右儿子
			if(rightNode!=null) {
				target=rightNode.frontSearch(i);
			}
		}
		return target;
	}
	
	//删除一个子树
	public void delete(int i) {
		ThreadedNode parent = this;
		//判断左儿子
		if(parent.leftNode!=null&&parent.leftNode.value==i) {
			parent.leftNode=null;
			return;
		}
		//判断右儿子
		if(parent.rightNode!=null&&parent.rightNode.value==i) {
			parent.rightNode=null;
			return;
		}
		
		//递归检查并删除左儿子
		parent=leftNode;
		if(parent!=null) {
			parent.delete(i);
		}
		
		//递归检查并删除右儿子
		parent=rightNode;
		if(parent!=null) {
			parent.delete(i);
		}
	}

}


package demo7;

public class ThreadedBinaryTree {

	ThreadedNode root;
	//用于临时存储前驱节点
	ThreadedNode pre=null;
	
	//遍历线索二叉树
	public void threadIterate() {
		//用于临时存储当前遍历节点
		ThreadedNode node = root;
		while(node!=null) {
			//循环找到最开始的节点
			while(node.leftType==0) {
				node=node.leftNode;
			}
			//打印当前节点的值
			System.out.println(node.value);
			//如果当前节点的右指针指向的是后继节点，可能后继节点还有后继节点、
			while(node.rightType==1) {
				node=node.rightNode;
				System.out.println(node.value);
			}
			//替换遍历的节点
			node=node.rightNode;
		}
	}
	
	//设置根节点
	public void setRoot(ThreadedNode root) {
		this.root = root;
	}
	
	//中序线索化二叉树
	public void threadNodes() {
		threadNodes(root);
	}
	
	public void threadNodes(ThreadedNode node) {
		//当前节点如果为null，直接返回
		if(node==null) {
			return;
		}
		//处理左子树
		threadNodes(node.leftNode);
		//处理前驱节点
		if(node.leftNode==null){
			//让当前节点的左指针指向前驱节点
			node.leftNode=pre;
			//改变当前节点左指针的类型
			node.leftType=1;
		}
		//处理前驱的右指针，如果前驱节点的右指针是null(没有指下右子树)
		if(pre!=null&&pre.rightNode==null) {
			//让前驱节点的右指针指向当前节点
			pre.rightNode=node;
			//改变前驱节点的右指针类型
			pre.rightType=1;
		}
		//每处理一个节点，当前节点是下一个节点的前驱节点
		pre=node;
		//处理右子树
		threadNodes(node.rightNode);
	}
	
	//获取根节点
	public ThreadedNode getRoot() {
		return root;
	}

	//前序遍历
	public void frontShow() {
		if(root!=null) {
			root.frontShow();
		}
	}

	//中序遍历
	public void midShow() {
		if(root!=null) {
			root.midShow();
		}
	}

	//后序遍历
	public void afterShow() {
		if(root!=null) {
			root.afterShow();
		}
	}

	//前序查找
	public ThreadedNode frontSearch(int i) {
		return root.frontSearch(i);
	}

	//删除子树
	public void delete(int i) {
		if(root.value==i) {
			root=null;
		}else {
			root.delete(i);
		}
	}
	
}


package demo7;

public class TestThreadedBinaryTree {

	public static void main(String[] args) {
		//创建一颗树
		ThreadedBinaryTree binTree = new ThreadedBinaryTree();
		//创建一个根节点
		ThreadedNode root = new ThreadedNode(1);
		//把根节点赋给树
		binTree.setRoot(root);
		//创建一个左节点
		ThreadedNode rootL = new ThreadedNode(2);
		//把新创建的节点设置为根节点的子节点
		root.setLeftNode(rootL);
		//创建一个右节点
		ThreadedNode rootR = new ThreadedNode(3);
		//把新创建的节点设置为根节点的子节点
		root.setRightNode(rootR);
		//为第二层的左节点创建两个子节点
		rootL.setLeftNode(new ThreadedNode(4));
		ThreadedNode fiveNode = new ThreadedNode(5);
		rootL.setRightNode(fiveNode);
		//为第二层的右节点创建两个子节点
		rootR.setLeftNode(new ThreadedNode(6));
		rootR.setRightNode(new ThreadedNode(7));
		//中序遍历树
		binTree.midShow();
		System.out.println("===============");
		//中前线索化二叉树
		binTree.threadNodes();
		binTree.threadIterate();
	}

}

线索二叉树的遍历

【牛客BAT算法】6.二叉树
12-04 508
目录 二叉树类型的题目为常考题型 案例一：用递归方式和非递归式实现二叉树的先序、中序和后序的遍历打印。 先序遍历： 中序遍历： 后序遍历： 案例二：给定二叉树的头结点head，要求按照以下格式打印 案例三：二叉树的序列化与反序列化 案例四：判断一棵树是否为平衡二叉树 案例五：判断一棵树是否是搜索二叉树 案例六：判断一棵树是否是完全二叉树 案例七：求二叉树节点的后继节点 案例八：折纸对折N次，从上到下打印所用折痕的方向 案例九：找出搜索二叉树中的错误节点 案例十：节点间的最大距离
16叉树
badopencoder的博客
01-29 869
#include #include using namespace std; const int M = 16; struct node{ node(int _v = 0, int _n = 0): value(_v), num(_n){ for(int i = 0; i < M; i++) next[i] = NULL; } int value, num; node* next
六、树和二叉树--(1)什么是二叉树
firetreeSF的博客
05-02 541
摘自计蒜客：http://www.jisuanke.com/course/35/1389 如上图所示，二叉树的每个结点最多只有两个孩子结点，也就是说每个结点最多有两个子树。 二叉树有 5 种基本形态： 空二叉树，树为空，没有结点； 只有根结点的二叉树； 只有左子树的二叉树； 只有右子树的二叉树； 左右子树都有的二叉树。 接下来我们来看看二叉树的性质：
C语言六叉树,递归创建二叉树c语言实现+详细解释
weixin_34502439的博客
05-19 234
该楼层疑似违规已被系统折叠隐藏此楼查看此楼voidCreatBiTree(BiTreeT){chara;scanf("%c",&a);if(a=='@')T=NULL;else{T=(BiTree)malloc(sizeof(BiNode));T->data=a;CreatBiTree(T->lchild);CreatBiTree(T->rchild);}}虽能编...
数据结构(六)树
Rookie_cong的博客
09-23 414
未完待续树的概念： 子树 根结点 内部结点 叶结点或终端结点 深度或高度：根为第一层，根的孩子为第二层，依次类推，树中结点最大的层数就称为深度或高度。 在树中，如果任意一个结点的子树，从左到右都是有次序的，那么这棵树被称为有序树，反之则为无序树。 森林：由多棵不相交的树的集合。树的存储结构： 双亲表示法： 双亲域：每个结点设置一个指向双亲位置的单元。 长子域：每个结点设置一个指向第一
实验六 二叉树操作.docx
11-12
本实验"实验六 二叉树操作.docx"显然着重于探讨如何操作和遍历二叉树，特别是通过层序遍历的方式。在这个过程中，我们将深入理解二叉树的性质、层序遍历的概念，以及如何实现这一遍历方法。 首先，二叉树是由节点...
实验六 二叉树操作.pdf
11-12
二叉树是一种数据结构，它由结点（或称为节点）构成，每个结点最多有两个子结点，分别称为左子结点和右子结点。在这个实验中，我们将深入理解二叉树的性质，并学习如何使用数组来存储和操作二叉树。 实验目标是掌握...
NJUCM-数据结构课程6.实验六 二叉树的构建应用.zip
06-02
在NJUCM的数据结构课程中，实验六着重探讨了二叉树的构建及其应用。二叉树作为一种基础且重要的数据结构，在计算机科学中扮演着关键角色，尤其在算法设计和数据组织方面。在这个实验中，学生将深入理解二叉树的性质...
实验六 二叉树的基本操作实验报告.docx
11-12
实验六涉及的是二叉树的基本操作，主要涵盖了二叉树的创建、输出、查找、高度计算、节点计数以及销毁等关键功能。以下是对这些知识点的详细解释： 1. **二叉树创建**： 通过`CreateBTNode`函数，使用给定的字符串...
实验六 二叉树的基本操作实验报告.pdf
11-12
【二叉树的基本操作实验】 在计算机科学中，二叉树是一种特殊的数据结构，它包含一个根节点，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树广泛应用于各种算法和数据结构中，如搜索、排序、表达式...
数据结构期末试题11
08-03
1．在数据结构中，数据元素之间通常有下列四类基本结构：、、 2． 以下代码：y=0 3．用六叉链表表示 30 个结点的六叉树，则树中共有 __ __个空指针 4
多叉树、2-3-4树
atu99602的博客
01-05 279
多叉树 非叶节点的子节点可以多于两个 2-3-4树 2-3-4树的非叶节点可能含有两个、三个或四个子节点，所以叫2-3-4树；2-3-4树的非叶节点最多可以有4个子节点，所以又叫4叉树。有两个子节点的节点叫2-节点，有三个子节点的节点叫3-节点，有四个子节点的节点叫4-节点。 对非叶节点来说，节点有一个数据项总是有两个子节点，节点有两个数据项总是有三个子节点，节点有三个数据项总是...
六、树和二叉树--(0)什么是树
firetreeSF的博客
05-02 958
摘自计蒜客：http://www.jisuanke.com/course/35/1387 树形结构广泛存在我们的现实生活里，下面两张图你一定不陌生吧，第一张是 Linux 文件系统结构，第二张是美国福特汽车公司的汽车家谱图。类似的树形结构还有很多，他们都可以抽象成数据结构里的树。和自然界里的树有所类似又有所不同，他们都有且仅有一个树根，树上的元素都是从树根衍生出来的。不同的是自然界里的树，它
j计算机二级基础知识,【日常干货】计算机二级基础知识（第四期）
weixin_33213911的博客
06-22 2624
原标题：【日常干货】计算机二级基础知识(第四期)考试即将到来小伙伴们加油鸭！(答案在题下方空白处，注意查收)1.设一棵树的度为3，其中没有度为2的结点，且叶子结点数为5。该树中度为3的结点数为A) 3B)1C) 2D)不可能有这样的树▼C【解析】设树的结点数为m，度为3的结点数为n，则度为1的结点数为m-n-5, 根据树中的结点数=树中所有结点的度之和+1，得3×n+1×(m-n-5)+5×0+1...
六 树和二叉树
xlbety的博客
10-24 492
6.1 树的定义 树（Tree）是n(n >= 0)个节点的有限集。 6.2 树的基本术语 结点：
已知完全二叉树有30个节点，则整个二叉树有 1 个度为1的节点。
05-12 7080
已知完全二叉树有30个节点，则整个二叉树有_1--个度为1的节点。 解答： 完全二叉树：除了最外层，其余层上的节点数目都达到最大值，而第h层上的节点集中存放在左侧树中。     n0是度为0的节点总数(即叶子节点数)，n1是度为1的节点总数，n2是度为2的节点总数，由二叉树的性质可知：     n0=n2+1，则完全二叉树的节点总数n为：    n=n0+n1+n2，由于完全二叉树中
大话数据结构第六章笔记 （树）
wsfhdhjs的博客
05-06 524
6.2树的定义： 1.树是n个结点的有限集，n=0时称为空树 2.有且仅有一个特定的根 3.子树的个数没有限制，但他们一定是不相交，如下图，就不是子树 4.结点拥有的子树数称为结点的度。度为0的结点称为叶节点；度不为0的结点称为分支结点。除根节点之外，分支节点也称内部结点；树的度是树内各结点的度的最大值，如下图 6.3结点间的关系： 1.结点的祖先是从根到该结点所经分支上的所有结点 对于H而言...
八叉树和十六叉树结构
Chinamming的专栏
11-24 1063
(1)三维和四维数据结构的提出。前面介绍的数据结构都是二维的，然而在有些信息系统中，需要有真三维的空间数据结构。例如矿山开采中的地下资源埋藏和采矿巷道的空间分布，如果用二维的坐标体系就根本无法很好表达。此外，矿山空间目标往往随时间不断变化着，这就提出了空间和时间信息系统的问题。 在时间信息系统中不考虑时间，是把时间看作不变的常数，即为当前的时间。而在时间和空间信息系统中，则把时间看作有过...
图解数据结构（6）——树及树的遍历
weixin_33939843的博客
06-27 264
八、树（Tree）树，顾名思义，长得像一棵树，不过通常我们画成一棵倒过来的树，根在上，叶在下。不说那么多了，图一看就懂： 当然了，引入了树之后，就不得不引入树的一些概念，这些概念我照样尽量用图，谁会记那么多文字？ 树这种结构还可以表示成下面这种方式，可见树用来描述包含关系是很不错的，但这种包含关系不得出现交叉重叠区域，否则就不能用树描述了，看图： 面试的时候我们经常被考到的是一种叫“二叉树”...
二叉树六个基本运算
最新发布
11-24
二叉树的六个基本运算如下： ### 创建二叉树 创建二叉树即根据给定的方式生成对应的二叉链存储结构。例如可以根据二叉树括号表示法字符串生成对应的二叉链存储结构。如由二叉树的括号表示串 “A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))” 创建对应的二叉链存储结构b [^1]。 以下是一个简单的Python示例代码： ```python class TreeNode: def __init__(self, value): self.value = value self.left = None self.right = None def create_binary_tree(): root = TreeNode('A') root.left = TreeNode('B') root.right = TreeNode('C') root.left.left = TreeNode('D') root.left.right = TreeNode('E') root.right.left = TreeNode('F') root.right.right = TreeNode('G') # 继续构建其他节点 return root ``` ### 销毁二叉链存储结构 销毁二叉链存储结构是释放二叉树所占用的内存空间，防止内存泄漏。当不再使用二叉树时，需要将其占用的内存释放掉。 以下是Python示例代码： ```python def destroy_binary_tree(root): if root: destroy_binary_tree(root.left) destroy_binary_tree(root.right) del root ``` ### 查找节点 在二叉树中查找data域值为指定值的节点，并返回指向该节点的指针。若找到则返回该节点，若未找到则返回空。 以下是Python示例代码： ```python def find_node(root, target): if root is None: return None if root.value == target: return root left_result = find_node(root.left, target) if left_result: return left_result return find_node(root.right, target) ``` ### 找孩子节点 找孩子节点包括求二叉树中节点的左孩子节点
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值