二叉树及操作c++

//二叉树及操作
#include<iostream>
#include<cstring>
using namespace std;
template<class T>
struct Node1//栈和队列共用结构
{
	T data;
	Node1<T> *next;
};
//栈和队列其实都可以直接调用。
//栈定义
template<class T>
class linkstack
{
	Node1<T> *top;
public:
	linkstack() { top = NULL; }
	~linkstack();
	void push(T x);
	T Top();
	T pop();
	bool empty() { return top == NULL; }
};
template<class T>
linkstack<T>::~linkstack()
{
	Node1<T> *p = top;
	while (p)
	{
		Node1<T> *q;
		q = p;
		p = p->next;
		delete q;
	}
	top = NULL;
}
template<class T>
void linkstack<T>::push(T x)
{
	Node1<T> *p = new Node1<T>;
	p->data = x;
	p->next = top;
	top = p;
}
template<class T>
T linkstack<T>::pop()
{
	if (top == NULL)
	{
		cout << "下溢" << endl;
		exit(1);
	}
	T x;
	Node1<T> *p = top;
	x = p->data;
	top = top->next;
	delete p;
	return x;
}
template<class T>
T linkstack<T>::Top()
{
	if (top == NULL)
	{
		cout << "下溢" << endl;
		exit(1);
	}
	return top->data;
}
template<class T>
//队列定义
class linkque
{
	Node1<T> *front, *rear;//队头指针，队尾指针
public:
	linkque();
	~linkque();
	void enque(T x);
	T deque();
	T getque();
	bool empty();
	void output();
};
template<class T>
linkque<T>::linkque()
{
	Node1<T> *s = new Node1<T>;
	s->next = NULL;
	front = rear = s;
}
template<class T>
linkque<T>::~linkque()
{
	rear = front=NULL;
}
template<class T>
void linkque<T>::enque(T x)//入队
{
	Node1<T> *p = new Node1<T>;
	p->data = x;
	p->next = NULL;
	rear->next = p;
	rear = p;
}
template<class T>
T linkque<T>::deque()//出队
{
	if (rear == front)
	{
		cout << "下溢" << endl;
		exit(1);
	}
	Node1<T> *p = front->next;
	T x = p->data;
	front->next = p->next;
	if (p->next == NULL)
	{
		rear = front;
	}
	delete p;
	return x;
}
template<class T>
T linkque<T>::getque()//返回队头元素
{
	if (rear == front)
	{
		cout << "下溢" << endl;    //即队列为空
		exit(1);
	}
	return front->next->data;
}
template<class T>
bool linkque<T>::empty()//判断是否为空
{
	return front == rear;
}
template<class T>
void linkque<T>::output()//输出队列
{
	Node1<T> *p = front->next;
	while (p != NULL)
	{
		T x = p->data;
		cout << x << " ";
		p = p->next;
	}
	cout << endl;
}

//二叉树
template<class T>
struct Node//二叉树结点
{
	T data;//结点元素
	Node<T> *lchild, *rchild;//左右孩子
};
template<class T>
class bitree
{
private:
	Node<T> * root;
	void pre_Order(Node<T> *t);//前序遍历
	void in_Order(Node<T> *t);//中序遍历
	void post_Order(Node<T> *t);//后序遍历
	void level_Order(Node<T> *t);//层次遍历
	void depthFirstSearch(Node<T> *t);//深度优先搜索
	void breadthFirstSearch(Node<T> *t);//广度优先搜索
	Node<T> *create(char s[], int &pos);
public:
	int length;
	void createBiTree(char s[]);//前序构造二叉树
	void preOrder();//前序
	void inOrder();//中序
	void postOrder();//后序
	void levelOrder();///层次
	void DepthFirstSearch();//深度
	void BreadthFirstSearch();//广度
};
template<class T>
Node<T> *bitree<T>::create(char s[], int &pos)
{
	++pos;
	Node<T> *t;
	if (pos >= length)//判断越界
		return NULL;
	else
	{
		if (s[pos] == '#')
			t = NULL;
		else
		{
			t = new Node<T>;
			t->data = s[pos];
			t->lchild = create(s, pos);
			t->rchild = create(s, pos);
		}
		return t;
	}
}
template<class T>
void bitree<T>::createBiTree(char s[])
{
	length = strlen(s);
	int pos = -1;
	root = create(s, pos);
}
template<class T>
void bitree<T>::preOrder()
{
	cout << "前序遍历结果";
	pre_Order(root);
	cout << endl;
}
template<class T>
void bitree<T>::pre_Order(Node<T> *t)
{
	if (t != NULL)
	{
		cout << t->data << " ";
		pre_Order(t->lchild);
		pre_Order(t->rchild);
	}
}
template<class T>
void bitree<T>::inOrder()
{
	cout << "中序遍历结果";
	in_Order(root);
	cout << endl;
}
template<class T>
void bitree<T>::in_Order(Node<T> *t)
{
	if (t != NULL)
	{
		in_Order(t->lchild);
		cout << t->data << " ";
		in_Order(t->rchild);
	}
}
template<class T>
void bitree<T>::postOrder()
{
	cout << "后序遍历结果";
	post_Order(root);
	cout << endl;
}
template<class T>
void bitree<T>::post_Order(Node<T> *t)
{
	if (t != NULL)
	{
		post_Order(t->lchild);
		post_Order(t->rchild);
		cout << t->data << " ";
	}
}
template<class T>
void bitree<T>::levelOrder()
{
	cout << "层次遍历结果";
	level_Order(root);
	cout << endl;

}
template<class T>
void bitree<T>::level_Order(Node<T> *t)
{
	if (t == NULL)
		exit(1);
	linkque<Node<T>*> a;
	a.enque(t);
	while (!a.empty())
	{
		Node<T> *p;
		p = a.getque();
		a.deque();
		cout << p->data << " ";
		if (p->lchild != NULL)
			a.enque(p->lchild);
		if (p->rchild != NULL)
			a.enque(p->rchild);
	}
}
template<class T>
void bitree<T>::breadthFirstSearch(Node<T> *t)
{
	linkque<Node<T>*> q;
	q.enque(t);
	while (!q.empty())
	{
		Node<T> *node = q.getque();
		cout << node->data << " ";
		q.deque();
		if (node->lchild)
		{
			q.enque(node->lchild);
		}
		if (node->rchild)
		{
			q.enque(node->rchild);
		}
	}
}
template<class T>
void bitree<T>::BreadthFirstSearch()
{
	cout << "广度优先搜索";
	breadthFirstSearch(root);
	cout << endl;
}
template<class T>
void bitree<T>::depthFirstSearch(Node<T> *t)
{
	linkstack<Node<T>*> nodestack;
	nodestack.push(t);
	while (!nodestack.empty())
	{
		Node<T> *node = nodestack.Top();
		cout << node->data << " ";
		nodestack.pop();
		if (node->rchild)
		{
			nodestack.push(node->rchild);
		}
		if (node->lchild)
		{
			nodestack.push(node->lchild);
		}
	}
}
template<class T>
void bitree<T>::DepthFirstSearch()
{
	cout << "深度优先搜索";
	depthFirstSearch(root);
	cout << endl;
}
int main()
{
	char t[20] = "helloworld";
	bitree<char> a;
	a.createBiTree(t);
	a.preOrder();
	a.inOrder();
	a.postOrder();
	a.levelOrder();
	a.BreadthFirstSearch();
	a.DepthFirstSearch();
	system("pause");
	return 0;
}

测试结果：