版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/majinlei121/article/details/84145969
前两篇介绍了二分搜索树以及二分搜索树的遍历,下面介绍二分搜索树删除最大值和最小值节点
(1)根据二叉树的定义,只要从根节点的左节点一直寻找,直到某一个左节点不再有左节点,那么该节点就是最小值
(2)只要从根节点的右节点一直寻找,直到某一个右节点不再有右节点,那么该节点就是最大值
删除二分搜索树的最小值
(1)如果删除的节点没有右子节点,那么直接删除掉就可以,如下图的最小节点13
(2)如果删除的节点有右节点,那么将该节点删除后,用其右节点替换其位置,如删除最小节点22,22有右节点,删除22后,就把其右节点33替换其位置
删除二分搜索树的最大值
(1)如果删除的节点没有左子节点,那么直接删除掉就可以,如下图的最大节点63
(2)如果删除的节点有左节点,那么将该节点删除后,用其左节点替换其位置,如删除最大节点58,58有左节点,删除58后,就把其左节点50替换其位置
下面是程序实现
#include <iostream>
#include <vector>
#include <string>
#include <ctime> //time()函数
#include <queue>
#include <cassert>
#include "FileOps.h"
using namespace std;
template<typename Key, typename Value>
class BST{
private:
struct Node{
Key key;
Value value;
Node *left;
Node *right;
Node(Key key, Value value){
this->key = key;
this->value = value;
this->left = this->right = NULL;
}
};
Node *root;
int count;
public:
BST(){
root = NULL;
count = 0;
}
~BST(){
// TODO: ~BST()
destroy(root);
}
int size(){
return count;
}
bool isEmpty(){
return count == 0;
}
void insert(Key key, Value value){
root = insert(root, key, value);
}
bool contain(Key key){
return contain(root, key);
}
Value *search(Key key){
return search(root, key);
}
//前序遍历
void preOrder(){
preOrder(root);
}
//中序遍历
void inOrder(){
inOrder(root);
}
//后序遍历
void postOrder(){
postOrder(root);
}
//层序遍历
void levelOrder(){
quene<Node*> q;
q.push(root);
while( !q.empty() ){
Node *node = q.front();
q.pop();
cout<<node->key<<endl;
if (node->left)
q.push(node->left);
if (node->right)
q.push(node->right);
}
}
//寻找最小的键值
Key minimum(){
assert(count != 0);
Node* minNode = minimum(root);
return minNode->key;
}
//寻找最大的键值
Key maximum(){
assert(count != 0);
Node* maxNode = maximum(root);
return maxNode->key;
}
//从二叉树中删除最小值所在节点
void removeMin(){
if (root)
root = removeMin(root);
}
//从二叉树中删除最大值所在节点
void removeMax(){
if (root)
root = removeMax(root);
}
private:
//向以node为根的二叉搜索树中,插入节点(key, value)
//返回插入新节点后的二叉搜索树的根
//递归插入
Node* insert(Node *node, Key key, Value value){
if (node == NULL){
count++;
return new Node(key, value);
}
if(node->key == key)
node->value = value;
else if (key < node->key)
node->left = insert(node->left, key, value);
else
node->right = insert(node->right, key, value);
return node;
}
//查找以node为根的二叉搜索树中是否包含键值为key的节点
bool contain(Node *node, Key key){
if (node == NULL){
return false;
}
if (key == node->key)
return true;
else if (key < node->key)
return contain(node->left, key);
else
return contain(node->right, key);
}
//在以node为根的二叉搜索树中查找key对应的value
Value* search(Node *node, Key key){
if (node == NULL)
return NULL;
if (key == node->key)
return &(node->value);
else if (key < node->key)
return search(node->left, key);
else
return search(node->right, key);
}
//对以node为根的二叉搜索树进行前序遍历
void preOrder(Node* node){
if (node != NULL){
cout<<node->key<<endl;
preOrder(node->left);
preOrder(node->right);
}
}
//对以node为根的二叉搜索树进行中序遍历
void inOrder(Node *node){
if (node != NULL){
inOrder(node->left);
cout<<node->key<<endl;
inOrder(node->right);
}
}
//对以node为根的二叉搜索树进行后序遍历
void postOrder(Node *node){
if(node != NULL){
postOrder(node->left);
postOrder(node->right);
cout<<node->key<<endl;
}
}
void destroy(Node *node){
if (node != NULL){
destroy(node->left);
destroy(node->right);
delete node;
count--;
}
}
//在以node为根的二叉搜索树中,返回最小键值的节点
Node* minimum(Node *node){
if (node->left == NULL)
return node;
return minimum(node->left);
}
//在以node为根的二叉搜索树中,返回最大键值的节点
Node* maximum(Node *node){
if (node->right == NULL)
return node;
return maximum(node->right);
}
//删除掉以node为根的二分搜索树中的最小节点
//返回删除节点后新的二分搜索树的根
Node* removeMin(Node* node){
if (node->left == NULL){
Node *rightNode = node->right;
delete node;
count--;
return rightNode;
}
node->left = removeMin(node->left);
return node;
}
//删除掉以node为根的二分搜索树中的最大节点
//返回删除节点后新的二分搜索树的根
Node* removeMax(Node* node){
if (node->right == NULL){
Node *leftNode = node->left;
delete node;
count--;
return leftNode;
}
node->right = removeMin(node->right);
return node;
}
};