c++ 数据结构 *** 树的部分实现

代码如下:

#pragma once
#ifndef HEAD_H
#define HEAD_H

#include<iostream>
#include<stack>
#include<queue>
using namespace std;

template<class Type>
class tree;

template<class Type>
class treeNode {
	friend tree<Type>;
private:
	Type data;
	treeNode<Type>* left;
	treeNode<Type>* right;
public:
	treeNode();
	treeNode(const Type &val, treeNode<Type>* left = NULL, treeNode<Type>* right = NULL);
};
template<class Type>
treeNode<Type>::treeNode() {
	left = right = NULL;
}

template<class Type>
treeNode<Type>::treeNode(const Type &val, treeNode<Type>* left, treeNode<Type>* right) {
	date = val;
	this->left = left;
	this->right = right;
}
template<class Type>
class tree {
private:
	treeNode<Type>* root;
	treeNode<Type>* CopyHelp(treeNode<Type>* r);
	void DestroyHelp(treeNode<Type>*&r);
	void preHelp(treeNode<Type>* r, void(*visit)(Type &));
	void inHelp(treeNode<Type>* r, void(*visit)(Type &));
	void postHelp(treeNode<Type>* r, void(*visit)(Type &));
	int heightHelp(const treeNode<Type>* r)const;
	int nodecntHelp(const treeNode<Type>* r)const;
	treeNode<Type>* parentsHelp(treeNode<Type>* r, const treeNode<Type>* cur)const;
public:
	tree();
	tree(treeNode<Type>* root);
	tree(const Type &e);
	tree(const tree& copy);
	~tree();
	tree<Type>& operator=(const tree<Type>& copy);
	treeNode<Type>* getRoot()const;
	bool Empty()const;
	bool getelem(treeNode<Type>* cur, Type e);
	bool setelem(treeNode<Type>* cur, Type e);
	void inOrder(void(*visit)(Type &));
	void preOrder(void(*visit)(Type &));
	void postOrder(void(*visit)(Type &));
	void levelOrder(void(*visit)(Type &));
	int nodeCnt()const;
	treeNode<Type>* leftChild(const treeNode<Type>* cur)const;
	treeNode<Type>* rightChild(const treeNode<Type>* cur)const;
	treeNode<Type>* parents(const treeNode<Type>* cur)const;
	void insertleft(const treeNode<Type>* cur, const Type& e);
	void insertright(const treeNode<Type>* cur, const Type& e);
	void deleteleft(const treeNode<Type>* cur);
	void deleteright(const treeNode<Type>* cur);
	int height();
};
template<class Type>
treeNode<Type>* tree<Type>::CopyHelp(treeNode<Type>* r) {
	if (r == NULL)return NULL;
	else {
		treeNode<Type>* l = CopyHelp(r->left);
		treeNode<Type>* r = CopyHelp(r->right);
		treeNode<Type>* rt = new treeNode<Type>(r->data, l, r);
		return rt;
	}
}
template<class Type>
void tree<Type>::DestroyHelp(treeNode<Type>*&r) {
	if (r != NULL) {
		DestroyHelp(r->right);
		DestroyHelp(r->left);
		delete r;
		r = NULL;
	}
}
template<class Type>
void tree<Type>::preHelp(treeNode<Type>* r, void(*visit)(Type &)) {
	//递归算法
	if (r != NULL) {
		(*visit)(r->data);
		preHelp(r->left, visit);
		preHelp(r->right, visit);
	}
	//非递归算法
	stack<treeNode<Type>*>s;
	while (r != NULL) {
		(*visit)(r->data);
		s.push(r);
		if (r->left != NULL)
			r = r->left;
		else if (!s.empty()) {
			while (!s.empty()) {
				s.pop(r);
				r = r->right;
				if (r != NULL)break;
			}
		}
		else r = NULL;
	}
}
template<class Type>
void tree<Type>::inHelp(treeNode<Type>* r, void(*visit)(Type &)) {
	//递归算法
	if (r != NULL) {
		inHelp(r->left, visit);
		(*visit)(r->data);
		inHelp(r->right, visit);
	}
	//非递归算法
	stack<treeNode<Type>*>s;
	while (r != NULL) {
		s.push(r);
		if (r->left != NULL) {
			r = r->left;
		}
		else if (!s.empty()) {
			while (!s.empty()) {
				s.pop(r);
				(*visit)(r->data);
				r = r->right;
				if (r != NULL)break;
				}
		}
		else r = NULL;
	}
}
template<class Type>
void tree<Type>::postHelp(treeNode<Type>* r, void(*visit)(Type &)) {
	//递归算法
	if (r != NULL) {
		postHelp(r->left, visit);
		postHelp(r->right, visit);
		(*visit)(r->data);
	}
	//非递归算法
	stack<treeNode<Type>*>s;
	while (r != NULL) {
		s.push(r);
		if (r->left != NULL) {
			r = r->left;
		}
		else if (r->right != NULL) {
			r = r->right;
		}
		else if (!s.empty()) {
			while (!s.empty()) {
				s.pop(r);
				(*visit)(r->data);
				r = r->right;
				if (r != NULL)break;
			}
		}
		else r = NULL;
	}
}
template<class Type>
int tree<Type>::heightHelp(const treeNode<Type>* r)const {
	if (r == NULL)return 0;
	else {
		int lHeight, rHeight;
		lHeight = heightHelp(r->left);
		rHeight = heightHelp(r->right);
		return 1 + (lHeight > rHeight ? lHeight : rHeight);
	}
}
template<class Type>
int tree<Type>::nodecntHelp(const treeNode<Type>* r)const {
	if (r == NULL)return 0;
	else return 1 + nodecntHelp(r->left) + nodecntHelp(r->right);
}
template<class Type>
treeNode<Type>* tree<Type>::parentsHelp(treeNode<Type>* r, const treeNode<Type>* cur)const {

}
template<class Type>
tree<Type>::tree() {
	root = NULL;
}
template<class Type>
tree<Type>::tree(treeNode<Type>* root) {
	this->data = root->data;
	this->left = root->left;
	this->right = root->right;
}
template<class Type>
tree<Type>::tree(const Type &e) {
	root->data = e;
}
template<class Type>
tree<Type>::tree(const tree& copy) {
	root = CopyHelp(copy.root);
}
template<class Type>
tree<Type>::~tree() {
	DestroyHelp(root);
}
template<class Type>
tree<Type>& tree<Type>::operator=(const tree<Type>& copy) {
	if (&copy != this) {
		DestroyHelp(root);
		root = CopyHelp(copy.root);
	}
}
template<class Type>
treeNode<Type>* tree<Type>::getRoot()const {
	return root;
}
template<class Type>
bool tree<Type>::Empty()const {
	return root == NULL;
}
template<class Type>
bool tree<Type>::getelem(treeNode<Type>* cur, Type e) {
	if (cur != NULL) {
		e = cur->data;
		return 1;
	}
	else return 0;
}
template<class Type>
bool tree<Type>::setelem(treeNode<Type>* cur, Type e) {
	if (cur != NULL) {
		cur->data = e;
		retur 1;
	}
	else return 0;
}
template<class Type>
void tree<Type>::inOrder(void(*visit)(Type &)) {
	inHelp(root, visit);
}
template<class Type>
void tree<Type>::preOrder(void(*visit)(Type &)) {
	preHelp(root, visit);
}
template<class Type>
void tree<Type>::postOrder(void(*visit)(Type &)) {
	postHelp(root, visit);
}
template<class Type>
void tree<Type>::levelOrder(void(*visit)(Type &)) {
	queue<treeNode<Type>*>q;
	treeNode<Type>* t = root;
	if (t != NULL)q.push(t);
	while (!q.empty()) {
		t = q.front();
		q.pop();
		(*visit)(t->data);
		if (t->left != NULL)q.push(t->left);
		if (t->right != NULL)q.push(t->right);
	}
}
template<class Type>
int tree<Type>::nodeCnt()const {
	return nodecntHelp(root);
}
template<class Type>
treeNode<Type>* tree<Type>::leftChild(const treeNode<Type>* cur)const {
	return cur->left;
}
template<class Type>
treeNode<Type>* tree<Type>::rightChild(const treeNode<Type>* cur)const {
	return cur->right;
}
template<class Type>
treeNode<Type>* tree<Type>::parents(const treeNode<Type>* cur)const {

}
template<class Type>
void tree<Type>::insertleft(const treeNode<Type>* cur, const Type& e) {
	treeNode<Type> next = new treeNode<Type>(e);
	if (cur->left == NULL)cur->left = next;
	else {
		next->left = cur->left;
		cur->left = next;
	}
}
template<class Type>
void tree<Type>::insertright(const treeNode<Type>* cur, const Type& e) {
	treeNode<Type> next = new treeNode<Type>(e);
	if (cur->right == NULL)cur->right = next;
	else {
		next->right = cur->right;
		cur->right = next;
	}
}
template<class Type>
void tree<Type>::deleteleft(const treeNode<Type>* cur) {
	if (cur->left == NULL)return;
	else {
		treeNode<Type>* tmp = cur->left;
		cur->left = tmp->left;
		delete tmp;
	}
}
template<class Type>
void tree<Type>::deleteright(const treeNode<Type>* cur) {
	if (cur->right == NULL)reuturn;
	else {
		treeNode<Type>* tmp = cur->right;
		cur->right = tmp->right;
		delete tmp;
	}
}
template<class Type>
int tree<Type>::height() {
	return heightHelp(root);
}
#endif