性质
-每个节点的key值各不相同
-左子树上所有节点的key值小于根结点
-右子树上的所有节点key值大于根结点
-左右子树都是二叉搜索树
Insert插入
bool Insert(const K& key)//非递归插入
{
if (_root == NULL)
{
_root = new Node (key);
return true;
}
Node* cur = _root;
Node* parent = NULL;
while (cur)
{
parent = cur;
if (key > parent->_key)
{
cur = parent->_right;
}
else if (key < parent->_key)
{
cur = parent->_left;
}
else
{
return false;
}
}
//cur找到NULL了,插入新节点
if (key < parent->_key)
{
parent->_left = new Node(key);
}
else
{
parent->_right = new Node(key);
}
return true;
}
Find查找
bool Find(const K& key)//非递归查找
{
if (_root == NULL) //空树直接返回
{
return false;
}
//非空树
Node* cur = _root:
while (cur)
{
if (key > cur->_key) //key值大 往右子树找
{
cur = cur->_right;
}
else if (key < cur->_key) //反之 左子树
{
cur = cur->_left;
}
else //找到了返回真
{
return true;
}
}
return false; //遍历之后发现并不存在
}
Remove删除
bool Remove(const K& key)//非递归删除
{
if (_root == NULL)
{
return false;
}
Node* cur = _root;
Node* parent = NULL;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else //找到了 分三种情况
{
if (cur->_left == NULL)//根的左为空
{
if (parent == NULL)
{
_root = cur->_right;
delete cur;
return true;
}
else
{
Node* tmp = cur->_right;
if (parent->_left == cur)
{
parent->_left = tmp;
}
else if (parent->_right == cur)
{
parent->_right = tmp;
}
delete cur;
return true;
}
}
else if(cur->_right == NULL)
{
Node* tmp = cur->_left;
if (parent->_left == cur)
{
parent->_left = tmp;
}
else if (parent->_right == cur)
{
parent->_right = tmp;
}
delete cur;
return true;
}
else//cur左右两个孩子均不为空
{
parent = cur;
Node* subleft = cur->_right;//找右孩子的最左节点
while (subleft->_left)
{
parent = subleft;
subleft = subleft->_left;
}
cur->_key = subleft->_key;
if (parent->_left == subleft)
{
parent->_left = subleft->_right;
}
else if (parent ->_right == subleft)
{
parent->_right = subleft->_right;
}
delete subleft;
return true;
}
}
}
return false;
}
二叉搜索树的退化和缺陷
-如果插入的数接近有序或者基本有序时,会成为一条单向单一的树,类似于链表
例如:{0,1,2,3,4,5,6,7,8,9}
这个时候它的时间复杂度为O(N),所以要考虑高度
附上详细代码
#pragma once
template<class K>
struct BinarySearchTreeNode
{
K _key;
BinarySearchTreeNode<K>* _left;
BinarySearchTreeNode<K>* _right;
BinarySearchTreeNode(const K& key)
:_key(key)
,_left(NULL)
,_right(NULL)
{}
};
template<class K>
class BSTree
{
typedef BinarySearchTreeNode<K> Node;
public:
BSTree() //无参构造
:_root(NULL)
{}
BSTree(K* a, size_t n) //构造函数
{
_root = NULL;
for (size_t i = 0; i < n; ++i)
{
InsertR(a[i]);
}
}
~BSTree()
{}
bool Insert(const K& key)//非递归插入
{
if (_root == NULL)
{
_root = new Node (key);
return true;
}
Node* cur = _root;
Node* parent = NULL;
while (cur)
{
parent = cur;
if (key > parent->_key)
{
cur = parent->_right;
}
else if (key < parent->_key)
{
cur = parent->_left;
}
else
{
return false;
}
}
//cur找到NULL了,插入新节点
if (key < parent->_key)
{
parent->_left = new Node(key);
}
else
{
parent->_right = new Node(key);
}
return true;
}
bool Find(const K& key)//非递归查找
{
if (_root == NULL) //空树直接返回
{
return false;
}
//非空树
Node* cur = _root:
while (cur)
{
if (key > cur->_key) //key值大 往右子树找
{
cur = cur->_right;
}
else if (key < cur->_key) //反之 左子树
{
cur = cur->_left;
}
else //找到了返回真
{
return true;
}
}
return false; //遍历之后发现并不存在
}
bool Remove(const K& key)//非递归删除
{
if (_root == NULL)
{
return false;
}
Node* cur = _root;
Node* parent = NULL;
while (cur)
{
if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else //找到了 分三种情况
{
if (cur->_left == NULL)//根的左为空
{
if (parent == NULL)
{
_root = cur->_right;
delete cur;
return true;
}
else
{
Node* tmp = cur->_right;
if (parent->_left == cur)
{
parent->_left = tmp;
}
else if (parent->_right == cur)
{
parent->_right = tmp;
}
delete cur;
return true;
}
}
else if(cur->_right == NULL)
{
Node* tmp = cur->_left;
if (parent->_left == cur)
{
parent->_left = tmp;
}
else if (parent->_right == cur)
{
parent->_right = tmp;
}
delete cur;
return true;
}
else//cur左右两个孩子均不为空
{
parent = cur;
Node* subleft = cur->_right;//找右孩子的最左节点
while (subleft->_left)
{
parent = subleft;
subleft = subleft->_left;
}
cur->_key = subleft->_key;
if (parent->_left == subleft)
{
parent->_left = subleft->_right;
}
else if (parent ->_right == subleft)
{
parent->_right = subleft->_right;
}
delete subleft;
return true;
}
}
}
return false;
}
//bool Insert(const K& key) //递归插入
//{
// return _InsertR(_root, key);
//}
// bool RemoveR(const K& key) //递归删除
// {
// return _RemoveR(_root, key);
// }
void Inorder()
{
_Inorder(_root);
cout << endl;
}
protected:
bool _InsertR(Node*& root,const K& key)
{
if (root == NULL)
{
root = new Node(key);
}
else
{
if (key > root->_key)
{
return _InsertR(root->_right, key);
}
else
{
return _InsertR(root->_left, key);
}
}
return true;
}
bool _RemoveR(Node*& root, const K& key)
{
if (root == NULL)
{
return false;
}
else if (root->_key > key)
{
return _RemoveR(root->_left, key);
}
else if (root->_key < key)
{
return _RemoveR(root->_right, key);
}
else //刚好根节点就是要删除的节点,分三种情况
{
if (root->_left == NULL) //根节点左为空
{
root = root->_right;
}
if (root->_right == NULL) //根节点右为空
{
root = root->_left;
}
else if //根节点左右都不为空,找替代节点
{
Node* parent = root;
Node* subleft = root->right;
while (subleft->_left)//右子树最左节点
{
root->key = subleft->key;
subleft = subleft->left;
}
}
}
}
void _Inorder(Node* root)
{
if (root == NULL)
{
return;
}
_Inorder(root->_left);
cout << root->_key << " ";
_Inorder(root->_right);
}
protected:
Node* _root;
};
void TestBSTree()
{
int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
BSTree<int> t1;
for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
{
t1.Insert(a[i]);
}
t1.Inorder();
t1.Remove(1);
t1.Inorder();
t1.Remove(0);
t1.Inorder();
t1.Remove(9);
t1.Inorder();
t1.Remove(5);
t1.Inorder();
t1.Remove(2);
t1.Inorder();
t1.Remove(3);
t1.Inorder();
t1.Remove(4);
t1.Inorder();
t1.Remove(6);
t1.Inorder();
t1.Remove(7);
t1.Inorder();
t1.Remove(8);
t1.Inorder();
}