二叉树的模板类

同样的问题，当时忘了卫星数据的模板了

//二叉树的模板类
#include <iostream>

using namespace std;

template <class Type>
struct node{
	Type value;
	node<Type> *left;
	node<Type> *right;
	node<Type> *parent;
}; 

template <class Type>
class tree_class{
	private:
		node<Type> *root;//树的类不定义额外的键值与内容空间了
		int size;
	public:
		tree_class();
		void NodeCpy(node<Type>* &,node<Type>* &);//两个函数用于递归，完成拷贝构造与析构 这个Cpy的需要用指针的引用，在函数里改变指针值 
		void NodeDel(node<Type> *);
		tree_class(tree_class<Type> &);
		~tree_class();
		bool Insert(const Type &);//插入value 
		void Show(node<Type> *);
		void ShowAll() ;//中序输出 
		node<Type> * SearchNode(node<Type> *,const Type &);
		node<Type> * Search(const Type &);//搜寻value，返回这个value的节点的指针 不存在返回NULL 
		node<Type> * Max();//最大value的节点 
		node<Type> * MinNode(node<Type> *); //从某节点找最小value的节点,没有左子树就是这个节点，有左子树就是一路向左子树搜索 
		node<Type> * Min();
		node<Type> * Replace(node<Type> * des,node<Type> * src);//src代替des的位置（鸠占鹊巢），包括des的父母节点，左右孩子节点全指向src,返回这个空出来的des ，
		//上面这个不太对，src把des占了但是src自己下面的子树全丢了，，不能把des的左右孩子节点改过来 ,只把des的父母节点改了，src再指向父母节点，相当于把src跟src的子树替换掉des 
		bool Delete(const Type&);
		
};

template <class Type>
tree_class<Type>::tree_class(){
	root = NULL;
	size = 0;
	return ;
}

template <class Type>//这里用的是指针的引用，然后就直接把des的指针改变，并且有个parent属性存在，所以至少要在函数里对下一层进行判断了。我觉得也可以用返回指针的方式，就需要在调用的时候先判断到节点了吗 
void tree_class<Type>::NodeCpy(node<Type>  * &des,node<Type> * &src){
	node<Type> *tmp;
	if(src->left!=NULL){
	//	cout<<"src,left"<<endl;
		tmp = new node<Type>;
		tmp->value = src->left->value;//这里可以再用一个临时指针，指向src的下一层 
		tmp->left = NULL;
		tmp->right = NULL;
		tmp->parent = des;
		des->left = tmp;//在des上加入了左孩子节点 
		size++;
		NodeCpy(des->left,src->left);
	}else{
		des->left =NULL;
	}
	
	if(src->right!=NULL){
	//	cout<<"src,right"<<endl;
		tmp = new node<Type>;
		tmp->value = src->right->value;
		tmp->left = NULL;
		tmp->right = NULL;
		tmp->parent = des;
		des->right = tmp;//在des上加入了右孩子节点
		size++;
		NodeCpy(des->right,src->right);
	}else{
		des->right = NULL;
	} 

	return;	
}

template <class Type>
tree_class<Type>::tree_class(tree_class<Type> & arg){
	if(arg.root==NULL){
		//cout<<"arg==NULL"<<endl;
		return;
	} 
	root = new node<Type>;
	root->value = arg.root->value;
	size = 1;
	NodeCpy(root,arg.root);
}

template <class Type>
void tree_class<Type>::NodeDel(node<Type> * arg){
	if(arg==NULL) return;
	else{
		NodeDel(arg->left);
		NodeDel(arg->right); 
		delete arg;
	}
	return ;
}
template <class Type>
tree_class<Type>::~tree_class()
{
	size = 0;
	NodeDel(root->left);
	NodeDel(root->right);
	delete root;
	return; 
	
} 

template <class Type>
bool tree_class<Type>::Insert(const Type & value){
	node<Type> *tmp;//用来遍历向下的指针 ，直到NULL 
	node<Type> *tmp_p;//用到指到当前节点的指针 
	tmp = root;
	tmp_p = NULL;
	while(tmp!=NULL){
		tmp_p = tmp;
		if(value>tmp->value) tmp = tmp->right;
		else if(value<tmp->value) tmp = tmp->left;
		else if(value==tmp->value) return false;
	} //一直搜索到了二叉树的最下层节点，最后tmp指到了这个NULL位置，tmp_p是这个NULL位置的父节点 
	tmp = new node<Type>;
	tmp->value = value;
	tmp->left = NULL;
	tmp->right = NULL;
	tmp->parent = tmp_p;
	if(tmp_p==NULL){
		root = tmp;
		return true;
	}//无元素
	else if(tmp_p->value>value){
		tmp_p->left = tmp;
		return true;
	} 
	else if(tmp_p->value<value){
		tmp_p->right = tmp;
		return true;
	}
	else{
		cout<<"logic failed"<<endl;
		return false;
	}
	
}

template <class Type>
void tree_class<Type>::Show(node<Type> * arg){
	if(arg!=NULL){
		Show(arg->left);
		cout<<"value="<<arg->value<<endl;
		Show(arg->right);
	}
	else return;
}

template <class Type>
void tree_class<Type>::ShowAll() {
	node<Type> *tmp;
	tmp = root;
	Show(tmp);
	return;
}

template <class Type>
node<Type> * tree_class<Type>::SearchNode(node<Type> * p,const Type & value){
	if(p==NULL||p->value==value) return p;
	if(p->value>value) return SearchNode(p->left,value);
	if(p->value<value) return SearchNode(p->right,value);
	
}

template <class Type>
node<Type> * tree_class<Type>::Search(const Type & value){
	//return SearchNode(root,value);
	node<Type> *tmp=root;
	while(tmp!=NULL){
		if(tmp->value==value) return tmp;
		else if(tmp->value>value) tmp = tmp->left;
		else tmp = tmp->right;
	}
	return tmp;
}

template <class Type>
node<Type> * tree_class<Type>::Max(){
	node<Type> *tmp=root;
	if(tmp==NULL) return tmp;
	while(tmp->right!=NULL){
		tmp = tmp->right;
	}
	return tmp;
}

template <class Type>
node<Type> * tree_class<Type>::MinNode(node<Type> * arg){
	node<Type> *tmp = arg;
	if(tmp==NULL) return tmp;
	while(tmp->left!=NULL){
		tmp = tmp->left;
	}
	return tmp;
}

template <class Type>
node<Type> * tree_class<Type>::Min(){
	return MinNode(root);
}

template <class Type>
node<Type> * tree_class<Type>::Replace(node<Type> * des,node<Type> * src){
	if(des->parent==NULL) root = src;
//	src->left = des->left;
//	src->right = des->right;
	
	else if(des->parent->left==des){
		des->parent->left = src;
	}else if(des->parent->right==des){
		des->parent->right = src;
	}
	if(src!=NULL)  src->parent = des->parent;
	return des; 
/*	if(des->left!=NULL){
		des->left->parent = src;
	}
	if(des->right!=NULL){
		des->right->parent = src;
	}*/
}

template <class Type>
bool tree_class<Type>::Delete(const Type & value){
	node<Type> *tmp;
	tmp = Search(value);
	if(tmp==NULL) return false;
	if(tmp->left==NULL){
		tmp=Replace(tmp,tmp->right);
		delete tmp;
		return true;
	} 
	else if(tmp->right==NULL){
		tmp=Replace(tmp,tmp->left);
		delete tmp;
		return true;
	}
	else{
		node<Type> *right_min;
		right_min = MinNode(tmp->right);
		cout<<"right_min="<<right_min->value<<endl;
		//这个子树不是tmp的右节点的话，这个节点肯定是最左的节点，要把这个节点摘出来，把它右子树补到这个节点 
		if(right_min->parent!=tmp){
			right_min = Replace(right_min,right_min->right);
			right_min->right = tmp->right;//再把这个摘出来的节点右边接到tmp的右子树 
			tmp->right->parent = right_min; 
		}
		//然后再拼接摘出来的这个节点左边子树 
		tmp = Replace(tmp,right_min);
		right_min->left = tmp->left;
		tmp->left->parent = right_min;
		delete tmp;
	}
	
} 

int main(){
	tree_class<int> test;
	test.Insert(1);
	test.Insert(4);
	test.Insert(19);
	test.Insert(7);
	test.Insert(86); 

	test.Insert(59);
	
	test.Insert(61);
	test.ShowAll();
	//tree_class<int> test2 = test;
//	test2.ShowAll();
	node<int> *p = test.Search(19);
	if(p==NULL) cout<<"search NULL"<<endl;
	else cout<<"search value="<<p->value<<endl;
	p = test.Max();
	cout<<"max value="<<p->value<<endl;
	p = test.Min();
	cout<<"min value="<<p->value<<endl;
	test.Delete(19);
	test.ShowAll();
	return 0;
}