嗨喽大家好，时隔许久阿鑫又给大家带来了新的博客，c++进阶——二叉搜索树，下面让我们开始今天的学习吧！
c++进阶_二叉搜索树
- 内容安排说明
- 二叉搜索树实现
- 二叉树搜索树应用分析
- 二叉树进阶面试题
1. 内容安排说明
二叉树最重要的一点就是将每一个节点看成一个子树的根，对于理解会方便很多
- map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构
- 二叉搜索树的特性了解，有助于更好的理解map和set的特性
- 二叉树中部分面试题稍微有点难度，在前面讲解大家不容易接受，且时间长容易忘
- 有些OJ题使用C语言方式实现比较麻烦，比如有些地方要返回动态开辟的二维数组，非常麻
烦
2. 二叉搜索树实现
2.1二叉搜索树概念
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
- 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
- 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
- 它的左右子树也分别为二叉搜索树
2.2 二叉搜索树操作
对于二叉搜索树，进行中序遍历得到的是有序的数
-
二叉搜索树的查找
a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。 -
二叉搜索树的插入
插入的具体过程如下：
a. 树为空，则直接新增节点，赋值给root指针
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
二叉搜索树的功能
-
二叉搜索树的删除
在二叉搜索树中，子树的最左和最右节点分别为最小和最大的节点
首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情
况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
如下：
- 情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
- 情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
- 情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点
中，再来处理该结点的删除问题–替换法删除
#pragma once
#include<iostream>
using namespace std;
template<class K>
struct BSTNode
{
K _key;
BSTNode* _left;
BSTNode* _right;
BSTNode(const K& key)
:_key(key)
,_left(nullptr)
,_right(nullptr)
{}
};
//
template<class K>
class BSTree
{
typedef BSTNode<K> Node;
public:
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;
}
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
{
return true;
}
}
return false;
}
bool Erase(const K& key)
{
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
{
// 删除
// 0-1个孩子
if (cur->_right == nullptr)
{
if (parent == nullptr)
{
_root = cur->_left;
}
else
{
if (parent->_right == cur)
{
parent->_right = cur->_left;
}
else
{
parent->_left = cur->_left;
}
}
delete cur;
return true;
}
else if (cur->_left == nullptr)
{
if (parent == nullptr)
{
_root = cur->_right;
}
else
{
if (parent->_right == cur)
{
parent->_right = cur->_right;
}
else
{
parent->_left = cur->_right;
}
}
delete cur;
return true;
}
else
{
// 2个孩子的情况
// 右子树的最小节点作为替代节点
Node* RightMin = cur->_right;
Node* RightMinp = cur;
while (RightMin->_left)
{
RightMinp = RightMin;
RightMin = RightMin->_left;
}
cur->_key = RightMin->_key;
if (RightMinp->_right == RightMin)
{
RightMinp->_right = RightMin->_right;
}
else if (RightMinp->_left == RightMin)
{
RightMinp->_left = RightMin->_right;
}
delete RightMin;
return true;
}
}
}
}
void _Inorder()
{
Inorder(_root);
cout << endl;
}
private:
void Inorder(Node* _root)
{
Node* cur = _root;
if (_root == nullptr)
{
return;
}
Inorder(cur->_left);
cout << cur->_key << " ";
Inorder(cur->_right);
}
private:
Node* _root = nullptr;
};
}
#include"SearchBinaryTree.h"
int main()
{
// 1、查找
// 2、去重
// 3、排序+去重
int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
//int a[] = { 8, 3, 3, 1, 3, 10, 6, 3, 4, 7, 5, 14, 13 };
BSTree<int> t;
for (auto e : a)
{
t.Insert(e);
}
t.Insert(4);
t.Insert(16);
t.InOrder();
//t.Erase(3);
//t.InOrder();
t.Erase(4);
t.InOrder();
t.Erase(3);
t.InOrder();
for (auto e : a)
{
t.Erase(e);
t.InOrder();
}
return 0;
}
2.4 二叉搜索树的应用
- K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到
的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
- 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
- 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
- KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方
式在现实生活中非常常见：
- 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英
文单词与其对应的中文<word, chinese>就构成一种键值对； - 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
现次数就是<word, count>就构成一种键值对
// 改造二叉搜索树为KV结构
template<class K, class V>
struct BSTNode
{
BSTNode(const K& key = K(), const V& value = V())
: _pLeft(nullptr) , _pRight(nullptr), _key(key), _Value(value)
{}
BSTNode<T>* _pLeft;
BSTNode<T>* _pRight;
K _key;
V _value
};
template<class K, class V>
class BSTree
{
typedef BSTNode<K, V> Node;
typedef Node* PNode;
public:
BSTree(): _pRoot(nullptr){}
PNode Find(const K& key);
bool Insert(const K& key, const V& value)
bool Erase(const K& key)
private:
PNode _pRoot;
};
void TestBSTree3()
{
// 输入单词，查找单词对应的中文翻译
BSTree<string, string> dict;
dict.Insert("string", "字符串");
dict.Insert("tree", "树");
dict.Insert("left", "左边、剩余");
dict.Insert("right", "右边");
dict.Insert("sort", "排序");
// 插入词库中所有单词
string str;
while (cin>>str)
{
BSTreeNode<string, string>* ret = dict.Find(str);
if (ret == nullptr)
{
cout << "单词拼写错误，词库中没有这个单词:" <<str <<endl;
}
else
{
cout << str << "中文翻译:" << ret->_value << endl;
}
}
}
void TestBSTree4()
{
// 统计水果出现的次数
string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉" };
BSTree<string, int> countTree;
for (const auto& str : arr)
{
// 先查找水果在不在搜索树中
// 1、不在，说明水果第一次出现，则插入<水果, 1>
// 2、在，则查找到的节点中水果对应的次数++
//BSTreeNode<string, int>* ret = countTree.Find(str);
auto ret = countTree.Find(str);
if (ret == NULL)
{
countTree.Insert(str, 1);
}
else
{
ret->_value++;
}
}
countTree.InOrder();
}
2.5 二叉搜索树的性能分析
3.二叉树进阶面试
class Solution {
public:
string tree2str(TreeNode *root) {
if (root == nullptr) {
return "";
}
if (root->left == nullptr && root->right == nullptr) {
return to_string(root->val);
}
if (root->right == nullptr) {
return to_string(root->val) + "(" + tree2str(root->left) + ")";
}
//左右子树都不为空或者左子树为空时
return to_string(root->val) + "(" + tree2str(root->left) + ")(" + tree2str(root->right) + ")";
}
};
class Solution {
//做这种题还是得从底往上找方法
//将每一个节点都看成一颗子树的根
public:
TreeNode* ans;
bool dfs(TreeNode* root, TreeNode* p, TreeNode* q)
{
//共计两种情况
//1.以某一颗子树为根，该子树的左子树和右子树都有一个孩子节点，最近祖先节点为该子树的根
//2.某一个孩子节点为根，另一个孩子节点在以该节点为根的子树上,最近祖先节点为第一个孩子节点
if(root==nullptr)
return false;
bool bleft = dfs(root->left,p,q);//用来表示左子树有无孩子节点
bool bright = dfs(root->right,p,q);//用来表示右子树有无孩子节点
if((bleft&&bright)||(root->val==p->val)||(root->val==q->val))
ans = root;
return (bleft||bright)||(root->val==p->val)||(root->val==q->val);//用来表示子树有无孩子节点
}
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
dfs(root,p,q);
return ans;
}
};
扫一扫
169
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
