【数据结构】 二叉搜索树的模拟实现——完整代码
二叉搜索树是支持set和map 实现的底层结构。
在上篇博客 二叉搜索树中，我详细讲到过实现的原理。
这里我主要完成二叉搜索树的完整代码中包含的几个接口：
构造函数，析构函数，拷贝构造，赋值重载，查找，插入，删除，打印
及测试过程。
BSTree.h
#define _CRT_SECURE_NO_WARNINGS 1
# pragma once
#include
#include
using namespace std;
namespace LY
{
template
struct BSTNode
{
BSTNode(const K&data = K())
:_left(nullptr)
, _right(nullptr)
, _data(data)
{}
BSTNode* _left;
BSTNode* _right;
K _data;
};
template
class BSTree
{
typedef BSTNode Node;
public:
BSTree() //构造函数
: _root(nullptr)
{}
~BSTree() //析构函数
{
Destroy(_root);
}
void Destroy(Node* root) //需要递归后序遍历销毁
{
if (root == nullptr) return;
Destroy(root->_left);
Destroy(root->_right);
delete root;
}
BSTree(const BSTNode &tree) //拷贝构造
{
_root = Copy(tree._root);
}
BSTree &operator =(const BSTree &tree) //赋值重载
{
if (this != &tree)
{
Destroy(_root);
_root = Copy(tree._root);
}
return *this;
}
//BSTree &operator=(const BSTree tree) //将形参写成局部变量
//{
// swap(_root, tree->_root);
// return *this;
//}
Node* Copy(Node* root) //拷贝一棵树
{
if (root == nullptr) return root;
Node* newroot = new Node(root->_data);
newroot->_left = Copy(root->_left);
newroot->_right = Copy(root->_right);
return newroot;
}
bool Insert(const K & val) //插入
{
if (_root == nullptr) //树为空时直接插入
{
_root = new Node(val);
return true;
}
Node* cur = _root; //树不空时，先确定位置再插入
Node* parent = nullptr;
while (cur) //确定位置
{
parent = cur;
if (val > cur->_data) //val大于当前节点的值就向右找
cur = cur->_right;
else if (val < cur->_data) //val 小于当前节点的值就向左找
cur = cur->_left;
else //val 等于当前节点的值，不允许插入
return false;
}
cur = new Node(val); //插入元素并与树连接
if (val>(parent->_data))
parent->_right = cur;
else
parent->_left = cur;
return true;
}
Node* Find(const K& val) //查找，其中：右树的值 > 根节点的值 > 左树的值
{
Node* cur = _root;
while (cur)
{
if (val == cur->_data)
return cur; //找到返回当前结点
else if (val > cur->_data)
cur = cur->_right;
else
cur = cur->_left;
}
return nullptr; //找不到返回空值
}
bool Erase(const K&val) //删除
{
if (_root == nullptr) return false; //树为空，无法删除
Node* cur = _root;
Node* parent = nullptr;
while (cur)
{
if (val == cur->_data)
break;
else if (val < cur->_data)
{
parent = cur;
cur = cur->_left;
}
else
{
parent = cur;
cur = cur->_right;
}
}
if (nullptr == cur) return false; //找不到，无法删除
/* 找到以后要删除时由三种情况
1. 要删除的结点是叶子节点或只有左孩子，则将被删除结点的双亲节点指向被删除节点的左孩子
2. 要删除的结点只有右孩子，则将被删除结点的双亲节点指向被删除节点的这个孩子
3. 要删除的结点既有左孩子也有右孩子，则在被删除结点的左子树中找最右结点（或者在右子树中最左结点）与要删除的结点交换值，再删除替代结点。*/
Node* del = cur;
if (cur->_right == nullptr) //1. 是叶子或只有左孩子
{
if (parent == nullptr) _root = _root->_left; //要删节点是根节点
if (parent->_left == cur)
parent->_left = cur->_left;
else
parent->_right = cur->_left;
}
else if (cur->_left == nullptr) //2. 只有右孩子
{
if (parent == nullptr) _root = _root->_right; //要删节点是根节点
if (parent->_left == cur)
parent->_left = cur->_right;
else
parent->_right = cur->_right;
}
else //既有左孩子又有右孩子
{
Node* replace = cur->_right; //用右树最左进行替代
Node* pre = cur; //替代节点的双亲节点，关键！！
while (replace->_left) //找到右树最左结点
{
pre = replace;
replace = replace->_left;
}
cur->_data = replace->_data;
if (pre->_left==replace) //替代节点的双亲节点与它的下个结点连接
pre->_left = replace->_right;
else pre->_right = replace->_right;
del = replace;
}
delete del;
return true;
}
void Print() //按中序输出这颗有序树
{
Inorder(_root);
cout << endl;
}
void Inorder(Node* root)
{
if (root)
{
Inorder(root->_left);
cout << root->_data << " ";
Inorder(root->_right);
}
}
private:
Node* _root;
};
void TestBST()
{
BSTree btree;
btree.Insert(1); //插入
btree.Insert(3);
btree.Insert(5);
btree.Insert(2);
btree.Insert(4);
btree.Insert(6);
btree.Print();
//BSTree b2(btree); //拷贝构造
//b2.Print();
//BSTree b3;
//b3.Insert(3);
//b3.Insert(4);
//b3.Insert(1);
//b3.Print();
//b3 = btree; //赋值重载
//b3.Print();
BSTNode* p = btree.Find(5); //查找5并输出结果
if (p == nullptr) cout<<"找不到!!"<_data< main.cpp
#include "BSTree.h"
int main()
{
LY::TestBST();
system("pause");
return 0;
}