数据结构-二叉树(c++)

#include<iostream>
#include<stack>

using namespace std;

template<class T>        //结点类
class node
{
public:
	node(T _data);
	~node();
	T data;

	node* lchild, *rchild;
};


template<class T>    //构造
node<T>::node(T _data) { data = _data; lchild = nullptr; rchild = nullptr; }

template<class T>    //析构
node<T>::~node() { lchild = nullptr; rchild = nullptr; }



template<class T>        //二叉树类
class binaryTree
{
public:
	binaryTree();

	~binaryTree();

	node<T>* getRoot();

	void DLR(node<T>* p);

	void LDR(node<T>* p);

	void LRD(node<T>* p);

	void before();

	void middle();

	void after();

	void remove(node<T>* p);

	int getDepth(node<T>* p);

private:

	node<T>* create();

	node<T>* root;
};

template<class T>			//构造
binaryTree<T>::binaryTree() { root = create(); }


template<class T>			//析构
binaryTree<T>::~binaryTree() { remove(root); }


template<class T>			//创建二叉树
node<T>* binaryTree<T>::create() 
{
	char ch;
	cin >> ch;
	node<T>* p;

	if (ch == '#') { p = nullptr; }
	else { p = new node<T>(ch); p->lchild = create(); p->rchild = create(); }

	return p;
}


template<class T>	//获取根节点
node<T>* binaryTree<T>::getRoot() { return root; }


template<class T>	//先序递归遍历
void binaryTree<T>::DLR(node<T>* p) 
{
	if (p == nullptr) { return; }
	cout << p->data << "  ";
	DLR(p->lchild);
	DLR(p->rchild);
}


template<class T>	//中序递归遍历
void binaryTree<T>::LDR(node<T>* p) 
{
	if (p == nullptr) { return; }
	LDR(p->lchild);
	cout << p->data << "  ";
	LDR(p->rchild);
}


template<class T>	//后序递归遍历
void binaryTree<T>::LRD(node<T>* p) 
{
	if (p == nullptr) { return; }
	LRD(p->lchild);
	LRD(p->rchild);
	cout << p->data << "  ";
}

template<class T>	//先序非递归遍历
void binaryTree<T>::before() 
{
	node<T>* p = root;
	stack<node<T>*> s;
	
	while (!s.empty() || p)
	{
		if (p != nullptr) 
		{
			cout << p->data << "  ";
			if (p->rchild != nullptr) { s.push(p->rchild); }
			p = p->lchild;
		}
		else{ p = s.top(); s.pop();}
	}
	cout << endl;
}


template<class T>	//中序非递归遍历
void binaryTree<T>::middle() 
{
	node<T>* p = root;
	stack<node<T>*> s;

	while (!s.empty() || p)
	{
		if (p != nullptr)
		{
			s.push(p);
			p = p->lchild;
		}
		else
		{
			p = s.top();
			s.pop();
			cout << p->data << "  ";
			p = p->rchild;
		}
	}
	cout << endl;
}


template<class T>	//后序非递归遍历
void binaryTree<T>::after() 
{
	node<T>* p = root;
	stack<pair<node<T>*,bool>> s;
	pair<node<T>*, bool> pi = make_pair(p, false);
	
	while (p || !s.empty())
	{
		if(p != nullptr)		
		{
			pi = make_pair(p, false);
			s.push(pi);
			p = p->lchild;
		}
		else
		{
			p = s.top().first;
			bool flag = s.top().second;


			if (p->lchild != nullptr && flag == false)
			{
				cout << p->lchild->data << "  ";
				pi = make_pair(p, true);
				s.pop();
				s.push(pi);
			}
			else if (p->lchild == nullptr)
			{
				pi = make_pair(p, true);
				s.pop();
				s.push(pi);
			}

			if (p->rchild != nullptr && flag == true)
			{
				cout << p->rchild->data << "  ";
				s.pop();
				p = nullptr;
			}
			else if(p->rchild != nullptr)
			{
				p = p->rchild;
			}
			else
			{
				s.pop();
				p = nullptr;
			}
		}
	}
	cout << root->data << "  ";
	cout << endl;
}


template<class T>	//后序递归清空二叉树
void binaryTree<T>::remove(node<T>* p)
{
	if (p == nullptr) { return; }
	remove(p->lchild);
	remove(p->rchild);
	//cout << "删除：" << p->data << endl;
	delete p;
	p = nullptr;
}

template<class T>			//求二叉树的深度
int binaryTree<T>::getDepth(node<T>* p)
{
	if (p == nullptr) { return 0; }
	int L = getDepth(p->lchild);
	int R = getDepth(p->rchild);

	return max(L + 1, R + 1);
}