我的创作纪念日

机缘

当决定在CSDN上成为创作者时，最初的动力来自于记录日常学习的过程并且通过文章与他人进行技术交流；

日常学习过程中的记录
记录自己的学习过程是成长的关键，在CSDN上写下每天学到的新知识、遇到的困难以及突破的经验，不仅可以加深对知识的理解，还可以梳理自己的学习路径，让其他人受益于你我的经验。这样的记录也可以帮助我建立自己的学习品牌，吸引更多人关注我的文章；

通过文章进行技术交流
技术交流是CSDN社区的核心；通过撰写技术文章，可以向其他人展示我的技术见解、经验和独特的解决方案，与其他技术爱好者交流，不仅可以拓展自己的视野，还可以获得来自不同领域的灵感和建议，同时，通过评论和互动，还可以建立起与其他技术人员的联系，促进共同学习和成长；

---

收获

粉丝数量的增长
在创作的过程中，逐渐积累了一批关注我的粉丝；他们对我的文章感兴趣，并且持续关注我的更新；这种关注不仅是对我个人成长的认可，也是对我文章内容的肯定和支持；看到粉丝数量的增长，让我觉得自己的努力是有价值的，也鼓舞了我继续创作下去的动力；

正向反馈的增加
我的文章收到了很多正向的反馈，包括点赞、评论和阅读量的提升；这些反馈不仅是对我文章质量的认可，也是读者们对我的技术见解和经验分享的认可；每次看到读者留下鼓励的评论或者给予肯定的赞，我都感到非常开心和鼓舞，这让我更有动力去写出更多有价值的内容；

志同道合的前行者
通过在CSDN上的创作，我结识了许多志同道合的同行，他们来自不同的领域，但都对技术充满热情，乐于分享自己的经验和见解，与他们交流让我受益匪浅，不仅学到了新知识，还建立起了良好的人际关系，这些同行不仅是我的技术伙伴，也成为了我的朋友，我们相互支持、共同成长；

---

日常

创作融入生活
创作已经不仅仅是我技术发展的一部分，也是我生活的一部分；在学习过程中，我都会花费时间来写作；写作已经成为了我记录思考、分享经验的重要方式，通过写作，我可以更好地理清自己的思路，总结经验教训，也可以将自己的见解和想法传递给他人；

平衡创作与学业
在有限的精力下，我努力平衡创作与学业时间；我会合理安排时间，将创作融入到我的日常工作和学习中；利用学习间隙来进行创作，或者在学习的过程中发现问题、积累经验，然后将这些内容整理成文章分享出来；同时，我也会根据自己的时间和精力状况，灵活调整创作的频率和内容，保持一个平衡的状态；

创作与学习的互补关系
创作与我的工作学习有着密切的互补关系；通过创作，我可以将学习中的经验和知识进行总结和输出，进一步加深自己的理解；同时，创作也为我提供了一个学习的平台，通过写作过程中的思考和总结，我可以不断提升自己的专业水平和表达能力，从而更好地应对工作和学习中的挑战；

 

---

成就

最近学习到map与set的模拟实现，对红黑树做了深度剖析，展示红黑树底层代码实现如下：

// KeyOfT仿函数 取出T对象中的key
template <class K, class T,class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T, T*, T&> iterator;
	typedef RBTreeIterator<T, const T*, const T&> const_iterator;
	//左子树的最左结点(中序遍历的第一个)
	iterator begin()
	{
		Node* SubLeft = _root;
		while (SubLeft && SubLeft->_left)
		{
			SubLeft = SubLeft->_left;
		}
		return iterator(SubLeft);
	}
 
	//空结点
	iterator end()
	{
		return iterator(nullptr);
	}
	pair<iterator,bool> insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root), true);
		}
		Node* parent = nullptr;
		Node* cur = _root;
		KeyOfT kot;
		while (cur != nullptr)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data)>kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(iterator(cur), false);
			}
		}
		//开辟结点,存储数据，建立链接关系
		cur = new Node(data);
		Node* newnode = cur;
		if (kot(parent->_data) > kot(data))
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
 
		//平衡化操作
		while (parent && parent->_col == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
 
					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
 
					break;
				}
			}
			//parent==grandfather->_right
			else
			{
				Node* uncle = grandfather->_left;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
 
					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
 
					break;
				}
			}
		}
		_root->_col = BLACK;
		return make_pair(iterator(newnode), true);
	}
 
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
 
		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;
 
		subR->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = subR;
 
		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
	}
 
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
 
		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;
 
		subL->_right = parent;
 
		Node* ppnode = parent->_parent;
		parent->_parent = subL;
 
		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}
	//红黑树的检测
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
 
		_InOrder(root->_left);
		cout << root->_kv.first << endl;
		_InOrder(root->_right);
	}
 
	void InOrder()
	{
		_InOrder(_root);
	}
	bool Check(Node* cur)
	{
		if (cur == nullptr)
			return true;
 
		//检查红黑树性质二
		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}
 
		return Check(cur->_left) && Check(cur->_right);
	}
 
	iterator* Find(const T& data)
	{
		KeyOfT kot;//定义仿函数对象
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				cur = cur->_right;
			}
			else if (kot(cur->_data)  > kot(data))
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}
 
	bool Check(Node* cur, int blackNum, int refBlackNum)
	{
		if (cur == nullptr)
		{
			if (refBlackNum != blackNum)
			{
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}
 
			return true;
		}
 
		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}
 
		if (cur->_col == BLACK)
			++blackNum;
 
		return Check(cur->_left, blackNum, refBlackNum)
			&& Check(cur->_right, blackNum, refBlackNum);
	}
	bool IsRBTree()
	{
		//检查根结点是否为黑色
		if (_root && _root->_col == RED)
			return false;
 
		int refBlackNum = 0;//基准值
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
				refBlackNum++;
 
			cur = cur->_left;
		}
 
		return Check(_root, 0, refBlackNum);
	}
private:
	Node* _root = nullptr;
};

---

憧憬

今天，我站在这里，回望过去，展望未来；这份创作的心情，无论何时打开，都是新鲜的；我期待着在这不断成长的旅程上，与你们分享更多的故事、知识和经验；让我们一起创造、学习和成长；

        作为一名创作者，我深知路途可能是漫长和不确定的，但正是这个过程中的每一步都构成了我旅程的不可或缺的部分。无论是面对挑战还是庆祝成就，我都将坚持我的初心：不断学习、分享知识，并通过创作来记录和反思我的成长之路；