C++ 数据结构--二叉搜索树的实现
文章目录
-
- 前言
- 类模板的声明
- 构造和析构
- 修改（非递归）
- 修改（递归）
- hpp文件
前言
二叉搜索树（BST，Binary Search Tree），也称二叉排序树，二叉查找树。若不是空树，二叉搜索树满足以下性质
1.左子树的所有节点小于根节点
2.右子树的所有节点大于根节点
3.左右子树都满足以上性质
二叉搜索树多用来查找，时间效率是O(n)，效率非常高，即使是最坏情况，查找次数也是高度次。
类模板的声明
template <class K>
struct BSTreeNode
{
BSTreeNode(K key)
{
_key = key;
_left = nullptr;
_right = nullptr;
}
BSTreeNode<K>* _left;
BSTreeNode<K>* _right;
K _key; // 数据域
};
template <class K>
class BSTree
{
typedef BSTreeNode<K> Node;
private:
Node* CopyTree(Node* root); // 拷贝一颗树，返回树的根节点
void DestoryTree(Node* root); // 释放每个节点
bool _FindR(const K& key, Node* cur);
bool _InsertR(const K& key, Node*& cur);
bool _EraseR(const K& key, Node*& cur);
public:
// 构造和析构
BSTree() = default; // 强制使用默认生成的构造
BSTree(const BSTree& t) { _root = CopyTree(t._root); }
~BSTree() { DestoryTree(_root); _root = nullptr; }
const BSTree& operator=(BSTree t);
// 修改
bool Insert(const K& key);
bool InsertR(const K& key) { return _InsertR(key, _root); }
bool Find(const K& key);
bool FindR(const K& key) { return _FindR(key, _root); }
bool Erase(const K& key);
bool EraseR(const K& key) { return _EraseR(key, _root); }
// 打印
void PrintTree() { _PrintTree(_root); }
void _PrintTree(Node* root);
private:
Node* _root = nullptr;
};
构造和析构
二叉搜索树的构造函数，在成员列表给_root缺省值nulllptr就行了。但后面要实现拷贝构造，因为拷贝构造也属于构造函数，不显式写构造函数编译器不会自动生成默认构造，在构造函数后面给缺省值default是C++11的语法，能强制构造函数使用编译器默认生成的。
拷贝构造函数：调用子函数CopyTree进行递归，一个参数是根节点的指针。
- 假设拷贝的树没有节点，判断根节点为空，返回nullptr
- 如果只有一个节点，根据该节点的key值new一个新的节点并且返回新的节点
- 如果节点数大于一个节点，在拷贝新的根节点后，拷贝根节点子树的根节点，并链接到根节点上。
template <class K>
typename::BSTree<K>::Node* BSTree<K>::CopyTree(Node* root)
{
if (root == nullptr)
return nullptr;
Node* copyNode = new Node(root->_key);
copyNode->_left = CopyTree(root->_left);
copyNode->_left = CopyTree(root->_right);
return copyNode;
}
拷贝构造调用这个子函数即可
析构函数也需要调用子函数Destroy递归释放每个节点，递归函数的逻辑和后续遍历相似：先释放左右子树的节点，最后再释放自己。
template <class K>
void BSTree<K>::DestroyTree(Node* root)
{
if (root == nullptr)
return;
DestroyTree(root->_left);
DestroyTree(root->_right);
delete root;
}
赋值就调用拷贝构造，拷贝出参数t，再交换t和当前树（形参在传递时会调用拷贝构造生成t）
template <class K>
const BSTree<K>& BSTree<K>::operator=(BSTree t)
{
std::swap(_root, t._root);
return *this;
}
修改（非递归）
插入，查找和删除。插入的思路：将key值和节点的key值比较，大于往右走，小于往左走，直到走到nullptr，new新的节点。但是原来的树并没有被修改，所以在迭代的过程中需要记录父母，当走到空时判断父母的key值和参数key值的关系，从而判断要将新节点链接到父母的左边还是右边。
template <class K>
bool BSTree<K>::Insert(const K& key)
{
if (_root == nullptr)
{
_root = new Node(key);
return true;
}
Node* cur = _root;
Node* parent = nullptr;
while (cur) // cur走到空停止
{
if (key < cur->_key) // 小于往左
{
parent = cur;
cur = cur->_left;
}
else if (key > cur->_key) // 大于往右
{
parent = cur;
cur = cur->_right;
}
else
{
return false; // 不插入相等的key
}
}
if (key < parent->_key)
{
parent->_left = new Node(key);
return true;
}
else
{
parent->_right = new Node(key);
return ture;
}
}
查找的思路和插入一样，走到else的地方说明找到了，返回true，循环结束还没找到，返回false
template <class K>
bool BSTree<K>::Find(const K& key)
{
Node* cur = _root;
while (cur)
{
if (key < cur->_key) // 当前值较小，向左走
{
cur = cur->_left;
}
else if (key > cur->_key)
{
cur = cur->_right;
}
else
{
return true;
}
}
// 循环结束还没找到就是没有这个数
return false;
}
删除就有一点麻烦，分为两种情况，一种是要删除的节点没有子节点或只有一个字节，在找要被删除的节点时需要记录父母，然后让父母的左或右指向被删除节点的子节点（如果被删除节点左为空，父母指向右，右为空，父母指向左）。但删除根节点时，由于根节点没有父母，所以直接对_root进行修改即可。
另一种情况就是被删节点有两个孩子，需要找出被删节点的左树最大或者右树最小的节点，替换被删节点，不删除被删除节点，而是删除左树最大或右树最小节点（转换成第一种情况）。替换节点后，树依然满足搜索二叉树的性质（被删节点的左树最大，小于被删节点，大于左树所有节点，被删节点小于右树所有节点，其左树最大也小于右树所有节点）。
template <class K>
bool BSTree<K>::Erase(const K& key)
{
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (key < cur->_key)
{
parent = cur;
cur = cur->_left;
}
else if (key > cur->_right)
{
parent = cur;
cur = cur->_right;
}
else // 找到的情况
{
// 被删节点
if (cur->_left == nullptr)
{
if (cur == _root) // 根节点无父节点
{
_root = _root->_right;
delete cur;
}
else
{
if (key < parent->_key) // cur在parent的左边
{
parent->_left = cur->_right;
delete cur;
}
else
{
parent->_right = cur->_right;
delete cur;
}
}
return true;
}
else if (cur->_right == nullptr)
{
if (cur == _root) // 根节点无父节点
{
_root = _root->_left;
delete cur;
}
else
{
if (key < parent->_key) // cur在parent的左边
{
parent->_left = cur->_left;
delete cur;
}
else
{
parent->_right = cur->_left;
delete cur;
}
}
return true;
}
else // 有两子节点
{
Node* leftMax = cur->_left;
Node* maxParent = cur;
while (leftMax->_right) // 找左树最大
{
maxParent = leftMax;
leftMax = leftMax->_right;
}
cur->_key = leftMax->_key;
// 删除leftMax节点
if (maxParent ->_left == leftMax)
{
maxParent ->_left = leftMax->_left;
delete leftMax;
}
else
{
maxParent ->_right = leftMax->_left;
delete leftMax;
}
}
}
}
// 循环结束，表示还没找到
return false;
}
修改（递归）
和非递归相比，递归就来的好写的多，但理解也偏难。用递归的思想插入：如果当前节点为空，直接插入，不为空判断，小于当前节点，往左。大于当前节点，往右。但递归需要调用子函数（主函数直接说插入的key，但递归需要判断节点是否为空来决定是否要继续递归，所以子函数比主函数多了一个参数–节点的指针）
template <class K>
bool BSTree<K>::_InsertR(const K& key, Node*& cur)
{
if (cur == nullptr)
{
cur = new Node(key);
return true;
}
if (key < cur->_key)
{
return _InsertR(key, cur->_left);
}
else if (key > cur->_key)
{
return _InsertR(key, cur->_right);
}
else
{
return false;
}
}
主函数调用子函数即可
注意：非递归需要使用parent记录被删除节点的父节点，但递归却不用，原因是节点指针使用了引用。
查找的思路和插入一样，比大小判断往左还是往右走，相等返回true
template <class K>
bool BSTree<K>::_FindR(const K& key, Node* cur)
{
if (cur == nullptr)
{
return false;
}
if (key < cur->_key)
{
return _FindR(key, cur->_left);
}
else if (key > cur->_key)
{
return _FindR(key, cur->_right);
}
else
{
return true;
}
}
删除的递归就比较复杂，但思路和前两个类似，在找到节点时分为两种情况。只有一个节点或没有节点的情况不用设置parent，使用引用，这样的话也不用判断是否是根节点。遇到有两个子节点的情况，找左树最小就要设置parent了，虽然cur是引用，但假设找leftMax也用引用，leftMax一直都是刚开始被定义时的引用，引用的对象没有被修改，具体的原理在我的C++入门有介绍。
template <class K>
bool BSTree<K>::_Erase(const K& key, Node*& cur)
{
if (cur == nullptr)
{
return false;
}
if (key < cur->_key)
{
return _Erase(key, cur->_left);
}
else if (key > cur->_key)
{
return _Erase(key, cur->_right);
}
else
{
if (cur->_left == nullptr)
{
Node* del = cur;
cur = cur->_right;
delete del;
}
else if (cur->_right == nullptr)
{
Node* del = cur;
cur = cur->_left;
delete del;
}
else
{
Node* leftMax = cur->_left;
Node* maxParent = cur;
while (leftMax->_right)
{
parent = leftMax;
leftMax = leftMax->_right;
}
cur->_key = leftMax->_key;
if (maxParent ->_left == leftMax)
{
maxParent ->_left = leftMax->_left;
delete leftMax;
}
else
{
maxParent ->_right = leftMax->_left;
delete leftMax;
}
}
return true;
}
}
对于有两个子节点的情况，还有一种写法，不设置parent，找到leftMax后不覆盖原来cur的key值，而交换两者的值，调用自己，删除被交换后的节点。但交换后的整颗树不满足搜索树的性质，但cur的左树是满足的，所以传的根节点为左子树的根节点。
else
{
Node* leftMax = cur->_left;
while (leftMax->_right)
{
leftMax = leftMax->_right;
}
swap(cur->_key, leftMax->key); // 交换key值
_Erase(key, cur->_left);
}
hpp文件
最后放出整个文件的代码
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include