实现了BST(二叉搜索树)的一些基本操作,比如插入,删除,查找元素,查找前驱后继等。
binany_search_tree.h
#pragma once
/*************************************************
Author:董小歪
Date:2016-06-12
Description:算法导论第十二章-二叉搜索树-Cpp代码实现
**************************************************/
#ifndef BINANY_SEARCH_TREE
#define BINANY_SEARCH_TREE
#include <iostream>
#include <string>
using namespace std;
struct TreeNode
{
int val;
TreeNode *left, *right, *parent;
TreeNode(int _val) :val(_val), left(nullptr), right(nullptr), parent(nullptr){}
};
class MyBST
{
public:
MyBST():root(nullptr){} //构造函数
MyBST(TreeNode* _root):root(_root){}
void inorder_tree_walk(); //中序遍历BST
void tree_insert(int val); //插入元素
void tree_delete(int val); //删除元素
void transplant(TreeNode* u, TreeNode* v); //删除元素移植过程
TreeNode* get_root(); //返回树根
TreeNode* tree_search(int val); //查找元素
TreeNode* iterative_tree_search(int val); //非递归查找元素
TreeNode* tree_minimum(TreeNode* node); //获取最小关键字元素
TreeNode* tree_maximum(TreeNode* node); //获取最大关键字元素
TreeNode* tree_successor(TreeNode* node); //获取当期元素的后继
TreeNode* tree_predecessor(TreeNode* node); //获取当前元素的前驱
private:
void inorder_tree_walk(TreeNode* node); //中序遍历BST
TreeNode* tree_search(TreeNode* node, int val); //查找元素
TreeNode *root; //树根
};
TreeNode* MyBST::get_root()
{
return root;
}
void MyBST::inorder_tree_walk()
{
inorder_tree_walk(root);
}
void MyBST::inorder_tree_walk(TreeNode* node)
{
if (node)
{
inorder_tree_walk(node->left);
cout << node->val << " ";
inorder_tree_walk(node->right);
}
}
TreeNode* MyBST::tree_search(int val)
{
return tree_search(root, val);
}
TreeNode* MyBST::tree_search(TreeNode* node, int val)
{
if (!node || node->val == val)
return node;
if (val < node->val)
return tree_search(node->left, val);
else
return tree_search(node->right, val);
}
TreeNode* MyBST::iterative_tree_search(int val)
{
TreeNode* temp = root;
while (temp && temp->val != val)
{
if (temp->val < val)
temp = temp->right;
else
temp = temp->left;
}
return temp;
}
TreeNode* MyBST::tree_minimum(TreeNode* node)
{
TreeNode* temp = node;
while (temp && temp->left)
temp = temp->left;
return temp;
}
TreeNode* MyBST::tree_maximum(TreeNode* node)
{
TreeNode* temp = node;
while (temp && temp->right)
temp = temp->right;
return temp;
}
TreeNode* MyBST::tree_successor(TreeNode* node)
{
if (node->right)
return tree_minimum(node->right);
TreeNode *temp = node->parent;
while (temp && temp->right == node)
{
node = temp;
temp = temp->parent;
}
return temp;
}
TreeNode* MyBST::tree_predecessor(TreeNode* node)
{
if(node->left)
return tree_maximum(node->left);
TreeNode* temp = node->parent;
while (temp && temp->left == node)
{
node = temp;
temp = temp->parent;
}
return temp;
}
void MyBST::tree_insert(int val)
{
TreeNode* node = new TreeNode(val), *parent = nullptr;
TreeNode* r = root;
while (r)
{
parent = r;
if (r->val < val)
r = r->right;
else
r = r->left;
}
node->parent = parent;
if (parent == nullptr)
root = node;
else if (val < parent->val)
parent->left = node;
else
parent->right = node;
}
void MyBST::transplant(TreeNode* u, TreeNode* v)
{
if (u->parent == nullptr)
root = v;
else if (u == u->parent->left)
u->parent->left = v;
else
u->parent->right = v;
if (v)
v->parent = u->parent;
}
void MyBST::tree_delete(int val)
{
TreeNode* del = tree_search(val); //找到要删除的结点元素
if (del->left == nullptr) //如果左子树为空
transplant(del, del->right);
else if (del->right == nullptr) //右子树为空
transplant(del, del->left);
else
{
TreeNode* successor = tree_successor(del);//删除结点的后继
if (successor != del->right) //如果后继不是当前删除结点的右孩子
{
transplant(successor, successor->right);
successor->right = del->right;
successor->right->parent = successor;
}
transplant(del, successor);
successor->left = del->left;
successor->left->parent = successor;
}
}
#endif // !BINANY_SEARCH_TREE
测试代码:
#include "binany_search_tree.h"
int main()
{
cout << "创建二叉搜索树" << endl; MyBST mybst;
cout << "中序遍历二叉搜索树:"; mybst.inorder_tree_walk(); cout << endl;
cout << "插入元素12:"; mybst.tree_insert(12); mybst.inorder_tree_walk(); cout << endl;
cout << "插入元素5:"; mybst.tree_insert(5); mybst.inorder_tree_walk(); cout << endl;
cout << "插入元素2:"; mybst.tree_insert(2); mybst.inorder_tree_walk(); cout << endl;
cout << "插入元素9:"; mybst.tree_insert(9); mybst.inorder_tree_walk(); cout << endl;
cout << "插入元素18:"; mybst.tree_insert(18); mybst.inorder_tree_walk(); cout << endl;
cout << "插入元素15:"; mybst.tree_insert(15); mybst.inorder_tree_walk(); cout << endl;
cout << "插入元素13:"; mybst.tree_insert(13); mybst.inorder_tree_walk(); cout << endl;
cout << "插入元素17:"; mybst.tree_insert(17); mybst.inorder_tree_walk(); cout << endl;
cout << "插入元素19:"; mybst.tree_insert(19); mybst.inorder_tree_walk(); cout << endl;
cout << "查找元素15:";
TreeNode* find = mybst.tree_search(15);
if (find) cout << "元素找到:" << to_string(find->val) << endl;
else cout << "元素未找到" << endl;
cout << "查找元素14:";
find = mybst.tree_search(14);
if (find) cout << "元素找到:" << to_string(find->val) << endl;
else cout << "元素未找到" << endl;
cout << "最小元素为:" << mybst.tree_minimum(mybst.get_root())->val << endl;
cout << "最大元素为:" << mybst.tree_maximum(mybst.get_root())->val << endl;
cout << "元素12的后继为:" << mybst.tree_successor(mybst.get_root())->val << endl;
cout << "元素9的后继为:" << mybst.tree_successor(mybst.get_root()->left->right)->val << endl;
cout << "元素12的前驱为:" << mybst.tree_predecessor(mybst.get_root())->val << endl;
cout << "元素13的前驱为:" << mybst.tree_predecessor(mybst.get_root()->right->left->left)->val << endl;
cout << "删除元素19:"; mybst.tree_delete(19); mybst.inorder_tree_walk(); cout << endl; //没有孩子的情况
cout << "删除元素18:"; mybst.tree_delete(18); mybst.inorder_tree_walk(); cout << endl; //只有一个左孩子的情况
cout << "删除元素12:"; mybst.tree_delete(12); mybst.inorder_tree_walk(); cout << endl; //同时有左右孩子的情况
system("pause");
}
测试结果: