这里因为删除节点的函数写得不错,所以代码放上来保存一下,这个函数当然不是我写的。
//BTNode.h
#ifndef BTNODE_H
#define BTNODE_H
#include <cstdio>
typedef int datatype;
typedef struct BTNode{
datatype data;
BTNode* left;
BTNode* right;
BTNode* father;
datatype val;
BTNode(datatype dataPara,datatype valPara = NULL)
:data(dataPara),left(NULL),right(NULL), val(valPara), father(NULL){};
}*nodePtr;
#endif
//BST.h
#ifndef BST_H
#define BST_H
#include "BTNode.h"
#include <iostream>
using namespace std;
class BST //means Binary Search Tree
{
public:
BST() :rootPtr(new BTNode(0)){};
~BST();
void Insert(datatype data);
void Delete(datatype data);
void count(datatype data);
void find(datatype data);
void Clear(datatype data);
void InRerverse(const nodePtr &node);
void Rerverse();
private:
nodePtr rootPtr;
void InsertHelp(datatype data, nodePtr &node);
void DeleteHelp(datatype data, nodePtr &node);
nodePtr findMin(nodePtr node);
};
#endif
//BST.cpp
#include "BST.h"
BST::~BST()
{
}
void BST::Insert(datatype data)
{
InsertHelp(data, rootPtr->left);
}
void BST::InsertHelp(datatype data, nodePtr &node)
{
if (node != NULL)
{
if (data == node->data)
cout << "the val has exist in the tree!" << endl;
else if (data < node->data)
InsertHelp(data, node->left);
else
InsertHelp(data, node->right);
}
else
node = new BTNode(data);
}
void BST::InRerverse(const nodePtr &node)
{
if (node != NULL)
{
InRerverse(node->left);
cout << node->data << " ";
InRerverse(node->right);
}
}
void BST::Rerverse()
{
InRerverse(rootPtr->left);
}
void BST::Delete(datatype data)
{
DeleteHelp(data, rootPtr->left);
}
void BST::DeleteHelp(datatype data, nodePtr &node)
{
if (node != NULL)
{
if (node->data < data)
DeleteHelp(data, node->right);
else if (node->data > data)
DeleteHelp(data, node->left);
else if (node->left != NULL && node->right != NULL)
{
node->data = findMin(node->right)->data; //这里没有调用找后继节点的函数,因为找后继节点是分情况讨论的,而这里不需要分情况
DeleteHelp(data, node->right); //只需要找到沿路径的最小值就可以了
}
else
{
nodePtr temp = node;
node = (node->left == NULL) ? node->right : node->left;
delete temp;
}
}
}
nodePtr BST::findMin(nodePtr node)
{
while (node != NULL || node->left != NULL)
{
node = node->left;
}
return node;
}
//Main.cpp 其实就是测试代码
#include "BST.h"
int main()
{
BST A;
A.Insert(3);
A.Insert(4);
A.Insert(1);
A.Insert(2);
A.Insert(6);
A.Insert(5);
A.Insert(0);
A.Insert(7);
A.Insert(9);
A.Insert(8);
A.Insert(0);
A.Delete(0);
A.Delete(7);
A.Rerverse();
}
这里来一版可以查找前驱/后继节点的,这时候node的结构体里面必须包括父节点的信息~,insert/delete等函数也要调整父节点信息
void BST::Insert1(datatype data)
{
InsertHelp1(data, rootPtr->left, rootPtr);
}
void BST::InsertHelp1(datatype data, nodePtr &node, nodePtr &father)
{
if (node != NULL)
{
if (data == node->data)
cout << "the val has exist in the tree!" << endl;
else if (data < node->data)
InsertHelp1(data, node->left, node);
else
InsertHelp1(data, node->right, node);
}
else
{
node = new BTNode(data);
node->father = father;
}
}
void BST::Delete1(datatype data)
{
DeleteHelp1(data, rootPtr->left);
}
void BST::DeleteHelp1(datatype data, nodePtr &node)
{
if (node != NULL)
{
if (node->data < data)
DeleteHelp1(data, node->right);
else if (node->data > data)
DeleteHelp1(data, node->left);
else if (node->left != NULL && node->right != NULL)
{
node->data = findMin(node->right)->data; //这里没有调用找后继节点的函数,因为找后继节点是分情况讨论的,而这里不需要分情况
DeleteHelp1(data, node->right); //只需要找到沿路径的最小值就可以了
}
else
{
nodePtr temp = node;
node = (node->left == NULL) ? node->right : node->left;
if (node != NULL)node->father = temp->father; //判定node是否为空
delete temp;
}
}
}
nodePtr BST::findMin(nodePtr node)
{
while (node != NULL && node->left != NULL)
{
node = node->left;
}
return node;
}
</pre><pre class="cpp" name="code">然后是真正的找后继节点的函数,形参是一个nodePtr,返回也是一个nodePtr
</pre><pre class="cpp" name="code">nodePtr BST::findPost(nodePtr node)
{
if (node != NULL)
{
if (node->right != NULL)
{
return findMin(node->right);
}
else
{
while (node->father != rootPtr && node == node->father->right)
node = node->father;
return node->father;
}
}
else
return NULL;
//return NULL;
}
也可以做得高端一点,输入一个Data返回他的后继节点,只需要多写个找data对应的node的函数
nodePtr BST::findNode(datatype data)
{
return findNodeHelp(data, rootPtr->left);
}
nodePtr BST::findNodeHelp(datatype data, nodePtr node)
{
if (node != NULL)
{
if (data > node->data)
return findNodeHelp(data, node->right);
else if (data < node->data)
return findNodeHelp(data, node->left);
else
return node;
}
else
return NULL;
}
最后是测试函数:
#include "BST.h"
int main()
{
BST A;
A.Insert1(3);
A.Insert1(4);
A.Insert1(1);
A.Insert1(2);
A.Insert1(6);
A.Insert1(5);
A.Insert1(0);
A.Insert1(7);
A.Insert1(9);
A.Insert1(8);
A.Insert1(0);
A.Delete1(0);
A.Delete1(7);
cout << A.findPost(A.findNode(6))->data << endl;
A.Rerverse();
}
代码已经跑过啦,没问题~,二叉搜索树就这些了