数据结构与算法_二叉查找树

BinarySearchTree.h

#pragma once
#include <iostream>
using namespace std;
template<class T> class BST;	//前置声明 
enum boolean
{
	FALSE,
	TRUE,
};


template<class T>
class Element
{
public:
	T key;	//这样做更容易添加更多新的数据，方便扩展 
};
template<class T>
class BstNode		//树的节点 
{
	friend class BST<T>;
public:
	Element<T>& getData()
	{
		return this->data;
	} 
private:
//public:
	Element<T> data;
	BstNode* leftChild;
	BstNode* rightChild;
	void Display(int i);
};

template<class T>
class BST
{
public:
	  BST(BstNode<T> *init = 0)
	  {
	  	 root = init; 
	  }	
	  boolean Insert(const Element<T> &data);
	  BstNode<T>* Search(const Element<T> &data);
	  BstNode<T>* Search(BstNode<T>*, const Element<T>&);	//递归查找 
	  BstNode<T>* IterSearch(const Element<T>&);	//迭代查找 
	  boolean DeleteNode(const Element<T> &data);
	  void InOrder();		//中序遍历
	  void InOrder(BstNode<T> *CurNode);
	  
	  void Visit(BstNode<T> *CurNode);	//显示当前节点的数据 
	  void display()
	  {
	  	if(root)
	  		root->Display(1);
	  	else
	  		cout << "这是空树" << endl;
	  }
private: 
	BstNode<T> *root;
} ;
/***************BstNode成员函数实现****************/ 
template<class T>
void BstNode<T>::Display(int i)
{
	cout << "Position: " << i << ", data.key = " << data.key << endl;
	if(leftChild)	//显示左子树 
		leftChild->Display(2*i);
	if(rightChild)	//显示右子树 
		rightChild->Display(2*i+1);
} 
/***************BST成员函数实现****************/ 
template<class T>
boolean BST<T>::Insert(const Element<T> &data)
{
	BstNode<T> *p = root;	//开始时p是指向root的，之后p是不停移动的 
	BstNode<T> *q = 0;		//q是指向p的父节点
	
	while(p)
	{
		q = p;	//q指向p的父节点
		if(data.key == p->data.key) 	return FALSE;	//发生了重复，返回失败
		if(data.key < p->data.key) 		
			p = p->leftChild;
		else if(data.key > p->data.key) 		
			p = p->rightChild;
	} 
	//循环结束时，就找到了一个空缺的位置q
	//重新利用指针p new 一个节点
	p = new BstNode<T>;
	p->data = data;
	p->leftChild = p->rightChild = 0;
	if(!root)	root = p;	//如果是空树 
	else if(data.key < q->data.key) 	q->leftChild = p;
	else q->rightChild = p;
	return TRUE; 	
}
template<class T>
BstNode<T>* BST<T>::Search(const Element<T> &node)
{
	return Search(root, node);
}

template<class T>
//从data节点开始找node 
BstNode<T>* BST<T>::Search(BstNode<T>* data, const Element<T>& node)	//递归查找 
{
	if(!data)	return 0;
	if(data->data.key == node.key) return data;
	if(node.key < data->data.key)
		return Search(data->leftChild, node);
	else
		return Search(data->rightChild, node);
}

template<class T>
BstNode<T>* BST<T>::IterSearch(const Element<T>& node)	//迭代查找 
{
	BstNode<T>* tmp = root;
	while(tmp)
	{
		if(node.key == tmp->data.key)
			return tmp;
		if(node.key < tmp->data.key)
			tmp = tmp->leftChild;
		else
			tmp = tmp->rightChild;
	}
	return 0;
}
template<class T>
boolean BST<T>::DeleteNode(const Element<T> &data)
{
	BstNode<T> *node = root;	//待删除的节点
	BstNode<T> *PreNode = NULL;	//待删除结点的父节点
	while(node)
	{
		if(node->data.key == data.key)	//找到节点 
		{
			//(1) 要删除的节点是叶子节点
			if(node->leftChild == NULL && node->rightChild == NULL)
			{
				//如果是根节点
				if(PreNode == NULL)
					root = NULL;
				else		//判断要删除的节点node是左叶子节点 还是右叶子节点 
					(node == PreNode->leftChild) ? PreNode->leftChild = NULL:PreNode->rightChild=NULL; 
				//开始删除
				delete node;
				node = NULL; 
				return TRUE;
			} 
			//(2) 要删除的节点node只有左/右子树 
			if(node->leftChild == NULL || node->rightChild == NULL)
			{
				//如果是根节点
				if(PreNode == NULL)
					(node->leftChild == NULL) ? root = node->rightChild : node->leftChild;
				else
				{
					if(PreNode->leftChild == node)
						(node->leftChild == NULL) ? PreNode->leftChild = node->rightChild : PreNode->leftChild = node->leftChild;
					else
						(node->leftChild == NULL) ? PreNode->rightChild = node->rightChild : PreNode->rightChild = node->leftChild; 
				} 
				//删除节点
				delete node;
				node = NULL; 
				return TRUE;
			}
			//(3)要删除的节点即有左子树又有右子树
			 else
			 {
			 	 //寻找左子树的最右节点作为替换节点
			 	 BstNode<T> *ReplaceNode = node->leftChild;
				 while(ReplaceNode->rightChild)
				 {
				 	ReplaceNode = ReplaceNode->rightChild;
				 } 
				 //保存替换节点的值
				Element<T> TempData = ReplaceNode->data; 
				//删除ReplaceNode节点
			 	DeleteNode(TempData);
			 	ReplaceNode = NULL;
			 	//替换值域
				 node->data = TempData; 
				 return TRUE;
			 } 
			
		}
		else
		{
			PreNode = node;
			if(data.key < node->data.key)
			{
				node = node->leftChild; 
			}
			else
			{
				node = node->rightChild;
			}
		} 
	} 
	return FALSE;
}
template<class T>
void BST<T>::InOrder()	//中序遍历
{
	InOrder(root);
}
template<class T>
void BST<T>::InOrder(BstNode<T> *CurNode)
{
	if(CurNode)
	{
		InOrder(CurNode->leftChild);
		Visit(CurNode);
		InOrder(CurNode->rightChild);
	}
}
template<class T>
void BST<T>::Visit(BstNode<T> *CurNode)	//显示当前节点的数据 
{
	cout << CurNode->data.key << " ";
}

main.h

#include <iostream>
#include "BinarySearchTree.h"
using namespace std;


int main() 
{
	BST<int> tree;
	Element<int> a,b,c,d,e,f,g,h,i,j,k,l;
	a.key = 5;
	b.key = 3;
	c.key = 11;
	d.key = 3;
	e.key = 15;
	f.key = 2;
	g.key = 8;
	h.key = 22;
	i.key = 20;
	j.key = 9;
	cout << tree.Insert(a) << endl;		//a=5 就是root 
	cout << tree.Insert(b) << endl;		//3
	cout << tree.Insert(c) << endl;		//11
	cout << tree.Insert(d) << endl;		//插入失败 
	cout << tree.Insert(e) << endl;		//15 
	cout << tree.Insert(f) << endl;		//2
	cout << tree.Insert(g) << endl;		//8
	cout << tree.Insert(h) << endl;		//22
	
	tree.display();	
	
	BstNode<int> * ret = tree.Search(f);
	cout << "找到的数是：" << ret->data.key << endl;
	
	ret = tree.IterSearch(h);
	cout << "找到的数是：" << ret->data.key << endl;
	//cout << "hello" << endl; 
	tree.InOrder();
	cout << endl;
	cout << tree.DeleteNode(g) << endl;;
	
	tree.display();	
	return 0;
}