BST(Binary Search Tree)C++

#include<iostream>
template<class B>
class Node
{
public:
	B key;
	int val;
	int N;
	Node* left, * right;
	Node(B _KEY, int _VAL, int _N) :key(_KEY), val(_VAL), N(_N), left(nullptr), right(nullptr) {}
};

template<class T>
class BST
{
	Node<T>* pRoot;
public:
	//节点数
	int get_size();
	//键值存储的值
	int get_val(T key);
	//键值排名
	int get_rank(T key);
	//插入节点
	void put(T key, int val);
	//删除节点
	void deleteNode(T key);
	//删除最小键
	void deleteMin();
	//删除最大键
	void deleteMax();
	//打印
	void c_out_Tree();
	//最大键
	T get_max();
	//最小键
	T get_min();
	//查找排名为_rank的键
	T select(int _rank);
	//向下取整
	T get_Floor(T key);
	//向上取整
	T get_ceiling(T key);
	~BST() { delete[] pRoot; }
private:
	int _size(Node<T>* node);
	int _get_val(Node<T>* root, T key);
	int _get_rank(Node<T>* root, T key);
	void _c_out_Tree(Node<T>* root);
	void _deleteMin(Node<T>* root);
	void _deleteMax(Node<T>* root);
	Node<T>* _deleteNode(Node<T>* root, T key);
	Node<T>* _select(Node<T>* root, int _rank);
	Node<T>* _get_max(Node<T>* node);
	Node<T>* _get_min(Node<T>* node);
	Node<T>* _put(Node<T>* root, T key, int val);
	Node<T>* _get_Floor(Node<T>* node, T key);
	Node<T>* _get_Ceiling(Node<T>* node, T key);
};

template<class T>
Node<T>* BST<T>::_deleteNode(Node<T>* root, T key)
{
	if (root == nullptr)return nullptr;
	if (key < root->key)root->left = _deleteNode(root->left, key);
	else if (key > root->key)root->right = _deleteNode(root->right, key);
	else
	{
		Node<T>* tempNode = nullptr;
		if (root->right == nullptr)
		{//如果删除节点右节点位空，直接将左节点提升
			tempNode = root->left;
			delete root;
			return tempNode;
		}
		if (root->left == nullptr)
		{//如果删除节点左节点位空，直接将右节点提升
			tempNode = root->right;
			delete root;
			return tempNode;
		}
		Node<T>* temp = root;
		Node<T>* temp_left = root->left;
		Node<T>* temp_right = root->right;
		if (temp->right->left != nullptr)
		{//如果删除节点的右节点的左节点不为空，需要找到最小
			Node<T>* p_parent = temp_right;
			Node<T>* p_left = temp_right->left;
			while (p_left->left)
			{
				p_left = p_left->left;
				p_parent = p_parent->left;
			}
			root = p_left;
			p_parent = p_left->right;
			root->right = temp_right;
			root->left = temp_left;
		}
		else
		{//如果删除节点的右节点的左节点为空，可直接将右节点提升
			root = temp_right;
			root->left = temp_left;
		}
		delete temp;
	}
	//更新节点数
	root->N = _size(root->left) + _size(root->right) + 1;
	return root;
}

template<class T>
void BST<T>::deleteNode(T key)
{
	this->pRoot = _deleteNode(this->pRoot, key);
}

template<class T>
void BST<T>::_c_out_Tree(Node<T>* root)
{
	if (root)
	{
		_c_out_Tree(root->left);
		std::cout << root->key<<" ";
		_c_out_Tree(root->right);
	}
}

template<class T>
void BST<T>::c_out_Tree()
{
	_c_out_Tree(this->pRoot);
}

template<class T>
void BST<T>::_deleteMax(Node<T>* root)
{
	Node<T>* tempNode = nullptr;
	if (root == nullptr)return;
	else if ((root->right == nullptr && root->left != nullptr) 
		|| (root != nullptr && root->left == nullptr && root->right == nullptr))
	{//如果最大值位于根节点
		tempNode = root;
		this->pRoot=root->left;
	}
	else
	{//位于右子树的情况
		Node<T>*p_parent=root;
		--p_parent->N;
		Node<T>*p_right=root->right;
		while (p_right->right)
		{
			--p_right->N;
			p_right = p_right->right;
			p_parent = p_parent->right;
		}
		p_parent->right = p_right->left;
		tempNode = p_right;
	}
	delete tempNode;
}

template<class T>
void BST<T>::deleteMax()
{
	_deleteMax(pRoot);
}

template<class T>
void BST<T>::_deleteMin(Node<T>* root)
{
	Node<T>* tempNode = nullptr;
	Node<T>* p_parent = nullptr;
	if (root == nullptr)return;//如果为空直接停止
	else if ((root->left == nullptr && root->right != nullptr)
		||(root != nullptr && root->left == nullptr && root->right == nullptr))
	{//如果最小节点位于根节点
		tempNode = root;
		this->pRoot = root->right;
	}
	else
	{//位于左子树的情况
		p_parent = root;
		--p_parent->N;
		Node<T>* p_left = root->left;
		while (p_left->left)
		{
			--p_left->N;
			p_left = p_left->left;
			p_parent = p_parent->left;
		}
		p_parent->left = p_left->right;
		tempNode = p_left;
	}
	delete tempNode;
}

template<class T>
void BST<T>::deleteMin()
{
	_deleteMin(this->pRoot);
}

template<class T>
int BST<T>::_get_rank(Node<T>* root, T key)
{//排名
	if (root == nullptr)        return 0;
	if (key < root->key)        return _get_rank(root->left, key);//左子树直接计算即可
	else if (key > root->key)   return _get_rank(root->right, key) + _size(root->left) + 1;//需要加上左子树以及根几点
	else                        return _size(root->left);
}

template<class T>
int BST<T>::get_rank(T key)
{
	return _get_rank(pRoot, key);
}

template<class T>
Node<T>* BST<T>::_select(Node<T>* root, int _rank)
{
	if (root == nullptr)        return nullptr;
	int left_count = _size(root->left);
	if (_rank < left_count)     return _select(root->left, _rank);//位于左子树
	else if (_rank > left_count)return _select(root->right, _rank - left_count - 1);//位于右子树，减去左子树数以及根节点
	else                        return root;
}

template<class T>
T BST<T>::select(int _rank)
{
	return select(pRoot, _rank)->key;
}

template<class T>
Node<T>* BST<T>::_get_Ceiling(Node<T>* node, T key)
{//向上取整
	if (node == nullptr)        return nullptr;
	if (key == node->key)       return node;
	if (key > node->key)        return _get_Ceiling(node->right, key);
	Node<T>* tempNode = _get_Ceiling(node->left, key);
	if (tempNode != nullptr)    return tempNode;
	else                        return node;
}

template<class T>
T BST<T>::get_ceiling(T key)
{
	Node<T>* node = _get_Ceiling(key);
	return node->key;
}

template<class T>
Node<T>* BST<T>::_get_Floor(Node<T>* node, T key)
{//向下取整
	if (node == nullptr)        return nullptr;
	if (key == node->key)       return node;
	if (key < node->key)        return _get_Floor(node->left, key);
	Node<T>* tempNode = _get_Floor(node->right, key);
	if (tempNode != nullptr)    return tempNode;
	else                        return node;
}

template<class T>
T BST<T>::get_Floor(T key)
{
	Node<T>* node = _get_Floor(pRoot, key);
	return node->key;
}

template<class T>
Node<T>* BST<T>::_get_min(Node<T>* node)
{//得到最小值
	if (node->left == nullptr)  return node;
	return                      _get_min(node->left);
}

template<class T>
T BST<T>::get_min()
{
	return _get_min(pRoot);
}

template<class T>
Node<T>* BST<T>::_get_max(Node<T>* node)
{//得到最大值
	if (node->right == nullptr) return node;
	return                      _get_max(node->right);
}

template<class T>
T BST<T>::get_max()
{
	return _get_max(pRoot)->key;
}

template<class T>
Node<T>* BST<T>::_put(Node<T>* root, T key, int val)
{//插入
	if (root == nullptr)        return root = new Node<T>(key, val, 1);
	if (key < root->key)        root->left = _put(root->left, key, val);
	else if (key > root->key)   root->right = _put(root->right, key, val);
	else                        root->val = val;
  	root->val = _size(root->right) + _size(root->left) + 1;
	return root;
}

template<class T>
void BST<T>::put(T key, int val)
{
	pRoot = _put(pRoot, key, val);
}

template<class T>
int BST<T>::_get_val(Node<T>* root, T key)
{//得到value
	if (root == nullptr)        return NULL;
	if (key < root->key)        _get_val(root->left, key);
	else if (key > root->key)   _get_val(root->right, key);
	else                        return root->val;
}

template<class T>
int BST<T>::get_val(T key)
{
	return _get_val(pRoot, key);
}

template<class T>
int BST<T>::_size(Node<T>* node)
{//大小
	if (node == nullptr)        return 0;
	else                        return node->val;
}

template<class T>
int BST<T>::get_size()
{
	return _size(pRoot);
}

int main(int argc, char* argv[])
{
	BST<char> B;
	B.put('C', 10);
	B.put('A', 10);
	B.put('D', 10);
	B.deleteMin();
	B.deleteMax();
	B.deleteNode('C');
	B.c_out_Tree();
	std::cin.get();
	return 0;
}