二叉搜索树:
- 1.每个节点都有一个作为搜索依据的关键码(key),所有节点关键码(key);
- 2.左子树上所有节点的1关键码(key)都小于根节点的关键码(key);
- 3.右子树所有节点的关键码(key)都大于根节点的关键码(key);
- 4.左右子树都是二叉搜索树。
实现:
- 二叉搜索树(节点插入、删除和查找)
#include<iostream>
using namespace std;
template<class K, class V>
struct BSTNode
{
K _key;
V _value;
BSTNode* _left;
BSTNode* _right;
BSTNode(const K& key, const V& value)
:_key(key)
, _value(value)
, _left(NULL)
, _right(NULL)
{}
};
template<class K, class V>
class BSTree
{
typedef BSTNode<K, V> Node;
public:
BSTree()
:_root(NULL)
{}
//插入(非递归)
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 (key > cur->_key)
{
parent = cur;
cur = cur->_right;
}
else if (key < cur->_key)
{
parent = cur;
cur = cur->_left;
}
else
{
return false;
}
}
cur = new Node(key, value);
if (parent->_key > key)
{
parent->_left = cur;
}
else
{
parent->_right = cur;
}
return true;
}
//插入(递归)
bool Insert_R(const K& key, const V& value)
{
return _Insert_R(_root, key, value);
}
//查找
Node* Find(const K& key)
{
if (_root == NULL)
{
return NULL;
}
Node* cur = _root;
while (cur)
{
if (key < cur->_key)
{
cur = cur->_left;
}
else if (key > cur->_key)
{
cur = cur->_right;
}
else
{
break;
}
}
return cur;
}
//删除(非递归)
bool Remove(const K& key)
{
if (_root == NULL)
{
return false;
}
if (_root->_left == NULL && _root->_right == NULL)
{
delete _root;
_root = NULL;
return true;
}
Node *parent = _root;
Node *del = _root;
while (del)
{
if (key < del->_key)
{
parent = del;
del = del->_left;
}
else if (key > del->_key)
{
parent = del;
del = del->_right;
}
else
{
break;
}
}
if (del == NULL)
{
return false;
}
if (del->_left == NULL)
{
if (del == _root)
{
_root = del->_right;
}
else
{
if (parent->_left == del)
{
parent->_left = del->_right;
}
else
{
parent->_right = del->_right;
}
}
}
else if (del->_right == NULL)
{
if (del == _root)
{
_root = del->_left;
}
else
{
if (parent->_left == del)
{
parent->_left = del->_left;
}
else
{
parent->_right = del->_left;
}
}
}
else
{
Node* sub = del;
Node* First = del->_right;
while (First->_left)
{
sub = First;
First = First->_left;
}
swap(del->_key, First->_key);
swap(del->_value, First->_value);
del = First;
if (del->_left == NULL)
{
if (sub->_left == del)
{
sub->_left = del->_right;
}
else
{
sub->_right = del->_right;
}
}
else if (del->_right == NULL)
{
if (sub->_left == del)
{
sub->_left = del->_left;
}
else
{
sub->_left = del->_left;
}
}
}
delete del;
del = NULL;
return true;
}
//删除(递归)
bool Remove_R(const K& key)
{
return _Remove_R(_root, key);
}
//遍历(中序)
void InOrder()
{
_InOrder(_root);
cout << endl;
}
protected:
bool _Insert_R(Node*& root, const K& key, const V& value)
{
if (root == NULL)
{
root = new Node(key, value);
return true;
}
if (key < root->_key)
{
return _Insert_R(root->_left, key, value);
}
else if (key > root->_key)
{
return _Insert_R(root->_right, key, value);
}
else
{
return false;
}
}
bool _Remove_R(Node*& root, const K& key)
{
if (root == NULL)
{
return false;
}
if (key < root->_key)
{
return _Remove_R(root->_left, key);
}
else if (key > root->_key)
{
return _Remove_R(root->_right, key);
}
else
{
Node* del = root;
if (root->_left == NULL)
{
root = root->_right;
}
else if (root->_right == NULL)
{
root = root->_left;
}
else
{
Node* First = root->_right;
while (First->_left)
{
First = First->_left;
}
swap(del->_key, First->_key);
swap(del->_value, First->_value);
return _Remove_R(root->_right, key);
}
delete del;
del = NULL;
return true;
}
}
void _InOrder(Node* root)
{
if (root == NULL)
{
return;
}
_InOrder(root->_left);
cout << root->_key << " ";
_InOrder(root->_right);
}
private:
BSTNode<K, V>* _root;
};