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 (© != 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