我的Map实现

最新推荐文章于 2024-10-11 21:08:57 发布
最新推荐文章于 2024-10-11 21:08:57 发布
阅读量1k 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiu824039983/article/details/52410803
版权
实习期间写了一个Map的实现，实验结果似乎要好过std::map，在这里贴出来，希望大家指教。 
#ifndef RBTREE_H
#define RBTREE_H

#include <assert.h>
#include <string.h>
#include <stdlib.h>

template<typename Key, typename Value>
class Cmap
{
#pragma region rbnode

	struct _rbnode
	{
		typedef enum {
			_red = 0,
			_black,
		}eColor;

		Key key;
		Value value;
		eColor color;

		_rbnode* right;
		_rbnode* left;
		_rbnode* parent;
	};

#pragma endregion

private:
#pragma region rbnode pool

	class _pool
	{
	public:
		_pool() : count(0)
		{

		}

		~_pool()
		{

		}

		int init(unsigned cnt)
		{
			count = cnt;
			memset(&buffer, 0, sizeof(__array));
			memset(&pool, 0, sizeof(__array));
			return increase();
		}

		int uninit()
		{
			for (unsigned i = 0; i < buffer.count; ++i)
			{
				void* buff = (void*)buffer[i];
				if (buff)
				{
					::free(buff);
					buff = 0;
				}
			}

			return true;
		}

		int increase()
		{
			_rbnode* buff = (_rbnode*)malloc(sizeof(_rbnode) * count);
			if (!buff)
				return false;
			buffer.push((intptr_t)buff);
			for (unsigned i = 0; i < count; ++i)
			{
				pool.push((intptr_t)buff);
				buff += 1;
			}
			return true;
		}

		_rbnode* alloc()
		{
			if (pool.count == 0)
			{
				if (!increase())
				{
					return 0;
				}
			}
			_rbnode* ret = (_rbnode*)pool[pool.count - 1];
			pool.count--;
			return ret;
		}

		void free(void* ptr)
		{
			if (ptr)
				pool.push((intptr_t) ptr);
		}

		struct __array
		{
			unsigned count;
			unsigned capacity;
			intptr_t* buffer;

			intptr_t operator[](const unsigned idx)
			{
				if (idx > count)
					return 0;
				return *(buffer + idx);
			}

			intptr_t push(intptr_t ptr)
			{
				if (capacity == count)
				{
					if (!increase())
						return 0;
				}
				buffer[count++] = ptr;
				return ptr;
			}

			int increase()
			{
				unsigned total = capacity << 1;
				if (total == 0)
					total = 4;

				unsigned char * tmp = (unsigned char *)malloc(total * sizeof(intptr_t));
				if (!tmp)
					return false;

				for (int i = 0; i < count; i++)
					*((intptr_t*)tmp + i) = *(buffer + i);

				::free(buffer);

				buffer = (intptr_t*)tmp;
				capacity = total;

				return true;
			}
		};
	private:
		__array buffer;
		__array pool;

		int count;
	};
#pragma endregion

public:
#pragma region iterator

	class Iterator
	{
		_rbnode* m_pNode;

	public:
		Iterator() : m_pNode(0) {}
		Iterator(_rbnode* rhs)
		{
			if (rhs == 0)
			{
				m_pNode = 0;
				return;
			}

			m_pNode = rhs;
		}
		Iterator& operator=(_rbnode* rhs)
		{
			if (rhs == 0)
			{
				m_pNode = 0;
				return *this;
			}

			m_pNode = rhs;
			return *this;
		}
		Iterator& operator=(const Iterator& rhs)
		{
			m_pNode = rhs.m_pNode;

			return *this;
		}
		Iterator& operator++()
		{
			m_pNode = NextTreeNode(m_pNode);

			if (m_pNode == 0) return *this;

			return *this;
		}
		Iterator& operator++(int)
		{
			m_pNode = NextTreeNode(m_pNode);

			return *this;
		}
		Iterator& operator--()
		{
			m_pNode = PrevTreeNode(m_pNode);

			return *this;
		}
		Iterator& operator--(int)
		{
			m_pNode = PrevTreeNode(m_pNode);

			return *this;
		}

		bool operator==(const Iterator& rhs)
		{
			return m_pNode == rhs.m_pNode;
		}

		bool operator!=(const Iterator& rhs)
		{
			return m_pNode != rhs.m_pNode;
		}

		bool operator!()
		{
			if (m_pNode == NULL)
				return true;
			return false;
		}

	public:
		Key GetKey() const
		{
			if (m_pNode == 0)
				return 0;
			return m_pNode->key;
		}
		Value GetValue() const
		{
			if (m_pNode == 0)
				return 0;
			return m_pNode->value;
		}
	};
#pragma endregion

public:
	Cmap() : root(0)
	{
		rbnodeAllocator.init(128);
	}
	Cmap(unsigned uCountInLine) : root(0)
	{
		rbnodeAllocator.init(uCountInLine);
	}
	~Cmap()
	{
		rbnodeAllocator.uninit();
		root = 0;
	}

	Iterator find(const Key& key)
#pragma region find
	{
		_rbnode* pNode = root;
		Iterator itr;
		if (root == 0)
			return itr;

		while (pNode)
		{
			if (key == pNode->key)
			{
				itr = pNode;
				break;
			}
			else if (key > pNode->key)
				pNode = pNode->right;
			else
				pNode = pNode->left;
		}
		return itr;
	}
#pragma endregion

	Iterator set(const Key& key, const Value& value)
#pragma region set
	{
		_rbnode * pSearchNode = root;
		_rbnode * pInsertedNode;
		_rbnode * pCurrent;

		Iterator itr;

		if (root == 0)
		{
			root = (_rbnode*)rbnodeAllocator.alloc();

			memset(root, 0, sizeof(_rbnode));
			root->color = _rbnode::eColor::_black;
			root->key = key;
			root->value = value;

			itr = root;

			return itr;
		}

		while (1)
		{
			if (key == pSearchNode->key)
			{
				pSearchNode->value = value;
				return itr;
			}
			else if (key < pSearchNode->key)
			{
				if (pSearchNode->left == 0)
				{
					pInsertedNode = (_rbnode *)rbnodeAllocator.alloc();

					pInsertedNode->color = _rbnode::eColor::_red;
					pInsertedNode->right = 0;
					pInsertedNode->left = 0;
					pInsertedNode->parent = pSearchNode;

					pInsertedNode->key = key;

					pInsertedNode->value = value;

					pSearchNode->left = pInsertedNode;
					break;
				}
				else
					pSearchNode = pSearchNode->left;
			}
			else
			{
				if (pSearchNode->right == 0)
				{
					pInsertedNode = (_rbnode *)rbnodeAllocator.alloc();

					pInsertedNode->color = _rbnode::eColor::_red;
					pInsertedNode->right = 0;
					pInsertedNode->left = 0;
					pInsertedNode->parent = pSearchNode;

					pInsertedNode->key = key;
					pInsertedNode->value = value;

					pSearchNode->right = pInsertedNode;
					break;
				}
				else
					pSearchNode = pSearchNode->right;
			}
		}

		pCurrent = pInsertedNode;
		itr = pInsertedNode;

		while (1)
		{
			_rbnode * pParent;
			_rbnode * pGrandParent;
			_rbnode * pUncle;

			if (pCurrent->parent == 0)
			{
				if (pCurrent->color == _rbnode::eColor::_red)
					pCurrent->color = _rbnode::eColor::_black;

				root = pCurrent;

				return itr;
			}

			pParent = pCurrent->parent;
			if (pParent->color == _rbnode::eColor::_black)
				return itr;

			pGrandParent = pParent->parent;

			if (pGrandParent->left == pParent)
			{
				pUncle = pGrandParent->right;

				if (!pUncle || pUncle->color == _rbnode::eColor::_black)
				{
					if (pCurrent == pParent->left)
					{
						pParent->color = _rbnode::eColor::_black;
						pGrandParent->color = _rbnode::eColor::_red;

						RightRotate(&pGrandParent);

						if (pParent->parent == 0)
							root = pParent;
					}
					else
					{
						LeftRotate(&pParent);

						pCurrent->color = _rbnode::eColor::_black;
						pGrandParent->color = _rbnode::eColor::_red;

						RightRotate(&pGrandParent);

						if (pCurrent->parent == 0)
							root = pCurrent;
					}

					return itr;
				}
			}
			else
			{
				pUncle = pGrandParent->left;

				if (!pUncle || pUncle->color == _rbnode::eColor::_black)
				{
					if (pCurrent == pParent->right)
					{
						pParent->color = _rbnode::eColor::_black;
						pGrandParent->color = _rbnode::eColor::_red;

						LeftRotate(&pGrandParent);

						if (pParent->parent == 0)
							root = pParent;
					}
					else
					{
						RightRotate(&pParent);

						pCurrent->color = _rbnode::eColor::_black;
						pGrandParent->color = _rbnode::eColor::_red;

						LeftRotate(&pGrandParent);

						if (pCurrent->parent == 0)
							root = pCurrent;
					}

					return itr;
				}
			}

			if (pUncle && pUncle->color == _rbnode::eColor::_red)
			{
				pParent->color = _rbnode::eColor::_black;
				pUncle->color = _rbnode::eColor::_black;
				pGrandParent->color = _rbnode::eColor::_red;

				pCurrent = pGrandParent;
			}
		}
		return itr;
	}
#pragma endregion

	Iterator erase(Key key)
#pragma region erase
	{
		_rbnode * pDeleteNode = root;
		_rbnode * pRealDeleteNode;

		_rbnode * pCurrent;
		_rbnode * pParent;

		Iterator itr;

		if (root == 0)
			return itr;

		while (1)
		{
			if (key == pDeleteNode->key)
				break;
			else if (key < pDeleteNode->key)
			{
				if (pDeleteNode->left == 0)
					return itr;
				else
					pDeleteNode = pDeleteNode->left;
			}
			else
			{
				if (pDeleteNode->right == 0)
					return itr;
				else
					pDeleteNode = pDeleteNode->right;
			}
		}

		if (pDeleteNode->right == 0)
			pRealDeleteNode = pDeleteNode;
		else
		{
			pRealDeleteNode = pDeleteNode->right;

			while (1)
			{
				if (pRealDeleteNode->left == 0)
					break;
				else
					pRealDeleteNode = pRealDeleteNode->left;
			}
		}

		pDeleteNode->key = pRealDeleteNode->key;
		pDeleteNode->value = pRealDeleteNode->value;

		itr = NextTreeNode(pDeleteNode);

		pCurrent = pRealDeleteNode;
		pParent = pCurrent->parent;

		if ((pParent == 0) && (pCurrent->left == 0) && (pCurrent->right == 0))
		{
			root = 0;

			rbnodeAllocator.free(pCurrent);

			return itr;
		}

		if (pCurrent->color == _rbnode::eColor::_red)
		{
			if (pParent->left == pCurrent)
				pParent->left = 0;
			else
				pParent->right = 0;

			rbnodeAllocator.free(pCurrent);

			return itr;
		}

		if (pCurrent->right != 0)
		{
			if (pCurrent->right->color == _rbnode::eColor::_red)
			{
				pCurrent->key = pCurrent->right->key;

				rbnodeAllocator.free(pCurrent->right);

				pCurrent->right = 0;

				return itr;
			}
			else
			{
				//printf("unscienceble!!\n");
				//return 1;
				return itr;
			}
		}
		else if (pCurrent->left != 0)
		{
			pCurrent->key = pCurrent->left->key;

			rbnodeAllocator.free(pCurrent->left);

			pCurrent->left = 0;
			//return 0;
			return itr;
		}
		else		//左右子节点为空，颜色为黑的节点
		{
			while (1)
			{
				if (pCurrent == pParent->left)		//左孩子
				{
					_rbnode * pSibling = pParent->right;

					if (pSibling->color == _rbnode::eColor::_black)		//兄弟节点为黑
					{
						_rbnode * sibling_left = pSibling->left;
						_rbnode * sibling_right = pSibling->right;

						if (sibling_right && sibling_right->color == _rbnode::eColor::_red)//兄弟右子节点为红
						{
							pSibling->color = pParent->color;
							sibling_right->color = _rbnode::eColor::_black;
							pParent->color = _rbnode::eColor::_black;

							LeftRotate(&pParent);

							if (pParent->parent)
							{
								if(pParent->parent->parent == nullptr)
									root = pSibling;
							}

							pParent->left = 0;

							rbnodeAllocator.free(pCurrent);

							//return 0;
							return itr;
						}

						if (sibling_left && sibling_left->color == _rbnode::eColor::_red)//兄弟左子节点为红
						{
							RightRotate(&pSibling);

							pSibling = pParent->right;

							pSibling->color = pParent->color;
							pParent->color = _rbnode::eColor::_black;

							LeftRotate(&pParent);

							pParent->left = 0;

							if (pParent->parent)
							{
								if (pParent->parent->parent == nullptr)
									root = pParent->parent;
							}

							rbnodeAllocator.free(pCurrent);

							//return 0;
							return itr;
						}

						if (pParent->color == _rbnode::eColor::_red)//父节点为红
						{
							pSibling->color = _rbnode::eColor::_red;
							pParent->color = _rbnode::eColor::_black;

							pParent->left = 0;

							rbnodeAllocator.free(pCurrent);

							//return 0;
							return itr;
						}
						else//父节点为黑，兄弟两个子节点为黑
						{
							pSibling->color = _rbnode::eColor::_red;

							pParent->left = 0;

							rbnodeAllocator.free(pCurrent);

							pCurrent = pParent;
							pParent = pCurrent->parent;

							while (1)
							{
								if (pParent == 0)
									break;

								if (pCurrent == pParent->left)//当前节点为左子节点
								{
									pSibling = pParent->right;

									if (pSibling->color == _rbnode::eColor::_black)
									{
										sibling_left = pSibling->left;
										sibling_right = pSibling->right;

										if (sibling_right && sibling_right->color == _rbnode::eColor::_red)
										{
											pSibling->color = pParent->color;
											sibling_right->color = _rbnode::eColor::_black;
											pParent->color = _rbnode::eColor::_black;

											LeftRotate(&pParent);

											if (pParent->parent)
											{
												if(pParent->parent->parent == nullptr)
													root = pParent->parent;
											}

											break;
										}

										if (sibling_left && sibling_left->color == _rbnode::eColor::_red)
										{
											RightRotate(&pSibling);

											pSibling = pParent->right;

											pSibling->color = pParent->color;
											pParent->color = _rbnode::eColor::_black;

											LeftRotate(&pParent);

											if (pParent->parent)
											{
												if (pParent->parent->parent == nullptr)
													root = pParent->parent;
											}

											break;
										}

										if (pParent->color == _rbnode::eColor::_red)
										{
											pSibling->color = _rbnode::eColor::_red;
											pParent->color = _rbnode::eColor::_black;

											break;
										}
										else//黑兄二黑侄
										{
											pSibling->color = _rbnode::eColor::_red;
											pParent->color = pCurrent->color;
											pCurrent->color = _rbnode::eColor::_black;

											if (pParent->parent == nullptr)
												pParent->color = _rbnode::eColor::_black;

											pCurrent = pParent;
											pParent = pCurrent->parent;
											continue;
										}
									}
									else//兄弟节点为红色
									{
										pParent->color = _rbnode::eColor::_red;
										pSibling->color = _rbnode::eColor::_black;

										LeftRotate(&pParent);

										if (pParent->parent)
										{
											if (pParent->parent->parent == nullptr)
												root = pParent->parent;
										}
										continue;
									}
								}
								else//当前节点为右子节点
								{
									pSibling = pParent->left;

									if (pSibling->color == _rbnode::eColor::_black)
									{
										_rbnode * pSiblingLeftChild = pSibling->left;
										_rbnode * pSiblingRightChild = pSibling->right;

										if (pSiblingLeftChild && pSiblingLeftChild->color == _rbnode::eColor::_red)
										{
											pSibling->color = pParent->color;
											pSiblingLeftChild->color = _rbnode::eColor::_black;
											pParent->color = _rbnode::eColor::_black;

											RightRotate(&pParent);

											if (pParent->parent)
											{
												if (pParent->parent->parent == nullptr)
													root = pParent->parent;
											}

											break;
										}

										if (pSiblingRightChild && pSiblingRightChild->color == _rbnode::eColor::_red)
										{
											LeftRotate(&pSibling);

											pSibling = pParent->left;

											pSibling->color = pParent->color;
											pParent->color = _rbnode::eColor::_black;

											RightRotate(&pParent);

											if (pParent->parent)
											{
												if (pParent->parent->parent == nullptr)
													root = pParent->parent;
											}

											break;
										}

										if (pParent->color == _rbnode::eColor::_red)
										{
											pSibling->color = _rbnode::eColor::_red;
											pParent->color = _rbnode::eColor::_red;

											break;
										}
										else
										{
											pSibling->color = _rbnode::eColor::_red;
											pParent->color = pCurrent->color;
											pCurrent->color = _rbnode::eColor::_black;

											pCurrent = pParent;
											pParent = pCurrent->parent;
											continue;
										}
									}
									else//兄弟节点为红色
									{
										pParent->color = _rbnode::eColor::_red;
										pSibling->color = _rbnode::eColor::_black;

										RightRotate(&pParent);

										if (pParent->parent)
										{
											if (pParent->parent->parent == nullptr)
												root = pParent->parent;
										}
										continue;
									}
								}
							}
							return itr;
						}
					}
					else			//兄弟节点为红
					{
						pParent->color = _rbnode::eColor::_red;
						pSibling->color = _rbnode::eColor::_black;

						LeftRotate(&pParent);

						if (pParent->parent)
						{
							if (pParent->parent->parent == nullptr)
								root = pParent->parent;
						}

						continue;
					}
				}
				else		//右孩子
				{
					_rbnode * pSibling = pParent->left;

					if (pSibling->color == _rbnode::eColor::_black)		//兄弟节点为黑
					{
						_rbnode * pSiblingLeftChild = pSibling->left;
						_rbnode * pSiblingRightChild = pSibling->right;

						if (pSiblingLeftChild && pSiblingLeftChild->color == _rbnode::eColor::_red)//兄弟左子节点为红
						{
							pSibling->color = pParent->color;
							pSiblingLeftChild->color = _rbnode::eColor::_black;
							pParent->color = _rbnode::eColor::_black;

							RightRotate(&pParent);

							pParent->right = 0;

							if (pParent->parent)
							{
								if (pParent->parent->parent == nullptr)
									root = pSibling;
							}

							rbnodeAllocator.free(pCurrent);

							//return 0;
							return itr;
						}

						if (pSiblingRightChild && pSiblingRightChild->color == _rbnode::eColor::_red)//兄弟右子节点为红
						{
							LeftRotate(&pSibling);

							pSibling = pParent->left;

							pSibling->color = pParent->color;
							pParent->color = _rbnode::eColor::_black;

							RightRotate(&pParent);

							pParent->right = 0;

							if (pParent->parent)
							{
								if (pParent->parent->parent == nullptr)
									root = pParent->parent;
							}

							rbnodeAllocator.free(pCurrent);

							//return 0;
							return itr;
						}


						if (pParent->color == _rbnode::eColor::_red)//父节点为红
						{
							pSibling->color = _rbnode::eColor::_red;
							pParent->color = _rbnode::eColor::_black;

							pParent->right = 0;

							rbnodeAllocator.free(pCurrent);

							//return 0;
							return itr;
						}
						else//父节点为黑，兄弟两个子节点为黑
						{
							pSibling->color = _rbnode::eColor::_red;

							pParent->right = 0;

							rbnodeAllocator.free(pCurrent);

							pCurrent = pParent;
							pParent = pCurrent->parent;

							while (1)
							{
								if (pParent == 0)
									break;

								if (pCurrent == pParent->left)//当前节点为父节点左孩子
								{
									pSibling = pParent->right;

									if (pSibling->color == _rbnode::eColor::_black)
									{
										pSiblingLeftChild = pSibling->left;
										pSiblingRightChild = pSibling->right;

										if (pSiblingRightChild && pSiblingRightChild->color == _rbnode::eColor::_red)
										{
											pSibling->color = pParent->color;
											pSiblingRightChild->color = _rbnode::eColor::_black;
											pParent->color = _rbnode::eColor::_black;

											LeftRotate(&pParent);

											if (pParent->parent)
											{
												if (pParent->parent->parent == nullptr)
													root = pParent->parent;
											}

											break;
										}

										if (pSiblingLeftChild && pSiblingLeftChild->color == _rbnode::eColor::_red)
										{
											RightRotate(&pSibling);

											pSibling = pParent->right;

											pSibling->color = pParent->color;
											pParent->color = _rbnode::eColor::_black;

											LeftRotate(&pParent);

											if (pParent->parent)
											{
												if (pParent->parent->parent == nullptr)
													root = pParent->parent;
											}

											break;
										}

										if (pParent->color == _rbnode::eColor::_red)
										{
											pSibling->color = _rbnode::eColor::_red;
											pParent->color = _rbnode::eColor::_black;

											break;
										}
										else
										{
											pSibling->color = _rbnode::eColor::_red;
											pParent->color = pCurrent->color;
											pCurrent->color = _rbnode::eColor::_black;

											if (pParent->parent == nullptr)
												pParent->color = _rbnode::eColor::_black;

											pCurrent = pParent;
											pParent = pCurrent->parent;
											continue;
										}
									}
									else			//兄弟节点为红
									{
										pParent->color = _rbnode::eColor::_red;
										pSibling->color = _rbnode::eColor::_black;

										LeftRotate(&pParent);

										if (pParent->parent)
										{
											if (pParent->parent->parent == nullptr)
												root = pParent->parent;
										}
										continue;
									}
								}
								else//当前节点为父节点右孩子
								{
									pSibling = pParent->left;

									if (pSibling->color == _rbnode::eColor::_black)
									{
										_rbnode * pSiblingLeftChild = pSibling->left;
										_rbnode * pSiblingRightChild = pSibling->right;

										if (pSiblingLeftChild && pSiblingLeftChild->color == _rbnode::eColor::_red)
										{
											pSibling->color = pParent->color;
											pSiblingLeftChild->color = _rbnode::eColor::_black;
											pParent->color = _rbnode::eColor::_black;

											RightRotate(&pParent);

											if (pParent->parent)
											{
												if (pParent->parent->parent == nullptr)
													root = pParent->parent;
											}

											break;
										}

										if (pSiblingRightChild && pSiblingRightChild->color == _rbnode::eColor::_red)
										{
											LeftRotate(&pSibling);

											pSibling = pParent->left;

											pSibling->color = pParent->color;
											pParent->color = _rbnode::eColor::_black;

											RightRotate(&pParent);

											if (pParent->parent)
											{
												if (pParent->parent->parent == nullptr)
													root = pParent->parent;
											}

											break;
										}

										if (pParent->color == _rbnode::eColor::_red)
										{
											pSibling->color = _rbnode::eColor::_red;
											pParent->color = _rbnode::eColor::_black;

											break;
										}
										else
										{
											pSibling->color = _rbnode::eColor::_red;
											pParent->color = pCurrent->color;
											pCurrent->color = _rbnode::eColor::_black;

											pCurrent = pParent;
											pParent = pCurrent->parent;
											continue;
										}
									}
									else			//兄弟节点为红
									{
										pParent->color = _rbnode::eColor::_red;
										pSibling->color = _rbnode::eColor::_black;

										RightRotate(&pParent);

										if (pParent->parent)
										{
											if (pParent->parent->parent == nullptr)
												root = pParent->parent;
										}

										continue;
									}
								}

							}
							return itr;
						}
					}
					else//兄弟节点为红
					{
						pParent->color = _rbnode::eColor::_red;
						pSibling->color = _rbnode::eColor::_black;

						RightRotate(&pParent);

						if (pParent->parent)
						{
							if (pParent->parent->parent == nullptr)
								root = pParent->parent;
						}

						continue;
					}
				}
			}
		}
		return itr;
	}
#pragma endregion

	Iterator begin()
	{
		Iterator RetIterator;

		if (root == 0)
			goto _EXIT;

		_rbnode* pCurrent = root;

		while (pCurrent->left)
			pCurrent = pCurrent->left;

		RetIterator = pCurrent;

	_EXIT:
		return RetIterator;
	}
	Iterator rbegin()
	{
		Iterator RetIterator;

		if (root == 0)
			goto EXIT_SUCCESS;

		_rbnode* pCurrent = root;

		while (pCurrent->right)
			pCurrent = pCurrent->right;

		RetIterator = pCurrent;

	EXIT_SUCCESS:
		return RetIterator;
	}

	Iterator end()
	{
		return Iterator();
	}
	Iterator rend()
	{
		return Iterator();
	}

private:
	static _rbnode* PrevTreeNode(_rbnode* pNode)
	{
		if (pNode == 0)
			return 0;

		if (pNode->m_pLeft != 0)
		{
			_rbnode* pCurrentNode = pNode->m_pLeft;

			while (pCurrentNode->m_pRight)
				pCurrentNode = pCurrentNode->m_pRight;

			return pCurrentNode;
		}
		else
		{
			_rbnode* pParent = pNode->m_pParent;

			if (pParent == 0)
				return 0;

			if (pNode == pParent->m_pRight)
				return pParent;

			pNode = pParent;
			pParent = pNode->m_pParent;

			while (pParent)
			{
				if (pNode == pParent->m_pRight)
					return pParent;
				else
				{
					pNode = pParent;
					pParent = pNode->m_pParent;
				}
			}

			return 0;
		}
	}

	static _rbnode* NextTreeNode(_rbnode* pNode)
	{
		if (pNode == 0)
			return 0;

		if (pNode->right != 0)
		{
			_rbnode* pCurrentNode = pNode->right;

			while (pCurrentNode->left)
				pCurrentNode = pCurrentNode->left;

			return pCurrentNode;
		}
		else
		{
			_rbnode* pParent = pNode->parent;

			if (pParent == 0)
				return 0;

			if (pNode == pParent->left)
				return pParent;

			pNode = pParent;
			pParent = pNode->parent;

			while (pParent)
			{
				if (pNode == pParent->left)
					return pParent;
				else
				{
					pNode = pParent;
					pParent = pNode->parent;
				}
			}

			return 0;
		}
	}

	void RightRotate(_rbnode ** ppCurrent)
	{
		_rbnode * pLeftChild = (*ppCurrent)->left;

		if (pLeftChild == 0) return;

		(*ppCurrent)->left = pLeftChild->right;

		if ((*ppCurrent)->left != 0)
			(*ppCurrent)->left->parent = (*ppCurrent);

		pLeftChild->right = (*ppCurrent);
		pLeftChild->parent = (*ppCurrent)->parent;

		(*ppCurrent)->parent = pLeftChild;

		if (pLeftChild->parent != 0)
		{
			if (pLeftChild->parent->left == (*ppCurrent))
				pLeftChild->parent->left = pLeftChild;
			else
				pLeftChild->parent->right = pLeftChild;
		}
	}
	void LeftRotate(_rbnode ** ppCurrent)
	{
		_rbnode * pRightChild = (*ppCurrent)->right;

		if (pRightChild == 0) return;

		(*ppCurrent)->right = pRightChild->left;

		if ((*ppCurrent)->right != 0)
			(*ppCurrent)->right->parent = (*ppCurrent);

		pRightChild->left = (*ppCurrent);
		pRightChild->parent = (*ppCurrent)->parent;
		(*ppCurrent)->parent = pRightChild;

		if (pRightChild->parent != 0)
		{
			if (pRightChild->parent->left == (*ppCurrent))
				pRightChild->parent->left = pRightChild;
			else
				pRightChild->parent->right = pRightChild;
		}
	}

public:
	_pool rbnodeAllocator;

	_rbnode * root;
};

#endif


qiu824039983
关注
Map的使用与实现
莫予笙的博客
06-09 1116
基本概念和使用场景 Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。以前常见的搜索方式有： 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢 二分查找，时间复杂度为,但搜索前必须要求序列是有序的 上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了，而现实中的查找可能会在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，这时就需要使用Map和Set这两种适合动态查找的集合容器。 所以map和set是两种用来搜索
Map方法的实现与遍历
weixin_48678713的博客
04-28 496
Map接口存储的是一对对的映射 从key到value的映射 key是唯一的，value可以重复 Map接口常用方法 put(Object key,Object value) 以键-值 方式存储 get(Object key) 返回相关联的值 如果该键不存在 返回null remove(Object key) 删除指定的键值对 size() 返回集合元素个数 keySet() 返回键的集合 values() 返回值得集合 containsKey(Object key) 判断是否...
map的实现
weixin_34110749的博客
01-08 161
1、map的实现是使用平衡树，AVL树或者红黑树。 2、在无序的情况下，查找为常数时间。有序的时候，查找为对数时间。二叉排序树（BST）就是为了解决这个问题。 3、但是，极端情况下，BST的查找效率退化到常数时间，考虑极端不平衡的二叉树，每个节点只有左孩子。 4、为了解决上面的问题，就要想办法对BST进行调整，保证查找效率。 5、AVL的思路是：每个节点两个孩子节点的高度相差不大于1，这样...
简易STL实现 | Map 的实现
最新发布
AsherGu的博客
10-11 945
特性，性能，标准库中基本用法，实现，常见面试题
Map的实现
weixin_30617737的博客
03-15 87
本文内容摘自：http://wiki.jikexueyuan.com/project/java-collection/hashmap.html，要看详解，请去阅读原文！ HashMap HashMap 是基于哈希表的 Map 接口的非同步实现，并允许使用 null 值和 null 键； 需要注意的是：Hashmap 不是同步的，如果多个线程同时访问一个 HashMap，而其中至少一个...
Map的底层结构及分析
热门推荐
abasen的专栏
02-02 3万+
1、Map接口的相关实现类： 2、HashMap的底层结构实际上是“链表散列”，即数组和链表的结合体。 从上图可以看出，HashMap底层就是一个数组结构（Entry[] table），数组中的每一项又是一个链表。 源代码如下： transient Entry[] table; static class Entry implements Map.Entry {
Map (c++实现的简易map)
03-16
在C++标准库中，`Map`被实现为`std::map`，但在这个场景中，我们讨论的是一个用户自定义的简易`Map`实现，名为"MyMap"，这是在Visual Studio 2013环境下编写的。 自定义`Map`的主要目的是为了学习和理解数据结构的...
C 语言 map实现
12-23
This is a simple hash table implementation in ANSI C. It supports the rudimentary functions generally expected of a hash table: Inserting and retrieving key-value associations Querying the existence ...
Linux内核Map完整实现！
01-20
Linux内核Map完整实现，内有Windows与linux红黑树结构实现
MDS_MAP算法实现
06-17
我只实现了在二维上的MDS-MAP算法 只需要少许改动你们即可实现多维的MDS-MAP算法 这个是论文地址：https://github.com/zenzondon/WSN-localization/blob/master/MDS-MAP/Localization from mere connectivity.pdf ...
java版list-map实现 树结构 父子结构 通俗易懂
12-12
此java类实现了对数据表的分类递归树的实现，为本人倾力之作，后期，会发布js版，敬请期待！
浅谈Map的实现
maitianlideshouhuzhe的博客
03-14 327
java中我们常用的集合有三大类：map、list、set。其中map与其它两者不一样，map是以键值对的形式存放数据。现在我们来聊一下java是怎么实现map这个集合的。 现在我们以HashMap来讲述 1.内部存储数据结构 1.1Entry内部类 查看HashMap的源码，我们不难发现，每一个键值对都是存放在Entry  final K key;  V value;  Ent
Map的实现类
hglhjh的博客
05-16 435
装载自：https://www.cnblogs.com/K-artorias/p/7373745.html      Map是一个双列集合接口，如果实现了Map接口，特点是数据以键值对形式存在，键不可重复，值可以重复。      java中主要有HashMap、TreeMap、Hashtable。1.HashMapHashMap的存储原理：HashMap 底层是基于哈希表实现的。往HashMap添...
js实现map
fkyq01的专栏
02-01 138
[code="java"] /** * Map对象，实现Map功能 * * * size() 获取Map元素个数 * isEmpty() 判断Map是否为空 * clear() 删除Map所有元素 * put(key, value) 向Map中增加元素（key, value) * remove(key) 删除指定key的元素，成功返回true，失败返回...
自己实现简单的Map
男儿当自强
03-23 947
package cn.t2; import java.util.LinkedList; public class MyHashMap { private LinkedList[] arr; public MyHashMap(int n) { arr = new LinkedList[n]; } public void put(Object k, Object v) { No...
Map实现原理
m0_58181788的博客
04-10 3262
什么是Map key，value存储 其实我们可以这么理解，Map是一个数据结构，什么样的数据结构呢，它其中包含了key和value，我们可以通过key来获取value的一个数据结构。其底层存储方式为数组，在存储key并不能重复，当key重复时，value进行覆盖，我们通过key进行hash运算（可以简单理解为把key转化成一个整型数字）然后对数组的长度取余，得到key存储在数组的哪个下标位置，最后将key和value组装为一个结构体放入到数组下标处 hash冲突 如上图所示，数组一个下标处只能存储一
蔚蓝网上书店的Java Map实现
- Map的实现：根据需求选择合适的Map实现，如HashMap适用于快速检索，TreeMap适用于元素排序等。 - Map的高级特性：理解Map的可变性和线程安全的特性，使用如ConcurrentHashMap来提高高并发环境下的性能。 5. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值