概念
二叉搜索树又称二叉排序树、二叉查找树,它或者是一棵空树,或者是具有以下性质的二叉树:
- 若它的左子树不为空,则左子树上所有节点的值都小于根结点的值
- 若它的右子树不为空,则右子树上所有节点的值都大于根节点的值
- 它的左右子树分别为二叉搜索树
查找时间为O(N),高度次
二叉树搜索树模型搭建
#pragma once
#include <iostream>
using namespace std;
template<class k>
struct BSTreeNode
{
BSTreeNode<k>* _left;
BSTreeNode<k>* _right;
k _key;
BSTreeNode(const k& key)
:_key(key)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class k>
class BSTree
{
typedef BSTreeNode<k> Node;
public:
BSTree()
:_root(nullptr)
{}
private:
Node* _root;
};
二叉排序树插入
#pragma once
#include <iostream>
using namespace std;
template<class k>
struct BSTreeNode
{
BSTreeNode<k>* _left;
BSTreeNode<k>* _right;
k _key;
BSTreeNode(const k& key)
:_key(key)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class k>
class BSTree
{
typedef BSTreeNode<k> Node;
public:
BSTree()
:_root(nullptr)
{}
bool Insert(const k& key)
{
if (_root == nullptr)
{
_root = new Node(key);
return true;
}
Node* parent = nullptr;
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;
}
}
cur = new Node(key);
if (parent->_key < key)
{
parent->_right = cur;
}
else
{
parent->_left = cur;
}
return true;
}
//因为成员为私有的,所以可以直接在类里直接调用
void InOrder()
{
_InOrder(_root);
}
void _InOrder(Node* root)
{
if (root == NULL)
{
return;
}
_InOrder(root->_left);
cout << root->_key << " ";
_InOrder(root->_right);
}
private:
Node* _root;
};
void TestBSTree1()
{
int a[] = { 8,3,1,10,6,4,7,14,13 };
BSTree<int> t;
for (auto e : a)
{
t.Insert(e);
}
t.InOrder();
}
递归插入
注意我们这里每次使用的是引用递归
template<class k>
struct BSTreeNode
{
BSTreeNode<k>* _left;
BSTreeNode<k>* _right;
k _key;
BSTreeNode(const k& key)
:_key(key)
, _left(nullptr)
, _right(nullptr)
{}
};
template<class k>
class BSTree
{
typedef BSTreeNode<k> Node;
public:
BSTree()
:_root(nullptr)
{}
bool InsertR(const k& key)
{
return _InsertR(_root, key);
}
private:
//插入
bool _InsertR(Node*& root, const k& key)
{
if (root == nullptr)
{
root = new Node(key);
return true;
}
if (root->_key < key)
{
_InsertR(root->_right, key);
}
else if (root->_key > key)
{
_InsertR(root->_left, key);
}
else
return false;
}
private:
Node* _root;
};
二叉排序树查找
bool Find(const k& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key < key)
{
cur = cur->_right;
}
else if (cur->_key > key)
{
cur = cur->_left;
}
else if (cur->_key == key)
{
return true;
}
}
//cur为空 查找失败
return false;
}
递归查找
public:
//递归实现二叉搜索树方法
// 查找
bool FindR(const k& key)
{
return _FindR(_root, key);
}
private:
//查找
bool _FindR(Node*& root, const k& key)
{
if (root == nullptr)
{
return false;
}
if (root->_key < key)
{
return _FindR(root->_right, key);
}
else if (root->_key > key)
{
return _FindR(root->_left, key);
}
else
return true;
}
二叉排序树删除
//结点的删除
bool Erase(const k& key)
{
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_key < key)
{
parent = cur;
cur = cur->_right;
}
else if (cur->_key > key)
{
parent = cur;
cur = cur->_left;
}
else//找到了
{
//左为空
if (cur->left == nullptr)
{
if (cur == _root)
{
_root = cur->_right;
}
else
{
if (parent->_right == cur)
{
parent->_right = cur->_right;
}
else
{
parent->_left = cur->_right;
}
}
}//根节点右为空
else
{
if (cur->_right == nullptr)
{
if (cur == _root)
{
_root = cur->_left;
}
else
{
if (parent->_right == cur)
{
parent->_right = cur->_left;
}
else
{
parent->_left = cur->_left;
}
}
} // 根节点左右都不为空
else
{
//找替代节点
Node* parent = cur;
Node* leftMax = cur->_left;
while (leftMax->_right)
{
parent = leftMax;
leftMax = leftMax->_right;
}
swap(cur->_key, leftMax->_key);
if (parent->_left == leftMax)
{
parent->_left = leftMax->_left;
}
else
{
parent->_right = leftMax->_left;
}
cur = leftMax;
}
}
delete cur;
return true;
}
}
return false;
}
如果删除的数字时3和10
如果删除的为根结点,则我们就需要改进
如果要删除的节点左右不为空
递归删除
这里还是注意引用的使用方法
public:
//删除
bool EraseR(const k& key)
{
return _EraseR(_root, key);
}
private:
//删除
bool _EraseR(Node*& root, const k& key)
{
if (root->_key < key)
{
_EraseR(root->_right, key);
}
else if (root->_key > key)
{
_EraseR(root->_left, key);
}
else
{
//准备删除
Node* del = root;
//开始删除
//左右为空
if (root->_left == nullptr)
{
root = root->_right;
}
else if (root->_right == nullptr)
{
root = root->_left;
}
else
{
//左右不为空
Node* maxleft = root->_left;
while (maxleft->_right)
{
maxleft = maxleft->_right;
}
swap(root->_key, maxleft->_key);
_EraseR(root->_left, key);
}
delete del;
return true;
}
}