二叉排序树

一、二叉排序树（Binary Sort Tree）又称二叉查找树（Binary Search Tree），亦称二叉搜索树。

二叉排序树或者是一棵空树，或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

（2）若右子树不空，则右子树上所有结点的值均大于或 等于它的根结点的值；

（3）左、右子树也分别为二叉排序树；

（4）没有键值相等的节点。

二、查找

步骤：若根结点的关键字值等于查找的关键字，成功。

否则，若小于根结点的关键字值，递归查左子树。

若大于根结点的关键字值，递归查右子树。

若子树为空，查找不成功。

三、插入

首先执行查找算法，找出被插结点的父亲结点。

判断被插结点是其父亲结点的左、右儿子。将被插结点作为叶子结点插入。

若二叉树为空。则首先单独生成根结点。

四、删除

在二叉排序树删去一个结点，分三种情况讨论：

1‘若*p结点为叶子结点，即PL(左子树)和PR(右子树)均为空树。由于删去叶子结点不破坏整棵树的结构，则可以直接删除此子结点。

2.若*p结点只有左子树PL或右子树PR，此时只要令PL或PR直接成为其双亲结点*f的左子树（当*p只有左子树）或右子树（当*p只有右子树）即可，作此修改也不破坏二叉排序树的特性。

3.若*p结点的左子树和右子树均不空。在删去*p之后，为保持其它元素之间的相对位置不变，可按中序遍历保持有序进行调整： 是令*p的直接前驱（或直接后继）替代*p，然后再从二叉排序树中删去它的直接前驱（或直接后继）－即让*f的左子树(如果有的话)成为*p左子树的最左下结点(如果有的话)，再让*f成为*p的左右结点的父结点。

#include<iostream>
using namespace std;

template <class T>
class BST;

template <class T>
class BSTNode
{
	friend class BST<T>;
private:
	T key;//数据
	BSTNode<T> *p;//双亲节点
	BSTNode<T> *l;//左孩子节点
	BSTNode<T> *r;//右孩子节点
};

template <class T>
class BST
{
public:
	BST()
	{
		_root=0;//初始化根节点为空
	}
	~BST();
	BSTNode<T>* GetRootNode()const;
	void DestroyBST(BSTNode<T> *);
	BSTNode<T>* Find(BSTNode<T> *,const T key);//寻找关键字key对应的节点，
	BSTNode<T>* FindMin(BSTNode<T> *);//查找最小关键字
	BSTNode<T>* FindMax(BSTNode<T> *);//查找最大关键字
	BSTNode<T>* FindPredecessor(BSTNode<T> *);//查找某个结点的前驱
	BSTNode<T>* FindSuccessor(BSTNode<T> *);//查找某个结点的后继
	void Insert(BSTNode<T> **,T key);//插入一个新的节点到二叉排序树中
	void create(T *array,int length);//创建一个二叉排序树
	bool DeleteNode(T key);//删除关键字为key 的节点。
	void print(BSTNode<T> *);//打印二叉排序树
private:
	BSTNode<T> *_root;//
};

template <class T>
BST<T>::~BST()
{
	DestroyBST(_root);
}

template <class T>
BSTNode<T>* BST<T>::GetRootNode()const
{
	return _root;
}

template <class T>
void BST<T>::DestroyBST(BSTNode<T> *root)
{//后序遍历销毁整个树
	if(!root)
		return;
	DestroyBST(root->l);
	DestroyBST(root->r);
	free(root);
}

template <class T>
BSTNode<T>* BST<T>::Find(BSTNode<T> *root,const T key)
{
	if(!root)
	{//空树
		return NULL;
	}
	if(root->key < key)
		return Find(root->r,key);//递归遍历右子树
	else if(root->key > key)
		return Find(root->l,key);//递归遍历左子树
	else 
		return root;
}

template <class T>
BSTNode<T>* BST<T>::FindMin(BSTNode<T> *root)//查找最小关键字，空树时返回NULL
{
	if(!root)
		return NULL;
	if(root->l == NULL)
		return root;
	else //一直往左孩子找，直到没有左孩子的结点 
		return FindMin(root->l);
}
template <class T>
BSTNode<T>* BST<T>::FindMax(BSTNode<T> *root)//查找最大关键字，空树时返回NULL
{
	if(!root)
		return NULL;
	if(root->r == NULL)
		return root;
	else //一直往右孩子找，直到没有右孩子的结点 
		return FindMin(root->r);
}

template <class T>
BSTNode<T>* BST<T>::FindPredecessor(BSTNode<T> *temp)//查找某个结点的前驱
{
	//空树  
	if(!temp)  
		return temp;  
	//有左子树、左子树中最大的那个  
	if(temp->l)  
		return FindMax(temp->l);  
	//无左子树,查找某个结点的右子树遍历完了  
	else{  
		if(temp->p == NULL)  
			return NULL;  
		//向上寻找前驱  
		while(temp){  
			if(temp->p->r == temp)  
				break;  
			temp=temp->p;  
		}  
		return temp->p;  
	} 
}
template <class T>
BSTNode<T>* BST<T>::FindSuccessor(BSTNode<T> *temp)//查找某个结点的后继
{
	//空树  
	if(!temp)  
		return temp;  
	//有右子树、左子树中最小的那个  
	if(temp->r)  
		return FindMin(temp->r);  
	//无右子树,查找某个结点的左子树遍历完了  
	else{  
		if(temp->p == NULL)  
			return NULL;  
		//向上寻找后继  
		while(temp){  
			if(temp->p->l == temp)  
				break;  
			temp=temp->p;  
		}  
		return temp->p;  
	} 
}


template <class T>
void BST<T>::Insert(BSTNode<T> **root,T key)
{
	//初始化插入节点
	BSTNode<T> *node = new BSTNode<T>;
	node->key=key;
	node->l=node->r=node->p=NULL;
	if(!(*root))
	{//树为空时，直接当做根节点
		*root = node;
		return;
	}
	if((*root)->l ==NULL && (*root)->key > key)
	{//插入当前节点的左孩子
		node->p=(*root);
		(*root)->l=node;
		return;
	}

	if((*root)->r ==NULL && (*root)->key < key)
	{//插入当前节点的右孩子
		node->p=(*root);
		(*root)->r=node;
		return;
	}

	if((*root)->key >key)
		Insert(&((*root)->l),key);
	else if((*root)->key <key)
		Insert(&((*root)->r),key);
	else
		return;
}

template <class T>
void BST<T>::create(T *array,int length)
{
	for(int i=0; i<length; i++)
	{//逐个节点插入二叉排序树中
		Insert(&_root,array[i]);
	}
}

template <class T>
bool BST<T>::DeleteNode(T key)
{
	BSTNode<T> *q,*qq;
	T temp;
	//查找要删除的节点
	q = Find(_root,key);
	if(!q)//没有找到关键字
		return false;
	if(q->l==NULL && q->r==NULL)
	{//1.删除的只有叶子节点
		if(q->p==NULL)
		{
			free(q);
			_root = NULL;
		}
		else
		{
			if(q->p->l==q)
				q->p->l=NULL;
			else
				q->p->r=NULL;
			free(q);
		}
	}
	else if(q->l&&!(q->r))
	{//2.删除节点只有左子树
		q->l->p=q->p;
		if(q->p==NULL)//删除的节点是根节点
			_root = q->l;
		else if(q->p->l == q)//删除的节点是父亲节点的左孩子
			q->p->l =q->l;
		else //删除的节点是父亲节点的右孩子
			q->p->r =q->l;
	}

	else if(q->r&&!(q->l))
	{//3.删除节点只有右子树
		q->r->p=q->p;
		if(q->p==NULL)//删除的节点是根节点
			_root = q->r;
		else if(q->p->l == q)//删除的节点是父亲节点的左孩子
			q->p->l =q->r;
		else //删除的节点是父亲节点的右孩子
			q->p->r =q->r;
	}
	else
	{//4.删除节点有左右子树
		//该结点的后继结点肯定无左子树(参考上面查找后继结点函数)  
		//删掉后继结点,后继结点的值代替该结点 
		//找到要删除结点的后继  
		qq=FindSuccessor(q);  
		temp=qq->key;  
		//删除后继结点  
		DeleteNode(qq->key);  
		q->key=temp;  
	}
	return true;
}

template <class T>
void BST<T>::print(BSTNode<T> *root)//打印二叉排序树
{
	if(!root)
	{
		return;
	}    

	print(root->l);
	cout<<root->key<<" ";
	print(root->r);
}


int main()
{
	BST<int> bst;
	int arrar[11] = {4,2,1,3,8,6,5,7,10,9,11};
	bst.create(arrar,11);
	bst.print( bst.GetRootNode());
	bst.DeleteNode(6);
	cout<<endl;
	bst.print( bst.GetRootNode());
	BSTNode<int> *temp = bst.GetRootNode();
	bst.Insert(&temp,6);
	cout<<endl;
	bst.print( bst.GetRootNode());

	bst.DeleteNode(8);
	cout<<endl;
	bst.print( bst.GetRootNode());
	return 0;
}