二叉树的层次遍历

二叉树的层次遍历

【问题描述】首先利用二叉树的前序遍历建立一棵二叉树，然后利用队列实现二叉树的层次遍历并输出结果

【输入形式】假设二叉树的结点为字符型，输入“#”表示空结点，输入为一行字符串，具体见样例输入，二叉树见殷人昆教材P202页，图5.15

输出形式】输出只有一行，二叉树的层次遍历结果，输出结点字符值时用一个空格隔开，注意最后一个字符后也有一个空格，具体格式见样例输出

【样例输入】

ABC##DE#G##F###

【样例输出】

A B C D E F G

代码如下:

PS:注意队列结点类型的定义

#include<iostream>

using namespace std;

template<class T>
struct BinTreeNode
{
	T data;
	BinTreeNode<T>* leftchild;
	BinTreeNode<T>* rightchild;
	BinTreeNode()
	{
		leftchild = NULL;
		rightchild = NULL;
	}
	BinTreeNode(T x)
	{
		data = x;
		leftchild = NULL;
		rightchild = NULL;
	}
};

template<class T>
struct QueneNode
{
	BinTreeNode<T>* data;
	QueneNode<T>* link;
	QueneNode()
	{
		data = NULL;
		link = NULL;
	}
	QueneNode(BinTreeNode<T>* x)
	{
		data = x;
		link = NULL;
	}
};


template<class T>
class BinTree
{
public:
	BinTree();
	~BinTree();
	BinTreeNode<T>* Get_root()
	{
		return root;
	}  //返回根结点
	void CreateTree(BinTreeNode<T>*& root);  //创建二叉树
	void DeleTree(BinTreeNode<T>* root);  //销毁二叉树
protected:
	BinTreeNode<T>* root;
};

template<class T>
class Quene
{
public:
	Quene();  //构造函数
	bool EnQuene(BinTreeNode<T>* x);  //入队
	bool DeQuene(BinTreeNode<T>*& x);  //出队
	bool Is_Empty();  //判断队列是否为空
private:
	QueneNode<T>* front;  //队头指针
	QueneNode<T>* rear;  //队尾指针
};

template<class T>
BinTree<T>::BinTree()
{
	root = NULL;
}

template<class T>
BinTree<T>::~BinTree()
{
	DeleTree(root);
}

template<class T>
void BinTree<T>::CreateTree(BinTreeNode<T>*& root)
{
	T x;
	cin >> x;
	if (x == '#')
	{
		root = NULL;
		return;
	}
	root = new BinTreeNode<T>(x);
	if (root == NULL)
		return;
	CreateTree(root->leftchild);
	CreateTree(root->rightchild);
}

template<class T>
void BinTree<T>::DeleTree(BinTreeNode<T>* root)
{
	if (root == NULL)
		return;
	DeleTree(root->leftchild);
	DeleTree(root->rightchild);
	delete root;
}

template<class T>
Quene<T>::Quene()
{
	front = new QueneNode<T>;
	rear = front;
}


template<class T>
bool Quene<T>::EnQuene(BinTreeNode<T>* x)
{
	QueneNode<T>* newnode;
	newnode = new QueneNode<T>(x);
	if (newnode == NULL)
		return false;
	rear->link = newnode;
	rear = newnode;
	return true;
}

template<class T>
bool Quene<T>::DeQuene(BinTreeNode<T>*& x)
{
	QueneNode<T>* p = front->link;
	if (front == rear)
		return false;
	if (p == rear)
		rear = front;
	front->link = p->link;
	x = p->data;
	delete p;
	p = NULL;
	return true;
}

template<class T>
bool Quene<T>::Is_Empty()
{
	if (front == rear)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void Level_Tra(BinTreeNode<char>* root)
{
	BinTreeNode<char>* p = root;
	if (root == NULL)
	{
		return;
	}
	Quene<char> t;
	t.EnQuene(p);
	while (!t.Is_Empty())
	{
		t.DeQuene(p);
		cout << p->data << ' ';
		if (p->leftchild != NULL)
			t.EnQuene(p->leftchild);
		if (p->rightchild != NULL)
			t.EnQuene(p->rightchild);
	}
}

int main()
{
	BinTree<char> tree;
	BinTreeNode<char>* head = tree.Get_root();
	tree.CreateTree(head);
	Level_Tra(head);
	return 0;
}