主要实现了二叉查找树的插入、删除等操作
树节点头文件tree_node.h
template<class T>
struct tree_node {
tree_node() {
left = NULL;
right = NULL;
}
tree_node(T ndata) {
data = ndata;
left = NULL;
right = NULL;
}
T data;
tree_node<T> *left;
tree_node<T> *right;
};
二叉查找树类文件
#include <iostream>
#include "tree_node.h"
#include <cassert>
using namespace std;
template<class T>
class binary_search_tree {
public:
binary_search_tree() {
used = 0;
root = NULL;
}
~binary_search_tree() {
clear();
}
int size() { return used; }
void clear() {
clearT(root);
used = 0;
}
void in_print() { in_printT(root); }
tree_node<T>* copy() { copyT(root); }
void insert(const T& entry) {
insertT(root, entry);
used++;
}
bool erase(const T &target) {
bool flag = deleteT(root, target);
if(flag) used--;
return flag;
}
private:
tree_node<T> *root;
int used;
//由底向上删除
void clearT(tree_node<T>*& proot) {
if(proot != NULL) {
clearT(proot->left);
clearT(proot->right);
delete proot;
proot = NULL;
}
}
//中序遍历
void in_printT(tree_node<T>* proot) {
if(proot != NULL) {
in_printT(proot->left);
cout << proot->data << endl;
in_printT(proot->right);
}
}
//由底向上拷贝
tree_node<T>* copyT(const tree_node<T> *proot) {
if(proot == NULL)
return NULL;
else {
tree_node<T> *lchild, *rchild;
lchild = copyT(proot->left);
rchild = copyT(proot->right);
return new tree_node<T>(proot->data, lchild, rchild);
}
}
//插入一个新项
void insertT(tree_node<T> *&proot, const T &entry) {
tree_node<T> *p = new tree_node<T>(entry);
if(proot == NULL) proot = p ;
else {
if(entry <= proot->data && proot->left == NULL) {
proot->left = p;
return;
}
if(entry > proot->data && proot->right == NULL) {
proot->right = p;
return;
}
if(entry <= proot->data && proot->left !=NULL)
insertT(proot->left, entry);
if(entry > proot->data && proot->right != NULL)
insertT(proot->right, entry);
}
}
// 删除树中的最大项节点,将要删除的节点值设置为最大项的值
void remove_max(tree_node<T>*& rt, T &removed) {
tree_node<T> *old;
//右子树为空
if(rt->right == NULL) {
removed = rt->data;
old = rt;
rt = rt->left;
delete old;
}
//右子树非空
else
remove_max(rt->right, removed);
}
//删除树中特定值
bool deleteT(tree_node<T> *&proot, const T &target) {
if(proot == NULL)
return false;
else {
if(target < proot->data)
deleteT(proot->left, target);
else if(target > proot->data)
deleteT(proot->right, target);
//删除节点时分两种情况,有左孩子和无左孩子
else {
tree_node<T> *old;
if(proot->left == NULL) { //无左孩子,右孩子成为父节点,包括了叶子节点情况
old = proot;
proot = proot->right;
delete old;
}
//有左孩子,则需要删除左子树中最大的值
else
remove_max(proot->left, proot->data);
return true;
}
}
}
};