二叉搜索树BinarySearchTree的实现

这里因为删除节点的函数写得不错，所以代码放上来保存一下，这个函数当然不是我写的。

//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();
}

代码已经跑过啦，没问题~,二叉搜索树就这些了