Step By Step TDD树的遍历算法：）

最新推荐文章于 2024-08-12 18:10:44 发布
最新推荐文章于 2024-08-12 18:10:44 发布
阅读量134 收藏
点赞数
分类专栏： Agile 文章标签： 算法 TDD Java C C++
Tree Node的定义。普通的POJO类： 

public class TreeNode {

	private TreeNode rightChild;
	private TreeNode leftChild;
	protected String treeNodeString;

	public TreeNode(String treeNodeString) {
		this.treeNodeString = treeNodeString;
	}

	public TreeNode getRightChild() {
		return rightChild;
	}

	public void setRightChild(TreeNode rightChild) {
		this.rightChild = rightChild;
	}

	public TreeNode getLeftChild() {
		return leftChild;
	}

	public void setLeftChild(TreeNode leftChild) {
		this.leftChild = leftChild;
	}

	public String getTreeNodeString() {
		return this.treeNodeString;
	}

}


第一个Test： 

public class TreeTest extends TestCase {
	public void testTreePreTraverse() {
		TreeNode a= new TreeNode("a");
		assertEquals("a", preOrderTraverse(a));
	}

	private String preOrderTraverse(TreeNode root) {
		return null;//为了看得清楚直接写在test里了，应该提出成单独类
	}
}



...
	private String preOrderTraverse(TreeNode root) {
		return root.getTreeNodeString();//绿
	}

增加test，进一步描述需求 

...
	public void testABCPreOrderTraverse(){
		TreeNode a= new TreeNode("a");
		TreeNode b= new TreeNode("b");
		TreeNode c= new TreeNode("c");
		a.setLeftChild(b);
		a.setRightChild(c);
		assertEquals("abc", preOrderTraverse(a));//红expected:abc actual:a
	}



	private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		}else{
			return "abc";
		}
	}


else里面的演化 
return root.getTreeNodeString()+"bc";

return root.getTreeNodeString()+"b"+"c";


"b" == root.getLeftChild().getTreeNodeString()
"c" == root.getRightChild().getTreeNodeString() 

	private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			result += leftChild.getTreeNodeString();
			result += rightChild.getTreeNodeString();

			return result;
		}
	}

进一步添加test 

	public void testABCDEPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		assertEquals("abdec", preOrderTraverse(a));//红
	}

红expected:abdec actual:abc

最快使其通过，然后refactor消除重复 

			String result = root.getTreeNodeString();
			result += leftChild.getTreeNodeString();
			result += "d";
			result += "e";
			result += rightChild.getTreeNodeString();

testABCDEPreOrderTraverse()通过了:-)
但testABCPreOrderTraverse()会红，暂时先不管这个，我们refactor完这步再来看这个= = 

			String result = root.getTreeNodeString();
			result += leftChild.getTreeNodeString();
			result += leftChild.getLeftChild().getTreeNodeString();//"d"
			result += "e";
			result += rightChild.getTreeNodeString();



private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			result += leftChild.getTreeNodeString();
			result += leftChild.getLeftChild().getTreeNodeString();
			result += leftChild.getRightChild().getTreeNodeString();
			result += rightChild.getTreeNodeString();

			return result;
		}
	}


result += leftChild.getTreeNodeString();//visit leftChild
result += leftChild.getLeftChild().getTreeNodeString();//visit leftChild's leftChild
result += leftChild.getRightChild().getTreeNodeString();//visit leftChild's rightChild
root，left，right 恩恩 这不就是在preOrderTraverse么？
等同于 preOrderTraverse(leftChild)可以试一下。 （有test在咱不怕，不行就退回去= =） 

private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			result += preOrderTraverse(leftChild);
			result += rightChild.getTreeNodeString();

			return result;
		}
	}


是个绿，通过 yeah~而且连testABCPreOrderTraverse()也通过了。
访问右孩子也没区别吧？ 那咱试试.(有test在，咱就可以随便试，方便= =~) 

	private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			result += preOrderTraverse(leftChild);
			result += preOrderTraverse(rightChild);

			return result;
		}
	}


目前为止都是完全树，那瘸腿的呢？写个test看下 

public void testABCDEFPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setLeftChild(f);
		assertEquals("abdefc", preOrderTraverse(a));//完了 nullPointer了,惨
	}

因为e只有左孩子f，e的右孩子==null,走到e的右孩子时（执行preOrderTraverse(e的右孩子)）
if (root.getLeftChild() == null && root.getRightChild() == null)
时会错（其实在调用null.getLeftChild()，所以错了）

太技术化了= =
事实是：你要访问人家的右孩子，你不得问问人家有没有啊（if（e的右孩子有否？））
我改= = 

			String result = root.getTreeNodeString();
			result += preOrderTraverse(leftChild);
			if (rightChild != null)
				result += preOrderTraverse(rightChild);


这次通过了，同理 我把f放e右边呢？ 也得check吧？先写个test 

	public void testABCDEF2PreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setRightChild(f);
		assertEquals("abdefc", preOrderTraverse(a));//红 还没check左孩子
	}



	private String preOrderTraverse(TreeNode root) {
		if (root.getLeftChild() == null && root.getRightChild() == null) {
			return root.getTreeNodeString();
		} else {
			TreeNode leftChild = root.getLeftChild();
			TreeNode rightChild = root.getRightChild();

			String result = root.getTreeNodeString();
			if (leftChild != null)
				result += preOrderTraverse(leftChild);
			if (rightChild != null)
				result += preOrderTraverse(rightChild);

			return result;
		}
	}

这下可以了：） 仔细看看怎么有点别扭啊 那么多check null啊？
嘿嘿 其实这里面有重复情况。第一个if 其实已经被else中包含了。去了试试 执行test，给我走= = 

	private String preOrderTraverse(TreeNode root) {

		TreeNode leftChild = root.getLeftChild();
		TreeNode rightChild = root.getRightChild();

		String result = root.getTreeNodeString();
		if (leftChild != null)
			result += preOrderTraverse(leftChild);
		if (rightChild != null)
			result += preOrderTraverse(rightChild);

		return result;

	}

通过:-) 继续refactor，消除重复 extract method 

	private String preOrderTraverse(TreeNode root) {

		TreeNode leftChild = root.getLeftChild();
		TreeNode rightChild = root.getRightChild();

		String result = root.getTreeNodeString();//root
		result = visitChild(leftChild, result);//left
		result = visitChild(rightChild, result);//right 真清爽:-)

		return result;

	}

	private String visitChild(TreeNode child, String result) {
		if (child != null)
			result += preOrderTraverse(child);
		return result;
	}

差不多了 下面是结果:-) 最后的extract class没有做= = 不过不难:-) 


import junit.framework.TestCase;

public class TreeTest extends TestCase {
	public void testTreePreTraverse() {
		TreeNode a = new TreeNode("a");
		assertEquals("a", preOrderTraverse(a));
	}

	public void testABCPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		a.setLeftChild(b);
		a.setRightChild(c);
		assertEquals("abc", preOrderTraverse(a));
	}

	public void testABCDEPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		assertEquals("abdec", preOrderTraverse(a));
	}

	public void testABCDEFPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setLeftChild(f);
		assertEquals("abdefc", preOrderTraverse(a));
	}

	public void testABCDEF2PreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setRightChild(f);
		assertEquals("abdefc", preOrderTraverse(a));
	}

	private String preOrderTraverse(TreeNode root) {

		String result = root.getTreeNodeString();
		result = visitChild(root.getLeftChild(), result);
		result = visitChild(root.getRightChild(), result);
		return result;

	}

	private String visitChild(TreeNode child, String result) {
		if (child != null)
			result += preOrderTraverse(child);
		return result;
	}
}



extract class
先序: 

public class PreOrderTraverserOld implements ITraverser {
	private String result = new String();

	public String doTraverse(TreeNode root) {
		result += root.getTreeNodeString();
		result = visitChild(root.getLeftChild(), result);
		result = visitChild(root.getRightChild(), result);
		return result;
	}

	public String visitChild(TreeNode child, String result) {
		if (child != null)
			result = doTraverse(child);
		return result;
	}

}



中序，后序步骤没啥差别= =


中序 

public class InOrderTraverserOld implements ITraverser {
	private String result = new String();

	public String doTraverse(TreeNode root) {
		result = visitChild(root.getLeftChild(), result);
		result += root.getTreeNodeString();
		result = visitChild(root.getRightChild(), result);
		return result;
	}

	public String visitChild(TreeNode child, String result) {
		if (child != null)
			result = doTraverse(child);
		return result;
	}

}

后序 

public class PostOrderTraverserOld implements ITraverser {
	private String result = new String();

	public String doTraverse(TreeNode root) {
		result = visitChild(root.getLeftChild(), result);
		result = visitChild(root.getRightChild(), result);
		result += root.getTreeNodeString();
		return result;
	}

	public String visitChild(TreeNode child, String result) {
		if (child != null)
			result = doTraverse(child);
		return result;
	}

}

Test 

import junit.framework.TestCase;

public class TreeTest extends TestCase {
	ITraverser preOrderTraverserOld = new PreOrderTraverserOld();
	ITraverser inOrderTraverserOld = new InOrderTraverserOld();
	ITraverser postOrderTraverserOld = new PostOrderTraverserOld();

	public void testTreePreTraverse() {
		TreeNode a = new TreeNode("a");
		assertEquals("a", preOrderTraverserOld.doTraverse(a));
	}

	public void testABCPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		a.setLeftChild(b);
		a.setRightChild(c);
		assertEquals("abc", preOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEPreOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		assertEquals("abdec", preOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEFInOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setLeftChild(f);

		assertEquals("dbfeac", inOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEF2InOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setRightChild(f);
		assertEquals("dbefac", inOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEFPostOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setLeftChild(f);
		assertEquals("dfebca", postOrderTraverserOld.doTraverse(a));
	}

	public void testABCDEF2PostOrderTraverse() {
		TreeNode a = new TreeNode("a");
		TreeNode b = new TreeNode("b");
		TreeNode c = new TreeNode("c");
		TreeNode d = new TreeNode("d");
		TreeNode e = new TreeNode("e");
		TreeNode f = new TreeNode("f");
		a.setLeftChild(b);
		a.setRightChild(c);
		b.setLeftChild(d);
		b.setRightChild(e);
		e.setRightChild(f);
		assertEquals("dfebca", postOrderTraverserOld.doTraverse(a));
	}

}
EverToBe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tdd-by-example:TDD示例
05-10
通过示例进行测试驱动的开发存储库中的所有源代码示例均适用于我的所提供的示例灵感来自肯特·贝克（Kent Beck）在他的《示例一书中的 在此存储库中，我将使用Beck的经典TDD Money示例-更新到Java 11和JUnit 5。...
FizzBuzz-TDD:研究TDD的项目
05-12
FizzBu​​zz TDD 关于 研究测试驱动开发（TDD）的项目。 锻炼： 编写一个程序，打印从1到100的数字。但是，对于三个打印数字“ Fizz”（而不是数字）的倍数，以及五个打印“嗡嗡声”的倍数。 对于三和五的倍数的...
Study__TDD:个人TDD学习资料库
05-25
当前，列出了以下内容： NHN FE개발랩摘要-Finsihed 견고한JS소프트웨어만들기-进行中测试Vue.js应用程序摘要-进行中TDD리팩토링[우아한테크세미나]-Finsihed 此外，在代码中，存在算法实践和vue测试实践。...
tdd:tdd 与 qunit
07-11
tdd 与 qunit。 在这个例子中，我们使用 requirejs javascript 加载器将单元测试拉到我们的项目中，这是一个带有 HST 的简单加法机。 测试通过加载和访问。 测试本身位于 js/tests 文件夹中。 被测hst的计算在js/lib...
react-tdd-workshop:TDD与React研讨会
05-11
React TDD工作坊 WIP-这是我的 欢迎来到我的React TDD研讨会！ 入门 npm i npm test 观看模式： 1号航站楼： npm start 2号航站楼： npm run test:watch 这个研讨会是关于什么的？ 我们将使用React + Jest + ...
day 9 回溯算法
m0_73924943的博客
08-08 323
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
代码随想录算法训练营day36：动态规划04：1049.最后一块石头的重量II；494.目标和；474.一和零
weixin_65180740的博客
08-07 935
力扣题目链接(opens new window)有一堆石头，每块石头的重量都是正整数。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；如果 x!= y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。输入：[2,7,4,1,8,1]输出：1。
浙大版《C语言程序设计（第3版）》题目集
qq_67330059的博客
08-09 317
其中a和b是用户传入的参数，函数返回的是两者中较大的数。
算法学习day32
最新发布
2301_78191305的博客
08-12 821
2.如果遍历到的数字可以和放一个数字构成一个有效的大写字母的ASCII值，是对dp[i+1]有用的，(这个有用是指多了dp[i-1]种分割方法）那么dp[i+1]+=dp[i-1];现在1有与3，5相乘的资格，2有与2，3，5相乘的资格，但是2×3和2×5是没必要比较的，因为有比它更小的1可以同3，5相乘，所以我们只需要比较1×3，1×5，2×2。即n=2*x+3*y+5*z。如果nums[i]==nums[i-1]&&nums[i-1]==nums[i-2] 那么dp[i]+=dp[i-1]+1;
矩阵转置（c语言）
scy2429828663的博客
08-09 779
int m = 0;int a = 0;//输入 n m//将数据存储在arr上//输入 aj < n;j++)i < m;i++)//转置i < m;i++)j < n;
算法日记day 33（动归之斐波那契数|爬楼梯）
m0_74980681的博客
08-08 367
要求每次可以爬1阶或者2阶，逆向思维可以理解为，当我们上到最后一阶楼梯时，可以迈一阶楼梯dp[n-1]，或者迈两阶楼梯上dp[n-2]，因此可得最终爬上去n阶台阶的方法共有dp[n-1]+dp[n-2]种方法，dp的方法是爬到第n阶台阶总共有多少种方法，而不是走了几步，因此递推关系仍是斐波那契数列。已知斐波那契数列递推式为dp[i]=dp[i-1]+dp[i-2]，因此求第n个数只需要逐渐相加获得。1. 1 阶 + 1 阶 + 1 阶。1. 1 阶 + 1 阶。2. 1 阶 + 2 阶。
代码随想录算法训练营day37｜动态规划part05
qq_39065682的博客
08-08 228
感觉今天学的技巧性都挺强的，完全背包的还得再看看；
6. Z 字形变换【 力扣(LeetCode) 】
yyh520025的博客
08-09 518
将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“PAHNAPLSIIGYIR”。
力扣：3132. 找出与数组相加的整数 II（Java，枚举）
jungleirim的博客
08-09 235
移除 nums1 中下标为 [0,4] 的两个元素，并且每个元素与 -2 相加后，nums1 变为 [18,14,10] ，与 nums2 相等。移除 nums1 中下标为 [0,3] 的两个元素，并且每个元素与 2 相加后，nums1 变为 [7,7] ，与 nums2 相等。执行上述操作后，nums1 和 nums2 相等。输入：nums1 = [4,20,16,12,8], nums2 = [14,18,10]输入：nums1 = [3,5,5,3], nums2 = [7,7]
【手撕数据结构】二叉树和堆
apple_61439616的博客
08-09 740
首先看到结构体的定义及声明，是不是回想起了我们之前所学的顺序表，因为顺序表的底层其实也是一种数组int size;}Hp;
leetcode 560.和为k的子数组
m0_73917165的博客
08-09 226
我们求出来前缀和之后,其实也就是变相知道了某个区间的和,就如上面所说的,如果两个区间相减为k,那么我们只需要求出该前缀和-k存不存在有那么一个区间是刚刚成立的那个式子的值.逆向思维.思路二:前缀和.对于子序列问题,一般来说就会用到滑动窗口的双指针,以及前缀和这种思想.这里也是,前缀和对于子序列求解的本质其实就是对于各个区间相加减得到全部子区间的过程.思路一:可以仿照数据结构黑皮书中第一章演示最大子段和的做法,我们可以暴力求解,然后在暴力做法的基础上,边计算边判断,降低时间复杂度至O(n2).
LeetCode——3131.找出与数组相加的整数I
玄昌盛不会编程
08-08 238
LeetCode——3131.找出与数组相加的整数I
CSP-J 复赛 模拟题7 and 解析
xingdjk888的博客
08-08 823
素数，又称质数，是指除 11 和其自身之外，没有其他约数的正整数。例如 2,3,5,132,3,5,13 都是素数，而 4,9,12,184,9,12,18 则不是。特别地，规定 11 不是素数（因此自然数的质因数分解就是唯一的）。如果一个数字的任意前缀所对应的数字都是一个素数，那么我们称这个数字是一个超级素数，例如：233233是一个超级素数，因为它的三个不同的前缀2,23,2332,23,233都是素数。而457457本身虽然是一个素数，但是它的前缀4,454,45却不是素数，所以457457不是一个超
C语言---指针数组和数组指针，函数指针
2301_80464770的博客
08-08 453
/指针数组int *arr[5] //函数指针int (*p)(int,int) = add;printf("请选择你要进行什么计算（1：加、2：减、3：乘、4.除）:");//(arr[choice-1])将数组内用户选择的算法函数指针传递给p。int (*p)[5] 这个声明定义了一个指针 ，指向一个包含5个整数的数组。printf("请输入你要进行计算的两个整数(之间用/分隔):");//int (*p)(int,int)定义一个函数指针。例：int (*p)(int,int) = add;
拥抱TDD：测试驱动开发的力量
"TDD INTRUDUCTION: Test-Driven Development (TDD) 是敏捷开发过程中的重要组成部分，引入TDD可以对项目管理和个人成长带来益处。" 在软件开发领域，测试驱动开发（Test-Driven Development，简称TDD）是一种以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值