基于低层平衡树的key-value容器

template<typename T>
struct Node
{
	Node<T>* left;
	Node<T>* right;
	T val;
	T key;
	T height;
	Node() {};
	Node(const T &m_val = T(), const T &m_key = T()) :val(m_val), key(m_key), left(nullptr), right(nullptr) {};
};

template<typename K, typename V>
class Map
{
public:
	Map() {}
	int Getheight(Node* root) {
		if (root == nullptr)
			return -1;
		else {
			root->height;
		}
	}
	Node* LL(Node* root) {
		Node* p = root->left;
		root->left = p->right;
		q->right = root;
		root->height = max(Getheight(root->left), Getheight(root->right)) + 1;
		p->height = max(Getheight(p->left), Getheight(p->right)) + 1;
		return p;
	}
	Node* RR(Node* root) {
		Node* p = root->right;
		root->right = p->left;
		q->left = root;
		root->height = max(Getheight(root->left), Getheight(root->right)) + 1;
		p->height = max(Getheight(p->left), Getheight(p->right)) + 1;
		return p;
	}

	Node* RL(Node* root) {
		LL(root->right);
		return RR(root);
	}
	Node* LR(Node* root) {
		RR(root->left);
		return LL(root);
	}

	bool insert(Node* root const int key,const int value) {
		if (root == nullptr) {
			root = new Node<T>(key,value);
			return true;
		}
		else if(root->key >key){
			insert(root->left,key, value);
			if (Getheight(root->left) - Getheight(root->right) > 1) {
				if (root->left->key > key) {
					root = LL(root);
				}
				else {
					root = LR(root);
				}
			}
		}
		else if(root->key < key){
			insert(root->right, key, value);
			if (Getheight(root->right) - Getheight(root->left) > 1) {
				if (root->right->key > key) {
					root = RR(root);
				}
				else {
					root = RL(root);
				}
			}
		}
		root->height = max(Getheight(root->left), Getheight(root->right)) + 1;
	}


private:
	Node<T>* root;

};