数据结构学习——带父节点的二叉搜索树全部功能c++实现

第二篇二叉树我们带来纯c++版本的二叉搜索树，这篇代码是我学习了很多优秀代码之后写出来的，大家在学习二叉搜索树的同时可以着重看下在这里如何定义的二叉搜索树，以及Private和Public的封装联动，对代码思路是一个很好的提升。

注：在这里的遍历我只写了前序遍历，其他的遍历方式大家可以看我的前一篇博客，一共写到了两个大方法共计5种小方法的遍历~~

猛男话不多，代码走起

#include<iostream>

using namespace std;

typedef int data_type;

class BinaryNode{
	
	private:
		BinaryNode *rchild;
		BinaryNode *lchild;
		BinaryNode *parent;
		data_type key;
		friend class BinarySTree;
			
		public:
		BinaryNode(BinaryNode *r = NULL,BinaryNode *l = NULL,BinaryNode *p = NULL,data_type a = 0):rchild(r),lchild(l),parent(p),key(a){}		
};

class BinarySTree{
	
	private:
		BinaryNode *root;
		
		//变换节点 用change替换old 
		void change(BinaryNode *&tmp,BinaryNode *old,BinaryNode *change) 
		{
			if(!old->parent)
			{
				tmp = change;
			}
			else if(old = old->parent->rchild)
				old->parent->rchild = change;
			else
				old->parent->lchild = change;
			if(change)
				change->parent = old->parent;
		}
		
		//先序遍历BST 
		void search(BinaryNode *p)
		{
			if(p)
			{
				cout<<p->key<<" ";
				search(p->lchild);
				search(p->rchild);
			}
		}
		
		
		//找子树最大值 
		BinaryNode *Max(BinaryNode *p)
		{
			while(p->rchild)
			{
				p = p->rchild;
			}
			return p;
		}
		
		//找子树最小值
		BinaryNode *Min(BinaryNode *p)
		{
			while(p->lchild)
			{
				p = p->lchild;	
			}	
			return p;
		}
		 
		//找已知节点的前驱结点 
		BinaryNode *ForwardNode(BinaryNode *p)
		{
			BinaryNode *old;
			if(p->lchild)
			{
				return Max(p->lchild);
			}
			else
			{
				old = p->parent;
				while(old && old->rchild!=p)
				{
					p = old;
					old = old->parent;
				}
			}
			return old;
		}
		
		//找已知的后继节点 
		BinaryNode *BackwardNode(BinaryNode *p)
		{
			BinaryNode *old;
			if(p->rchild)
			{
				return Min(p->rchild);
			}
			else
			{
				old = p->parent;
				while(old && old->lchild!=p)
				{
					p = old;
					old = old->parent;
				}
			}
			return old;
		}
		
		//插入新的节点 
		void TInsert(BinaryNode *&tmp, BinaryNode *z)
		{
			BinaryNode *p = tmp;
			BinaryNode *temp = NULL;
			
			while(p)
			{
				temp = p;
				if(z->key < p->key)
					p = p->lchild;
				else
					p = p->rchild;
			}
			
			z->parent = temp;
			
			if(!temp)
				tmp = z;
			
			else if(z->key < temp->key)
				temp->lchild = z;
			
			else
				temp->rchild = z;	
		}
		
		//添加固定key值的节点 
		
		void add(BinaryNode *&tmp, data_type key)
		{
			
			BinaryNode *temp = tmp;
			BinaryNode *z = NULL;
			BinaryNode *a = new BinaryNode(NULL,NULL,NULL,key);
			
			while(temp)
			{
				z = temp;
				
				if(key > temp->key)
				{
					temp = temp->rchild;		
				}
				else if(key < temp->key)
				{
					temp = temp->lchild;
				}
			}
			
			if(a->key > z->key)
				{
					z->rchild = a;
					a->parent = z;
				}
			else if(a->key < z->key)
				{
					z->lchild = a;
					a->parent = z;
				}

			
			cout<<"插入结束新的BST为: ";
			search(tmp);
		}
		
		//删除固定key的节点 
		
		void deleteNode(BinaryNode *&tmp,data_type key)
		{
			BinaryNode *p = tmp;
			BinaryNode *p1 = NULL;
		
			
			while(p&&p->key!=key)
			{
				if(key > p->key)
				{
					p = p->rchild;
				}
				else if(key < p->key)
				{
					p = p->lchild;
				}
			}
						
			//如果被删除节点的 度 == 0
			
			 if(!p->lchild&&!p->rchild)
			{
				if(p == p->parent->rchild)
					p->parent->rchild = NULL;
				else if(p == p->parent->lchild)
					p->parent->lchild = NULL;
			} 
			
			
			//如果被删除节点的 度 == 1 
			
			else if(!p->lchild||!p->rchild)
			{
				if(p->lchild)
				{
					if(p == p->parent->lchild)
					
						p->parent->lchild = p->lchild;
					
					else if(p == p->parent->rchild)
					
						p->parent->rchild = p->lchild; 
				}
				else if(p->rchild)
				{
					if(p == p->parent->lchild)
					
						p->parent->lchild = p->rchild;
					
					else if(p == p->parent->rchild)
					
						p->parent->rchild = p->rchild; 
				}
			}

			
			//如果被删除节点的 度 == 2 
			
			else 
			{
				BinaryNode *a = Min(p->rchild);
				
				if(p->rchild == a)
				{
					change(root,p,p->rchild);
					p->rchild->lchild = p->lchild;
					p->rchild->lchild->parent = p->rchild;
				}
				else
				{
					change(root,a,a->rchild);
					a->rchild->lchild = p->rchild;
					a->rchild->lchild->parent = a->rchild;
					
					change(root,p,a);
					a->lchild = p->lchild;
					p->lchild->parent = a;
				}
			}
		
		}
		
	
		
	public:
		
		BinarySTree():root(NULL){}
		
                //下面是main函数访问到的公用接口的定义

		void Search()
		{
			search(root);
			cout<<endl;
		}
		
		void Insert(data_type key)
		{
			BinaryNode *p = new BinaryNode(NULL,NULL,NULL,key);
			TInsert(root,p); 
		}
		
		void *Forward(BinaryNode *p)
		{
			ForwardNode(p);
		}
		
		void *Backward(BinaryNode *p)
		{
			BackwardNode(p);
		}
		
		BinaryNode *findMax(BinaryNode *p)
		{
			return Max(p);
		}
		
		BinaryNode *findMin(BinaryNode *p)
		{
			return Min(p);
		}
		
		void Add(data_type key)
		{
			add(root,key);
		}
		
		void DeleteNode(data_type key)
		{
			deleteNode(root,key);
			search(root);	
		} 
};

int main()
{
	int count = 0;
	cout<<"Input the number of Node: ";
	cin>>count;
	
	int a[count] = {0};
	BinarySTree s1;
	cout<<"Input the Node one by one: ";
	
	for(int i = 0;i < count;i++)
	{
		cin>>a[i];
		s1.Insert(a[i]);
	}
	
	cout<<endl<<"Finish the input"<<endl;
	
	cout<<"该二叉搜索树的前序遍历为：";
	s1.Search();
	
	int temp = 0;
	cout<<endl<<"请输入需要添加的节点key值: ";
	cin>>temp;
	s1.Add(temp);
	
	int del = 0;
	cout<<endl<<"请输入需要删除的节点key值：";
	while(cin>>del)
	{
		s1.DeleteNode(del);
		cout<<endl<<"请输入需要删除的节点key值：";
	} 
	system("pause");
}