【C++高阶数据结构】红黑树：全面剖析与深度学习

已于 2024-08-15 19:28:47 修改
阅读量1.5k 收藏 71
点赞数 84
分类专栏： C++从入门到精通 文章标签： c++ 数据结构 算法 开发语言
于 2024-07-29 22:28:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50776420/article/details/140781078
版权

🌈 个人主页：Zfox_
🔥 系列专栏：C++从入门到精通

目录


🚀 前言：红黑树与AVL树的比较

红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O( l o g 2 N log_2 N log2​N)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

一： 🔥 红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。

在这里插入图片描述

二： 🔥 红黑树的性质

1. 每个结点不是红色就是黑色
2. 根节点是黑色的
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

思考：为什么满足上面的性质，红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

三： 🔥 红黑树节点的定义和结构

🚀 3.1 基本元素

  • _left：指向节点的左子节点的指针
  • _right：指向节点的右子节点的指针
  • _parent：指向节点的父节点的指针
  • _kv：一个结构体或配对（pair），包含节点的键值（key）和值（value）。这取决于红黑的具体用途，可能只包含键或包含键值对。
  • _col：表示当前节点的颜色。

🚀 3.2 节点颜色

在上面的定义中，_col 成员变量用于表示节点的颜色，通过 Color 枚举类型来定义，可以是 RED 或 BLACK。

🚀 3.3 构造函数

初始化一个新节点时，通常需要一个构造函数，它接受一个键值对（或仅键），并设置节点的左子节点、右子节点、父节点和颜色（初始化为红色）

🚀 3.4 红黑树节点的定义

// 节点的颜色
enum Color{RED, BLACK};
// 红黑树节点的定义
template<class ValueType>
struct RBTreeNode
{
	RBTreeNode(const ValueType& data = ValueType()，Color color = RED)
	: _pLeft(nullptr), _pRight(nullptr), _pParent(nullptr)
	, _data(data), _color(color)
	{}
	RBTreeNode<ValueType>* _pLeft;       // 节点的左孩子
	RBTreeNode<ValueType>* _pRight;      // 节点的右孩子
	RBTreeNode<ValueType>* _pParent;     // 节点的双亲(红黑树需要旋转，为了实现简单给
	出该字段)
	ValueType _data;       // 节点的值域
	Color _color;          // 节点的颜色
}

思考：在节点的定义中，为什么要将节点的默认颜色给成红色的？
答案：优先增加黑色节点会破坏红黑树的默认规则和结构，而新插入红色节点可以通过调整来适应规则，不一定会破坏结构。

四：🔥 红黑树的插入操作

  • 红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：
    1. 按照二叉搜索的树规则插入新节点
template<class ValueType>
class RBTree
{
	//……
	bool Insert(const ValueType& data)
	{
		PNode& pRoot = GetRoot();
		if (nullptr == pRoot)
		{
		pRoot = new Node(data, BLACK);
		// 根的双亲为头节点
		pRoot->_pParent = _pHead;
		_pHead->_pParent = pRoot;
		}
		else
		{
		// 1. 按照二叉搜索的树方式插入新节点
		// 2. 检测新节点插入后，红黑树的性质是否造到破坏，
		// 若满足直接退出，否则对红黑树进行旋转着色处理
		}
		// 根节点的颜色可能被修改，将其改回黑色
		pRoot->_color = BLACK;
		_pHead->_pLeft = LeftMost();
		_pHead->_pRight = RightMost();
		return true;
	}
private:
	PNode& GetRoot(){ return _pHead->_pParent;}
	// 获取红黑树中最小节点，即最左侧节点
	PNode LeftMost();
	// 获取红黑树中最大节点，即最右侧节点
	PNode RightMost();
private:
	PNode _pHead;
};

2. 检测新节点插入后，红黑树的性质是否造到破坏

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：

约定 : cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

  • 情况一: cur为红，p为红，g为黑，u存在且为红
    在这里插入图片描述
    cur和p均为红，违反了性质三，此处能否将p直接改为黑？

解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

  • 情况二 : cur为红，p为红，g为黑，u不存在/u存在且为黑
    在这里插入图片描述
    p为g的左孩子，cur为p的左孩子，则进行右单旋转；相反，
    p为g的右孩子，cur为p的右孩子，则进行左单旋转
    p、g变色–p变黑，g变红

  • 情况三 : cur为红，p为红，g为黑，u不存在 / u存在且为黑
    在这里插入图片描述
    解决方式： p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反，p为g的右孩子，cur为p的左孩子，则针对p做右单旋转则转换成了情况2
    具体实现代码如下：

	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr) {
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		// 找到插入位置
		Node* cur = _root, * parent = nullptr;
		while (cur)
		{
			if (cur->_kv.first == kv.first) return false;
			else if (cur->_kv.first < kv.first) {
				parent = cur;
				cur = cur->_right;
			}
			else {
				parent = cur;
				cur = cur->_left;
			}
		}
		cur = new Node(kv);
		//	新增节点 颜色优先选择红色
		cur->_col = RED;
		if (kv.first > parent->_kv.first) parent->_right = cur;
		else parent->_left = cur;

		cur->_parent = parent;

		// 1、parent不存在，cur就是根了，出去后把根处理成黑的
		// 2、parent存在，且为黑
		// 3、parent存在，且为红，继续循环处理
		// 变色了之后持续网上处理
		while (parent && parent->_col == RED)          // 父亲颜色是红色就需要继续处理（来连续的红节点， 关键看叔叔）
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)               // 父亲在爷爷的左边 右边就是对称的
			{
				Node* uncle = grandfather->_right;
				//    g
				//  p   u
				if (uncle && uncle->_col == RED)     // 如果叔叔存在且为红色
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = grandfather->_parent;
				}
				else {                               // 叔叔存在且为黑或者不存在  那么旋转+变色
					//    g
					//  p   u
					// c
					// 单旋
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else {
						//    g
						//  p   u
						//    c
						// 双旋
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;                           // 局部根节点是黑色那么就可以退出了
				}
			}
			else {
				//    g
				//  u   p
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)     // 如果叔叔存在且为红色
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = grandfather->_parent;
				}
				else {                               // 叔叔存在且为黑或者不存在  那么旋转+变色
					//    g
					//  u   p
					//        c
					// 单旋
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else {
						//    g
						//  u   p
						//    c
						// 双旋
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;                           // 局部根节点是黑色那么就可以退出了
				}
			}
		}
		_root->_col = BLACK;

		return true;
	}

五：🔥 红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  2. 检测其是否满足红黑树的性质
    具体代码如下：
	bool IsBalance()
	{
		if (_root == nullptr)
			return true;

		if (_root->_col == RED)
		{
			return false;
		}

		// 参考值
		int refNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++refNum;
			}

			cur = cur->_left;
		}

		return Check(_root, 0, refNum);
	}

	bool Check(Node* root, int blackNum, const int refNum)
	{
		if (root == nullptr)
		{
			//cout << blackNum << endl;
			if (refNum != blackNum)
			{
				cout << "存在黑色节点的数量不相等的路径" << endl;
				return false;
			}

			return true;
		}

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在连续的红色节点" << '\n';
			return false;
		}

		if (root->_col == BLACK)
		{
			blackNum++;
		}

		return Check(root->_left, blackNum, refNum) && Check(root->_right, blackNum, refNum);
	}

六：🔥 红黑树的完整代码

#pragma once

#include <iostream>
#include <algorithm>
#include <cstring>
#include <set>
#include <map>
#include <assert.h>

using namespace std;

enum Color
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode {
	pair<K, V> _kv;
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;		
	Color _col;

	RBTreeNode(const pair<K, V>& kv)
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
	{}
};

template<class K, class V>
class RBTree {
	typedef RBTreeNode<K, V> Node;
public:
	RBTree() = default;

	RBTree(const RBTree<K, V>& t)
	{
		_root = Copy(t._root);
	}

	RBTree<K, V>& operator=(RBTree<K, V> t)
	{
		swap(_root, t._root);
		return *this;
	}

	~RBTree()
	{
		Destroy(_root);
		_root = nullptr;
	}


	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr) {
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		// 找到插入位置
		Node* cur = _root, * parent = nullptr;
		while (cur)
		{
			if (cur->_kv.first == kv.first) return false;
			else if (cur->_kv.first < kv.first) {
				parent = cur;
				cur = cur->_right;
			}
			else {
				parent = cur;
				cur = cur->_left;
			}
		}
		cur = new Node(kv);
		//	新增节点 颜色优先选择红色
		cur->_col = RED;
		if (kv.first > parent->_kv.first) parent->_right = cur;
		else parent->_left = cur;

		cur->_parent = parent;

		// 1、parent不存在，cur就是根了，出去后把根处理成黑的
		// 2、parent存在，且为黑
		// 3、parent存在，且为红，继续循环处理
		// 变色了之后持续网上处理
		while (parent && parent->_col == RED)          // 父亲颜色是红色就需要继续处理（来连续的红节点， 关键看叔叔）
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)               // 父亲在爷爷的左边 右边就是对称的
			{
				Node* uncle = grandfather->_right;
				//    g
				//  p   u
				if (uncle && uncle->_col == RED)     // 如果叔叔存在且为红色
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = grandfather->_parent;
				}
				else {                               // 叔叔存在且为黑或者不存在  那么旋转+变色
					//    g
					//  p   u
					// c
					// 单旋
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else {
						//    g
						//  p   u
						//    c
						// 双旋
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;                           // 局部根节点是黑色那么就可以退出了
				}
			}
			else {
				//    g
				//  u   p
				Node* uncle = grandfather->_left;
				if (uncle && uncle->_col == RED)     // 如果叔叔存在且为红色
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = grandfather->_parent;
				}
				else {                               // 叔叔存在且为黑或者不存在  那么旋转+变色
					//    g
					//  u   p
					//        c
					// 单旋
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else {
						//    g
						//  u   p
						//    c
						// 双旋
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;                           // 局部根节点是黑色那么就可以退出了
				}
			}
		}
		_root->_col = BLACK;

		return true;
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	Node* Copy(Node * root)
		{
			if (root == nullptr)
				return nullptr;

			Node* newRoot = new Node(root->_kv);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);

			return newRoot;
		}

	void Destroy(Node * root)
		{
			if (root == nullptr)
				return;

			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
		}

	void InOrder()
	{
		_InOrder(_root);
	}

	int Height()
	{
		return _Height(_root);
	}

	// 检查是否是红黑树
	bool IsBalance()
	{
		if (_root == nullptr)
			return true;

		if (_root->_col == RED)
		{
			return false;
		}

		// 参考值
		int refNum = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++refNum;
			}

			cur = cur->_left;
		}

		return Check(_root, 0, refNum);
	}

private:
	bool Check(Node* root, int blackNum, const int refNum)
	{
		if (root == nullptr)
		{
			//cout << blackNum << endl;
			if (refNum != blackNum)
			{
				cout << "存在黑色节点的数量不相等的路径" << endl;
				return false;
			}

			return true;
		}

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << root->_kv.first << "存在连续的红色节点" << '\n';
			return false;
		}

		if (root->_col == BLACK)
		{
			blackNum++;
		}

		return Check(root->_left, blackNum, refNum) && Check(root->_right, blackNum, refNum);
	}

	int _Size(Node* root)
	{
		return root == nullptr ? 0 : _Size(root->_left) + _Size(root->_right) + 1;
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	void RotateL(Node * parent)
		{
			Node* subR = parent->_right;
			Node* subRL = subR->_left;

			parent->_right = subRL;
			if (subRL) subRL->_parent = parent;

			Node* parent_parent = parent->_parent;

			subR->_left = parent;
			parent->_parent = subR;

			if (parent_parent == nullptr)
			{
				_root = subR;
				subR->_parent = nullptr;
			}
			else {
				if (parent == parent_parent->_left) parent_parent->_left = subR;
				else parent_parent->_right = subR;

				subR->_parent = parent_parent;
			}
		}


	void RotateR(Node * parent)
		{
			Node* subL = parent->_left;
			Node* subLR = parent->_left->_right;

			parent->_left = subLR;
			if (subLR) subLR->_parent = parent;

			Node* parent_parent = parent->_parent;

			subL->_right = parent;
			parent->_parent = subL;


			if (parent_parent == nullptr)
			{
				_root = subL;
				subL->_parent = nullptr;
			}
			else {
				if (parent == parent_parent->_left)
				{
					parent_parent->_left = subL;
				}
				else {
					parent_parent->_right = subL;
				}
				subL->_parent = parent_parent;
			}
		}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << '\n';
		_InOrder(root->_right);
	}


	Node* _root = nullptr;

};

void TestRBTree1()
{
	RBTree<int, int> t;
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	// int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : a)
	{

		t.Insert({ e, e });
	}

	t.InOrder();
	cout << t.IsBalance() << endl;
}

以上就是红黑树的讲解与完整实现过程，红黑树因为其自平衡的特性，及通过节点颜色来操作其树形结构的特点，极大的提高了数据存储及处理的效率，需要我们好好掌握，觉得这篇博客对你有帮助的，可以点赞收藏关注支持一波~😉
在这里插入图片描述

Zfox_
关注
专栏目录
【C++高阶】精通AVL树：全面剖析与深度学习
Zfox的博客
07-21 1846
数据结构中AVL树的全面剖析与深度学习
【C++高阶】深入理解红黑树：数据结构与算法之美
EterNity_TiMe_的计算机学习之路
07-08 1784
在数据结构的浩瀚星空中，红黑树犹如一颗璀璨的明珠，以其独特的自平衡特性和高效的搜索能力，成为了计算机科学领域中不可或缺的一部分。红黑树，作为二叉搜索树的一种变体，通过引入节点颜色的概念和一系列复杂的旋转操作，巧妙地解决了传统二叉搜索树在极端情况下退化为链表的问题
【C++高阶】哈希：全面剖析与深度学习
Zfox的博客
07-31 1697
详细讲解了哈希的概念和哈希函数的原理及实现
【高阶数据结构】红黑树详解
m0_70980326的博客
08-17 2499
红黑树详解
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 21万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
C++笔记：从零开始一步步手撕高阶数据结构红黑树
ljh1257的博客
03-17 732
文章研究了红黑树概念，红黑树维护平衡的规则，AVL和红黑树之间的简单对比，如何去描述设计一棵红黑树，如何通过插入构建一棵红黑树，最后对构建好的红黑树进行炎症性测试
高阶数据结构： 红黑树
sea18323的博客
02-16 242
红黑树的特性：红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。性质：1.每个结点不是红色就是黑色2.根节点是黑色的3.如果一个节点是红色的，则它的两个孩子结点是黑色的补：不存在连续的红节点，但存在连续的黑节点4.对于每个结点，从该结点到其所U有后代叶结点的简单路径上，均 包含相同数目的黑色结点5.
【数据结构高阶】红黑树
m0_70811813的博客
12-10 1079
本期详细分析了红黑树的性质和结构，实现了红黑树的底层结构，并对其进行了验证
高阶数据结构 —— 红黑树(较平衡搜索树)
lyzzs222的博客
10-15 582
红黑树 的 这些 细节，你得懂！！！
初阶数据结构+高阶数据结构，分别用c、c++来实现.zip
10-24
本资料包"初阶数据结构+高阶数据结构，分别用c、c++来实现.zip"提供了对数据结构的初级和高级理解，并通过这两种语言的实践代码来加深理解。 首先，让我们深入了解一下初阶数据结构。基础的数据结构通常包括数组、...
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 平衡搜索树 — 红黑树
coding-hwz
10-24 482
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 平衡搜索树 — 红黑树一、基本概念 一、基本概念 红黑树是这样的一棵二叉搜索树：树中每一个节点的颜色或者是红色或者是黑色。红-黑树的其他特征可以用相应的扩充二叉树来说明： ① 根节点和所有外部节点都是黑色。 ② 在根至外部节点路径上，没有连续两个节点是红色。 ③ 在所有根节点至外部节点的路径上，黑色节点的数目相同。 红黑树还有另一种等价，它取决于父子节点间的指针颜色。从父节点指向黑色孩子的指针是黑色，从父节点指向红色孩子的指针是红色。另外还有： ①
高级数据结构：红黑树、B树、并查集，实现与原理全解析
数据结构概述与重要性 数据结构是计算机科学的基础，它决定了如何存储、组织和处理数据。在IT行业中，高效的数据结构可以显著提高软件性能，优化资源使用，以及支持复杂算法的实现。无论是在软件开发、系统设计，...
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 9万+
C/C++学习路线总结与分享
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1210
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
使用socket编程来实现一个简单的C/S模型（TCP协议）
caiji0169的博客
10-02 1720
下图是基于TCP协议的客户端/服务器程序的一般流程：服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。数据传输的过程：建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，
大话C++：第15篇 友元
最新发布
whccf的博客
10-09 752
友元（Friend）是C++中的一个特殊概念，它允许一个类或函数访问另一个类的私有和保护成员。友元可以是一个函数，也可以是一个类。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 287
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
白乐天_ξ( ✿＞◡❛)的博客
10-06 636
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
评论 53
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值