#pragma once
// Binary Search Tree Node
template<class K, class V>
struct BSTNode
{
K _key; // 节点关键值
V _value; // 节点数据
BSTNode* _left; // 左孩子
BSTNode* _right; // 右孩子
BSTNode(const K& key, const V& data)
:_key(key)
,_value(data)
,_left(NULL)
,_right(NULL)
{}
};
template<class K, class V>
class BSTree
{
typedef BSTNode<K, V> Node;
public:
BSTree()
:_root(NULL)
{}
~BSTree()
{}
BSTree(const BSTree& t);
BSTree&operator=(const BSTree& t);
public:
BSTNode<K,V>* Find_R(const K& key)
{
return _Find(_root, key);
}
bool Insert_R(const K& key, const V& data)
{
return _Insert(_root, key, data);
}
bool Remove_R(const K& key)
{
return _Remove(_root, key);
}
void PrevOrder()
{
_PrevOrder(_root);
cout<<endl;
}
Node* Find(const K& key)
{
Node* cur = _root;
while(cur)
{
if (cur->_key > key)
{
cur = cur->_left;
}
else if (cur->_key < key)
{
cur = cur->_right;
}
else
{
return cur;
}
}
return NULL;
}
bool Remove(const K& key)
{
if (_root == NULL)
{
return false;
}
else if (_root->_left == NULL && _root->_right == NULL)
{
delete _root;
_root = NULL;
return true;
}
Node* parent = NULL;
Node* del = _root;
while (del)
{
if (del->_key > key)
{
parent = del;
del = del->_left;
}
else if (del->_key < key)
{
parent = del;
del = del->_right;
}
else
{
break;
}
}
if (del)
{
// 左树为空,则用右树调补
if (del->_left == NULL)
{
// 注意删除节点为根节点的情况
if (_root != del)
{
if(del == parent->_left)
parent->_left = del->_right;
else
parent->_right = del->_right;
}
else
{
_root = del->_right;
}
}
else if (del->_right == NULL)
{
// 注意删除节点为根节点的情况
if (_root != del)
{
if(del == parent->_left)
parent->_left = del->_left;
else
parent->_right = del->_left;
}
else
{
_root = del->_right;
}
}
else
{
// 查找右子树的中序遍历的第一个节点
Node* subRight = del->_right;
Node* firstInOrder = del->_right;
Node* parent = del;
while(firstInOrder->_left)
{
parent = firstInOrder;
firstInOrder = firstInOrder->_left;
}
swap(del->_key, firstInOrder->_key);
swap(del->_value, firstInOrder->_value);
if (firstInOrder == parent->_left)
{
parent->_left = firstInOrder->_right;
}
else
{
parent->_right = firstInOrder->_right;
}
del = firstInOrder;
}
delete del;
}
else
{
return false;
}
return true;
}
bool Insert(const K& key, const V& value)
{
if (_root == NULL)
{
_root = new Node(key, value);
return true;
}
Node* parent = NULL;
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}
if (parent->_key < key)
parent->_right = new Node(key, value);
else
parent->_left = new Node(key, value);
return true;
}
protected:
void _PrevOrder(BSTNode<K,V>* root)
{
if (root)
{
_PrevOrder(root->_left);
// cout<<"[key:"<<root->_key<<","<<root->_value<<"]"<<"->";
cout<<root->_key<<", ";
_PrevOrder(root->_right);
}
}
BSTNode<K,V>* _Find(BSTNode<K,V>* root, const K& key)
{
if (root)
{
if (root->_key > key)
{
return _Find(root->_left, key);
}
else if (root->_key < key)
{
return _Find(root->_right, key);
}
else
{
return root;
}
}
return NULL;
}
bool _Insert(BSTNode<K,V>*& root, const K& key, const V& data)
{
if (root == NULL)
{
root = new BSTNode<K,V>(key, data);
return true;
}
else
{
if (root->_key > key)
{
return _Insert(root->_left, key, data);
}
else if (root->_key < key)
{
return _Insert(root->_right, key, data);
}
else
{
return false;
}
}
}
bool _Remove(BSTNode<K,V>*& root, const K& key)
{
if (root)
{
if(root->_key > key)
{
return _Remove(root->_left, key);
}
else if(root->_key < key)
{
return _Remove(root->_right, key);
}
else
{
// 1.如果左or右子树为空,则用一个子树进行填补。
// 2.如果左右均不为空,则使用右子树中序的第一个节点填补
if (root->_left == NULL)
{
BSTNode<K,V>* del = root;
root = root->_right;
delete del;
}
else if(root->_right == NULL)
{
BSTNode<K,V>* del = root;
root = root->_left;
delete del;
}
else
{
// 查找右子树的中序遍历的第一个节点
BSTNode<K,V>* right = root->_right;
while (right->_left)
{
right = right->_left;
}
swap(root->_value, right->_value);
swap(root->_key, right->_key);
_Remove(root->_right, right->_key);
}
return true;
}
}
return false;
}
private:
BSTNode<K,V>* _root;
};
void TestBSTree()
{
// 5 3 4 1 7 8 2 6 0 9
BSTree<int, double> t;
t.Insert(5,5);
t.Insert(3,3);
t.Insert(4,4);
t.Insert(1,1);
t.Insert(7,7);
t.Insert(8,8);
t.Insert(2,2);
t.Insert(6,6);
t.Insert(0,0);
t.Insert(9,9);
t.PrevOrder();
BSTNode<int,double>* ret = t.Find(9);
cout<<"Find 9 ?: "<<ret->_key<<endl;
ret = t.Find(10);
cout<<"Find 10 ?: "<<ret<<endl;
t.Remove(8);
t.Remove(1);
t.Remove(5);
t.PrevOrder();
}
BinarySearchTree
最新推荐文章于 2023-11-03 09:13:13 发布