Day7：有序二叉树（二叉搜索树）

已于 2022-08-17 09:06:37 修改
阅读量1.6k 收藏 3
点赞数 3
文章标签： 算法
于 2022-07-24 09:51:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjjaibc/article/details/125941826
版权

目录

一、有序二叉树基础

        1.    有序的含义：

        2.每棵二叉搜索树的子树也是一棵二叉搜索树​编辑

        3.二叉搜索树的特性

二、常用操作：

        1.构建基本类型

        2.查找结点findNode

        3.遍历二叉树(中序->有序)

        4.插入节点

        5.删除节点

        6.释放各个节点

三、存放自定义类型的二叉搜索树(完整代码

一、有序二叉树基础

        1.    有序的含义：

                升序    :
            左 < 根 < 右  
                降序    :
            左 > 根 > 右      

        2.每棵二叉搜索树的子树也是一棵二叉搜索树

        3.二叉搜索树的特性

     中序遍历是一个有序序列，是从小到大排序的，2-3-4-7-8-10-12-18

二、常用操作：

        1.构建基本类型

        2.查找结点findNode

根据二叉搜索树的有序的性质，可以利用二分查找的方式->找到(此处采用迭代方式实现)

//功能五：查找指定节点
template<class T>
Node<T>* Tree<T>::findNode(const T& data)
{
	Node<T>* pTemp = pRoot;
	while (pTemp)
	{
		if (data < pTemp->data)
		{
			pTemp = pTemp->pLeft;
		}
		else if (data > pTemp->data)
		{
			pTemp = pTemp->pRight;
		}
		else
			return pTemp;
	}
	return nullptr;
}

        3.遍历二叉树(中序->有序)

根据type的值，然后递归（调整位置即可），实现遍历。

//功能四：遍历
template<class T>
void Tree<T>::travel(int type)
{
	switch (type)
	{
	case -1:
		_preTravel(pRoot); break;
	case 0:
		_midTravel(pRoot); break;
	case 1:
		_behTravel(pRoot); break;
	}
	cout << endl;
}
template<class T>
void Tree<T>::_preTravel(Node<T>*p)
{
	if (p == nullptr)return;
	cout << p->data<<" ";
	_preTravel(p->pLeft);
	_preTravel(p->pRight);
}
template<class T>
void Tree<T>::_midTravel(Node<T>* p)
{
	if (p == nullptr)return;
	_midTravel(p->pLeft);
	cout << p->data<<" ";
	_midTravel(p->pRight);
}
template<class T>
void Tree<T>::_behTravel(Node<T>* p)
{
	if (p == nullptr)return;
	_behTravel(p->pLeft);
	_behTravel(p->pRight);
	cout << p->data<<" ";
}

        4.插入节点

在左根右的情况下，需要不断递归，找到合适的插入位置。

注意：递归的终止条件,子根为nullptr，然后创建新的节点，然后赋值。

//功能一：插入节点
template <class T>
void Tree<T>::_insert(Node<T>*&pRoot,const T& data)
{//插入的顺序:左< 根 <右
	if (pRoot == nullptr)
	{
		Node<T>* pNew = new Node<T>(data);
		pRoot = pNew;
		return;//   7.23别忘记return
	}
	if (pRoot->data > data) { _insert(pRoot->pLeft, data); }
	else { _insert(pRoot->pRight, data); }
}

        5.删除节点

/*Args：pDel待删除节点 pRoot树的根节点  pDelParent待删节点的父节点*/

情况一：findNode没找到该节点->return

情况二：需要删除的是根节点->（统一规则）

        （i）若如果pDel有右孩子，循环遍历出右孩子的最小左孩子，将pDel的左孩子(就算没有为nullptr也是可行的)给其最小左孩子领养->释放pDel

        （ii）若pDel没有右孩子，让左孩子直接成为新的pRoot->释放pDel

情况三：需要删除的是子树中的结点

                ->重写二分查找，定位pDel和pDelParent(相当于pre指针)位置

        (i)若pDel在parent的左孩子

                （a）若pDel有右孩子->寻找其pDel右孩子的最小左孩子

                          (方便pDel的左孩子被其领养)->让父节点领养pDel的右孩子

                                (此时已经将pDel的左孩子归pDel右孩子的最小左孩子领养了)

                （b）若pDel无右孩子->让父亲节点直接领养pDel的左孩子

        (ii)pDel是parent的右孩子

                （a）若pDel有右孩子->寻找其pDel右孩子的最小左孩子

                                (方便pDel的左孩子被其领养)

                                ->让父节点领养pDel的右孩子

                                (此时已经将pDel的左孩子归pDel右孩子的最小左孩子领养了)

                （b）若pDel无右孩子->让父亲节点直接领养pDel的左孩子

//功能三：删除指定节点
template<class T>
void Tree <T>::_deleteNode(const T & data)
{
	Node<T>* pDel = findNode(data);
	//情况一：没找到
	if (pDel == nullptr)
	{
		cout << "未找到,插入失败" << endl;
	}
	//情况二:找到的是根节点
	if (pDel == pRoot)
	{
		if (pDel->pRight)//若根节点有右孩子->寻找pDel右孩子的最小左孩子(方便pDel的左孩子被其领养)
		{
			Node<T>* pMove = pDel->pRight;
			while(pMove->pLeft)
			{
				pMove = pMove->pLeft;
			}//找到最小左孩子
			pMove->pLeft = pDel->pLeft;//领养
			pRoot = pDel->pRight;//让右孩子成为新的根节点
		}
		else//根节点无右孩子->让根节点的左孩子成为新的根节点
		{
			pRoot = pDel->pLeft;
		}
		delete pDel;//处理掉原先的旧根节点
		pDel = nullptr;
	}//情况三:找到的是子树的结点
	else
	{//优先先将pDel和其父节点pDelParent找出来(必定存在)->二分
		Node<T>* pDelParent = pRoot;
		while (pDelParent->pLeft != pDel && pDelParent->pRight != pDel)//找到pDel退出
		{
			if (pDelParent->data < data)pDelParent = pDelParent->pRight;
			else if (pDelParent->data > data)pDelParent = pDelParent->pLeft;
		}//跳出循环后，此时的parent指针指向pdel
		//(i)若pDel在parent的左孩子
		if (pDel == pDelParent->pLeft)
		{
			if (pDel->pRight)//若pDel有右孩子->寻找其pDel右孩子的最小左孩子(方便pDel的左孩子被其领养)
			{
				Node<T>* pMove = pDel->pRight;
				while (pMove->pLeft)
				{
					pMove = pMove->pLeft;
				}//找到最小左孩子
				pMove->pLeft = pDel->pLeft;//领养pDel的左孩子
				pDelParent->pLeft = pDel->pRight;//让父节点领养pDel的右孩子(此时已经将pDel的左孩子归pDel右孩子的最小左孩子领养了)
			}
			else//pDel无右孩子->让父亲节点直接领养pDel的左孩子
			{
				pDelParent->pLeft = pDel->pLeft;
			}
			delete pDel;//处理掉待删除节点
			pDel = nullptr;
		}
		else//(ii)pDel是parent的右孩子
		{
			if (pDel->pLeft)//若pDel有右孩子->寻找其pDel右孩子的最小左孩子(方便pDel的左孩子被其领养)
			{
				Node<T>* pMove = pDel->pRight;
				while (pMove->pLeft)
				{
					pMove = pMove->pLeft;
				}//找到最小左孩子
				pMove->pLeft = pDel->pLeft;//领养pDel的左孩子
				pDelParent->pRight = pDel->pRight;//让父节点领养pDel的右孩子(此时已经将pDel的左孩子归pDel右孩子的最小左孩子领养了)
			}
			else//pDel无右孩子->让父亲节点直接领养pDel的左孩子
			{
				pDelParent->pRight = pDel->pLeft;
			}
			delete pDel;//处理掉待删除节点
			pDel = nullptr;
		}
	}
}

有关此方法为何能保证删除之后还能保证有序的一些思考： 

        基本核心操作待删节点的思路->看待删节点是否有右孩子，有，就将pDel的左孩子归位？归哪？左<根<右 显然左孩子要被右孩子领养，还要保证二叉搜索树的结构的话，右边都是大于左边的，所以肯定要找到右孩子的最小左孩子，才是pDel的左孩子的归宿。若没有右孩子，直接移动即可。

        6.释放各个节点

利用二叉树的递归特性，逐一递归释放即可。

//功能二：释放各个节点
template<class T>
void Tree<T>::_clear(Node<T>*pDel)
{
	if (pDel == nullptr)return;
	_clear(pDel->pLeft);
	_clear(pDel->pRight);
	delete pDel;
	pDel = nullptr;
}

三、存放自定义类型的二叉搜索树(完整代码)

bug：(以及重载时，const 的处理！！！)C++报错：友元重载＜＜无法输出const char*类型&&一堆string中的未定义&&模板未用T表示(内部直接int....)_https://blog.csdn.net/zjjaibc/article/details/125955646?spm=1001.2014.3001.5501

Stu.h

#pragma once
#include<string>
#include<iostream>
using namespace std;
class Stu
{
public:
	Stu(int id = -1, std::string name = (string)"default"):id(id),name(name){}
	friend ostream& operator<<(ostream& out, const Stu& s);
	bool operator>( Stu& t);
private:
	int id;
	string name;
};

Stu.cpp

#include"Stu.h"
#include<string>
std::ostream& operator<<(ostream& out, const Stu& s)
{
	out << string("学号:") << s.id <<string(" 姓名:") << s.name<<"  ";
	return out;
}
bool Stu::operator>( Stu& t)
{
	return id>t.id;
}

Tree.h

#pragma once
#pragma once
#include<iostream>
#include<string>
using namespace std;
class Stu;
template <class T>
struct Node
{
	T data;
	Node* pLeft;
	Node* pRight;
	Node(const T& data)
	{
		this->data = data;
		pLeft = pRight = nullptr;
	}
};
template <class T>
class Tree
{
public:
	Tree() { pRoot = nullptr; }
	~Tree() { clear(pRoot); }
	Node<T>* findNode( T& data);
	//释放结点
	void clear(Node<T>* pDel) { _clear(pDel); }
	//插入节点
	void insert( T& data) { _insert(pRoot, data); }
	//删除节点
	void deleteNode( T& data) { _deleteNode(data); }
	//遍历
	void travel(int type = 0);//-1表示前序遍历,默认中序遍历，1表示后序遍历
private:
	void _clear(Node<T>* pDel);
	void _insert(Node<T>*& pRoot, T& data);
	void _deleteNode( T& data);
private:
	void _preTravel(Node<T>* p);//先序
	void _midTravel(Node<T>* p);//中序遍历
	void _behTravel(Node<T>* p);//后序遍历
private:
	Node<T>* pRoot;
};

//功能一：插入节点
template <class T>
void Tree<T>::_insert(Node<T>*& pRoot, T& data)
{//插入的顺序:左< 根 <右
	if (pRoot == nullptr)
	{
		Node<T>* pNew = new Node<T>(data);
		pRoot = pNew;
		return;//   7.23别忘记return
	}
	if (pRoot->data > data) { _insert(pRoot->pLeft, data); }
	else { _insert(pRoot->pRight, data); }
}
//功能二：释放各个节点
template<class T>
void Tree<T>::_clear(Node<T>* pDel)
{
	if (pDel == nullptr)return;
	_clear(pDel->pLeft);
	_clear(pDel->pRight);
	delete pDel;
	pDel = nullptr;
}
//功能三：删除指定节点
template<class T>
void Tree <T>::_deleteNode( T& data)
{
	Node<T>* pDel = findNode(data);
	//情况一：没找到
	if (pDel == nullptr)
	{
		cout << "未找到,插入失败" << endl;
	}
	//情况二:找到的是根节点
	if (pDel == pRoot)
	{
		if (pDel->pRight)//若根节点有右孩子->寻找pDel右孩子的最小左孩子(方便pDel的左孩子被其领养)
		{
			Node<T>* pMove = pDel->pRight;
			while (pMove->pLeft)
			{
				pMove = pMove->pLeft;
			}//找到最小左孩子
			pMove->pLeft = pDel->pLeft;//领养
			pRoot = pDel->pRight;//让右孩子成为新的根节点
		}
		else//根节点无右孩子->让根节点的左孩子成为新的根节点
		{
			pRoot = pDel->pLeft;
		}
		delete pDel;//处理掉原先的旧根节点
		pDel = nullptr;
	}//情况三:找到的是子树的结点
	else
	{//优先先将pDel和其父节点pDelParent找出来(必定存在)->二分
		Node<T>* pDelParent = pRoot;
		while (pDelParent->pLeft != pDel && pDelParent->pRight != pDel)//找到pDel退出
		{
			if (data > pDelParent->data)pDelParent = pDelParent->pRight;
			else if (pDelParent->data > data)pDelParent = pDelParent->pLeft;
		}//跳出循环后，此时的parent指针指向pdel
		//(i)若pDel在parent的左孩子
		if (pDel == pDelParent->pLeft)
		{
			if (pDel->pRight)//若pDel有右孩子->寻找其pDel右孩子的最小左孩子(方便pDel的左孩子被其领养)
			{
				Node<T>* pMove = pDel->pRight;
				while (pMove->pLeft)
				{
					pMove = pMove->pLeft;
				}//找到最小左孩子
				pMove->pLeft = pDel->pLeft;//领养pDel的左孩子
				pDelParent->pLeft = pDel->pRight;//让父节点领养pDel的右孩子(此时已经将pDel的左孩子归pDel右孩子的最小左孩子领养了)
			}
			else//pDel无右孩子->让父亲节点直接领养pDel的左孩子
			{
				pDelParent->pLeft = pDel->pLeft;
			}
			delete pDel;//处理掉待删除节点
			pDel = nullptr;
		}
		else//(ii)pDel是parent的右孩子
		{
			if (pDel->pLeft)//若pDel有右孩子->寻找其pDel右孩子的最小左孩子(方便pDel的左孩子被其领养)
			{
				Node<T>* pMove = pDel->pRight;
				while (pMove->pLeft)
				{
					pMove = pMove->pLeft;
				}//找到最小左孩子
				pMove->pLeft = pDel->pLeft;//领养pDel的左孩子
				pDelParent->pRight = pDel->pRight;//让父节点领养pDel的右孩子(此时已经将pDel的左孩子归pDel右孩子的最小左孩子领养了)
			}
			else//pDel无右孩子->让父亲节点直接领养pDel的左孩子
			{
				pDelParent->pRight = pDel->pLeft;
			}
			delete pDel;//处理掉待删除节点
			pDel = nullptr;
		}
	}
}
//功能四：遍历
template<class T>
void Tree<T>::travel(int type)
{
	switch (type)
	{
	case -1:
		_preTravel(pRoot); break;
	case 0:
		_midTravel(pRoot); break;
	case 1:
		_behTravel(pRoot); break;
	}
	cout << endl;
}
template<class T>
void Tree<T>::_preTravel(Node<T>* p)
{
	if (p == nullptr)return;
	cout << p->data << " ";
	_preTravel(p->pLeft);
	_preTravel(p->pRight);
}
template<class T>
void Tree<T>::_midTravel(Node<T>* p)
{
	if (p == nullptr)return;
	_midTravel(p->pLeft);
	cout << p->data << " ";
	_midTravel(p->pRight);
}
template<class T>
void Tree<T>::_behTravel(Node<T>* p)
{
	if (p == nullptr)return;
	_behTravel(p->pLeft);
	_behTravel(p->pRight);
	cout << p->data << " ";
}
//功能五：查找指定节点
template<class T>
Node<T>* Tree<T>::findNode( T& data)
{
	Node<T>* pTemp = pRoot;
	while (pTemp)
	{
		if (pTemp->data>data)
		{
			pTemp = pTemp->pLeft;
		}
		else if (data > pTemp->data)
		{
			pTemp = pTemp->pRight;
		}
		else
			return pTemp;
	}
	return nullptr;
}

Main:

#include"Stu.h"
#include"Tree.h"
//#include<string>
#include<vector>

using namespace std;

int main()
{
	Tree<Stu> m;
	vector<Stu> arr = { Stu(4,"a"),Stu(2,"b"),Stu(9,"li"),Stu(1, string("ddd")),Stu(7,"kk")};
	for (auto v : arr)
	{
		m.insert(v);
	}
	m.travel();
	//arr.reserve(4);
	for (auto v : arr)
	{
		m.deleteNode(v);
		m.travel();
	}
	m.travel();
	return 0;
}

输出：

学号:1 姓名:ddd   学号:2 姓名:b   学号:4 姓名:a   学号:7 姓名:kk   学号:9 姓名:li
学号:1 姓名:ddd   学号:2 姓名:b   学号:7 姓名:kk   学号:9 姓名:li
学号:1 姓名:ddd   学号:7 姓名:kk   学号:9 姓名:li
学号:1 姓名:ddd   学号:7 姓名:kk
学号:7 姓名:kk

_Ocean__
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构—树、有序二叉树
且将&的博客
12-05 420
树、有序二叉树
C语言判定一棵二叉树是否为二叉搜索树的方法分析
12-31
本文实例讲述了C语言判定一棵二叉树是否为二叉搜索树的方法。分享给大家供大家参考，具体如下： 问题 给定一棵二叉树，判定该二叉树是否是二叉搜索树（Binary Search Tree）？ 解法1:暴力搜索 首先说明一下二叉树和...
有序平衡二叉树(AVL树)
07-23
一棵AVL树或者是空树，或者是具有下列性质的二叉搜索树：它的左子树和右子树都是AVL树，且左子树和右子树的高度之差的绝对值不超过1。
【数据结构】二叉树的介绍
WINGREZ‘S BLOG
08-31 1598
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 二叉树 二叉树是一种特殊的有序树，它的每个结点最多只有两棵子树。它与度为2的有序树的区别在于：度为2的树至少有3个结...
数据结构之有序二叉树C语言版
Cukor丘克的博客
11-28 1457
数据结构之有序二叉树C语言版 文章目录数据结构之有序二叉树C语言版什么是有序二叉树有序二叉树的优点简单实现有序二叉树有序二叉树的样子有序二叉树的结构体描述有序二叉树的各个函数的实现主函数简单测试 什么是有序二叉树 从名字就可以知道的是有序二叉树是二叉树的一种，这种二叉树中的数据是排好顺序的，这里实现的默认使用从小到大的排序方式。就是从外界插入进来的数据不需要使用者自己排序，在插入数据的时候就已经自动排好序。有序二叉树又称为二叉搜索树。 有序二叉树的优点 数据插入进来就直接排好序 查询速度快 最坏的情况下
数据结构-非线性结构-树形结构：有序树 ----＞二叉树【动态数据结构】
u013250861的博客
05-03 1461
二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）排序二叉树(BST)的要求:顺序存储：将数据结构存储在固定的数组中，虽然在遍历速度上有一定的优势，但因所占空间比较大，是非主流二叉树 存储方式.二叉树通常以链式存储。链式存储：由于对节点的个数无法掌握，常见树的存储表示都转换成二叉树进行处理，子节点个数最多为2。 五、二叉树的遍历 1、广度优先遍历 2、深度优先遍历 三种深度优先遍历方式：...
详细图解,二叉排序树的遍历、删除、插入，通过bf优化构建成平衡二叉树(avl树)的原理
yadoufeng的专栏
05-28 1258
二叉排序树的插入，遍历，删除。插入时通过bf优化构建成平衡二叉树(avl树)的原理
数据结构之有序二叉树（1）：基础知识
Beau Wang
01-02 544
树是数据结构中的一种，那我们为什么需要树这样数据结构呢？ 首先我们先对数组存储结构和链式存储结构分析一下。 数组存储方式 优点：通过下表方式访问元素，速度快。对于有序数组没还可以使用二分查找提高检索速度。 缺点：如果要检索某一个具体值，效率比较低下。 链式存储方式 优点：在一定程度上对数组存储方式进行优化（比如插入一个节点，只需要将插入节点，链接到链表当中可删除的效率也很好）。 缺点：在进行检索时，效率仍然比较低，比如（检索某个数值，需要从头结点开始遍历）。 而树能提高数据存储，读取的效率，
有序二叉树，平衡二叉树，二三四树，红黑树
m0_61983575的博客
03-31 914
有序二叉树： 平衡二叉树具有以下特点： 1）它是一颗空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两颗子树都是一颗平衡二叉树。 2）平衡因子： 左子树的高度 - 右子树的高度 我们将平衡因子的绝对值小于1的的有序二叉树称为平衡二叉树 旋转：LL,RR LL RR LR RL 造成不平衡的节点最后插入 红黑树 红黑树：介于有序二叉树和平衡二叉树之间的树，最优二叉树 二三四树 红黑树 红黑树中的节点不是红色就是黑色 红黑树中根节点一定是黑
有序二叉树的实现
从今以后...
03-01 2702
有序二叉树，二叉搜索树的实现。完成了二叉树有序插入，节点删除，中序遍历，树高，搜索，删除匹配数据等功能。三个文件，bt.h，bs.cpp,test.cpp. #ifndef _BT_H_ #define _BT_H_ #include using namespace std; typedef struct bstreenode{ int data; struct bstreenode *
二叉树（详解）
qq_68006585的博客
11-13 3937
二叉树（详解）
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
用c语言编写的数据结构相关的二叉树的二叉搜索
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
二叉树 二叉树_基于C++实现的二叉搜索树
剑指Offer(Python多种思路实现):二叉搜索树的第K大节点
12-22
剑指Offer(Python多种思路实现):二叉搜索树的第K大节点 面试54题： 题目：二叉搜索树的第K大节点 题：给定一颗二叉搜索树，请找出其中的第k小的结点。例如， 5 / \ 3 7 /\ /\ 2 4 6 8 中，按结点数值大小顺序第三个...
一个ppt让你了解二叉搜索树的判断
11-22
二叉搜索树判断的ppt有动画，有递归讲解，二叉搜索树判断的ppt有动画，有递归讲解，十分详细,适合要做演示的老师和同学 二叉搜索树判断的ppt有动画，有递归讲解，二叉搜索树判断的ppt有动画，有递归讲解，十分详细,...
Leetcode 41. 缺失的第一个正数和Leetcode 155. 最小栈
2301_79614379的博客
04-20 1078
定义一个结构体，数组 data 用于存放推进的数据，数组 min 用于存放最小值，变量 top 存放最后进入的数在 data 的下标，变量 mintop 记录最小值在 min 中的下标。循环遍历数组 nums ，如果该位置的值大于 0 并且不小于数组长度，让哈希表 table 在该值的位置自加。获取堆栈中的最小元素时，根据 mintop 的值返回数组 miin 中的元素。返回栈顶元素时，根据 top 的值返回数组 data 中的元素。--> 返回 -3.输入：nums = [3,4,-1,1]
力扣---从中序与后序遍历序列构造二叉树
m0_71536793的博客
04-20 462
力扣 中序遍历 后序遍历 建树
算法刷题-16
qq_45773834的博客
04-21 676
学习来源： leetcode，牛客 https://programmercarl.com https://www.yuque.com/taxing-qarr6/hxitgt/dedugmp09knerdi1
力扣HOT100 - 543. 二叉树的直径
qq_61504864的博客
04-23 170
【代码】力扣HOT100 - 543. 二叉树的直径。
二叉树 二叉搜索树 红黑树
10-09
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树，它具有以下性质： 1. 左子树上所有节点的值都小于根节点的值； 2. 右子树上所有节点的值都大于根节点的值； 3. 左子树和右子树也都是二叉搜索树。 红黑...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

_Ocean__

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值