本文介绍了二叉搜索树的概念，包括其定义和性质。二叉搜索树分为K模型和KV模型，K模型用于判断单词拼写正确性，通过构建二叉搜索树进行检索；KV模型在现实生活中广泛应用，如英汉词典，通过二叉搜索树实现快速查找键值对。文章详细阐述了如何利用二叉搜索树解决实际问题。
1 二叉搜索树概念
- 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
- 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
- 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
- 它的左右子树也分别为二叉搜索树
2 二叉搜索树概念
#include<time.h>
#include<iostream>
using namespace std;
template <class T>
struct BNode
{
T _data;
typedef BNode<T> Node;
Node* _left;
Node* _right;
BNode(const T& data)
:_data(data)
, _left(nullptr)
, _right(nullptr)
{}
};
template <class T>
class BTree
{
public:
typedef BNode<T> Node;
Node* find(const T& val)
{
Node* cur = _root;
while (cur)
{
if (cur->_data == val)
return cur;
else if (cur->_data > val)
cur = cur->_left;
else
cur = cur->_right;
}
}
//拷贝二叉搜索树的数据和结构
Node* copy(Node* root)
{
if (root == nullptr)
return nullptr;
Node* newNode = new Node(root->_data);
newNode->_left = copy(root->_left);
newNode->_right = copy(root->_right);
return newNode;
}
//拷贝构造
BTree(const BTree<T>& btree)
:_root(copy(btree._root))
{}
BTree()
:_root(nullptr)
{}
//不插入重复的值
bool insert(const T& val)
{
//插入第一个值
if (_root == nullptr)
{
_root = new Node(val);
return true;
}
//找到需要插入元素的位置
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
parent = cur;
if (cur->_data == val)
return false;
else if (cur->_data > val)
cur = cur->_left;
else
cur = cur->_right;
}
//插入
cur = new Node(val);
if (parent->_data > val)
parent->_left = cur;
else
parent->_right = cur;
return true;
}
void inorder()
{
_inorder(_root);
cout << endl;
}
//搜索树的中序遍历有序
void _inorder(Node* root)
{
if (root)
{
_inorder(root->_left);
cout << root->_data << " ";
_inorder(root->_right);
}
}
//销毁
void destroy(Node* root)
{
if (root)
{
destroy(root->_left);
destroy(root->_right);
cout << "destroy:" << root->_data << endl;
delete root;
}
}
~BTree()
{
if (_root)
{
destroy(_root);
_root = nullptr;
}
}
bool erase(const T& val)
{
//查找
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_data == val)
break;
parent = cur;
if (cur->_data > val)
cur = cur->_left;
else
cur = cur->_right;
}
//删除
//1.删除的为叶子节点
if (cur->_left == nullptr && cur->_right == nullptr)
{
//判断是否为根节点
if (cur == _root)
{
_root = nullptr;
}
else
{
//判断需要删除的父节点在哪一边
if (parent->_left == cur)
parent->_left = nullptr;
else
parent->_right = nullptr;
}
//删除节点
delete cur;
}
else if (cur->_left == nullptr) //左为空
{
//判断是否为根节点
if (cur == _root)
{
//更新根节点
_root = cur->_right;
}
else
{
if (parent->_left == cur)
parent->_left = cur->_right;
else
parent->_right = cur->_right;
}
//删除节点
delete cur;
}
else if (cur->_right == nullptr)
{
//判断是否为根节点
if (cur == _root)
{
//更新根节点
_root = cur->_left;
}
else
{
if (parent->_left == cur)
parent->_left = cur->_left;
else
parent->_right = cur->_left;
}
delete cur;
}
return true;
}
private:
Node* _root;
};
生成随机数，然后进行中序遍历
//void test()
//{
// BTree<int> b;
// srand(time(nullptr));
// int num;
// cin >> num;
// for (int i = 0; i < num; i++)
// {
// b.insert(rand());
// }
//
// b.inorder();
//
// BTree<int> copy(b);
// copy.inorder();
//}
void test()
{
BTree<int> b;
b.insert(50);
b.insert(90);
b.insert(30);
b.insert(20);
b.insert(80);
b.insert(40);
b.insert(70);
b.insert(5);
b.insert(500);
//中序遍历有序
b.inorder();
}
int main()
{
test();
return 0;
}
3 二叉搜索树的应用
- K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
以单词集合中的每个单词作为key，构建一棵二叉搜索树
在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。 - KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。
比如：实现一个简单的英汉词典dict，可以通过英文找到与其对应的中文，具体实现方式如下：
- <单词，中文含义>为键值对构造二叉搜索树，注意：二叉搜索树需要比较，键值对比较时只比较
Key - 查询英文单词时，只需给出英文单词，就可快速找到与其对应的key
#include<iostream>
using namespace std;
template <class K,class V>
struct BNode
{
K _key; //索引
V _value; //data
typedef BNode<K,V> Node;
Node* _left;
Node* _right;
BNode(const K& key,const V& value)
:_key(key)
,_value(value)
, _left(nullptr)
, _right(nullptr)
{}
};
template <class K,class V>
class BTree
{
public:
typedef BNode<K,V> Node;
Node* find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (cur->_key == key)
return cur;
else if (cur->_key > key)
cur = cur->_left;
else
cur = cur->_right;
}
return cur;
}
//拷贝二叉搜索树的数据和结构
Node* copy(Node* root)
{
if (root == nullptr)
return nullptr;
Node* newNode = new Node(root->_key,root->_value);
newNode->_left = copy(root->_left);
newNode->_right = copy(root->_right);
return newNode;
}
//拷贝构造
BTree(const BTree<K,V>& btree)
:_root(copy(btree._root))
{}
BTree()
:_root(nullptr)
{}
//不插入重复的值
bool insert(const K& key,const V& value)
{
//插入第一个值
if (_root == nullptr)
{
_root = new Node(key,value);
return true;
}
//找到需要插入元素的位置
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
parent = cur;
if (cur->_key == key)
return false;
else if (cur->_key > key)
cur = cur->_left;
else
cur = cur->_right;
}
//插入
cur = new Node(key,value);
if (parent->_key > key)
parent->_left = cur;
else
parent->_right = cur;
return true;
}
void inorder()
{
_inorder(_root);
cout << endl;
}
//搜索树的中序遍历有序
void _inorder(Node* root)
{
if (root)
{
_inorder(root->_left);
cout << root->_key << "-->"<<root->_value<<" ";
_inorder(root->_right);
}
}
//销毁
void destroy(Node* root)
{
if (root)
{
destroy(root->_left);
destroy(root->_right);
cout << "destroy:" << root->_key <<"-->"<<root->_value<<endl;
delete root;
}
}
~BTree()
{
if (_root)
{
destroy(_root);
_root = nullptr;
}
}
bool erase(const K& key)
{
//查找
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (cur->_key == key)
break;
parent = cur;
if (cur->_key > key)
cur = cur->_left;
else
cur = cur->_right;
}
//删除
//1.删除的为叶子节点
if (cur->_left == nullptr && cur->_right == nullptr)
{
//判断是否为根节点
if (cur == _root)
{
_root = nullptr;
}
else
{
//判断需要删除的父节点在哪一边
if (parent->_left == cur)
parent->_left = nullptr;
else
parent->_right = nullptr;
}
//删除节点
delete cur;
}
else if (cur->_left == nullptr) //左为空
{
//判断是否为根节点
if (cur == _root)
{
//更新根节点
_root = cur->_right;
}
else
{
if (parent->_left == cur)
parent->_left = cur->_right;
else
parent->_right = cur->_right;
}
//删除节点
delete cur;
}
else if (cur->_right == nullptr)
{
//判断是否为根节点
if (cur == _root)
{
//更新根节点
_root = cur->_left;
}
else
{
if (parent->_left == cur)
parent->_left = cur->_left;
else
parent->_right = cur->_left;
}
delete cur;
}
else
{
//左右子树都存在
//1.假设找左子树的最右节点
Node* leftRightMost = cur->_left;
parent = cur;
while (leftRightMost->_right)
{
parent = leftRightMost;
leftRightMost = leftRightMost->_right;
}
//2.交换
swap(cur->_key, leftRightMost->_key);
swap(cur->_value, leftRightMost->_value);
//3.删除最右节点
if (parent->_left == leftRightMost)
parent->_left = leftRightMost->_left;
else
parent->_right = leftRightMost->_left;
//4.删除最右节点
delete leftRightMost;
}
return true;
}
private:
Node* _root;
};
void test()
{
BTree<int,int> b;
b.insert(5,50);
b.insert(3,30);
b.insert(7,70);
b.insert(1,10);
b.insert(4,40);
b.insert(6,60);
b.insert(8,80);
b.insert(0,100);
b.insert(2,20);
b.insert(9,90);
b.inorder();
b.erase(5);
b.inorder();
}
int main()
{
test();
return 0;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
