（二）数据结构-二叉树的创建及遍历

这里创建二叉树运用了即遍历，都进行了函数的重载，并且遍历的时候，只是顺序的改变；

难点：层次遍历的方法，在这里进行了一下总结。其中包括vector , queue, deque, 等多种方法：

#include "iostream"
#include "vector"
#include "malloc.h"
#include "queue"
using namespace std;

//二叉树   //先序顺序进行创建
template<class Object>
class BinaryNode;

template<class Object>
class BinaryTree
{
private:
	BinaryNode<Object> *root;   //想要对private进行创建，建立一个重载的函数
public:
	BinaryTree()
	{
		root = 0;
	}
	~BinaryTree()
	{
		delete root;
	}
	void create();  
	bool create(BinaryNode<Object> *&T);  //define 构造二叉树  //递归创建
	
	//先序，中序，后序，只是输出顺序不同，在操作中递归排列输出顺序。
	void preOrderTraverse();
	void inOrderTraverse();
	void postOrderTraverse();
	void levelOrderTraverse();
	void pirntBFS();
	void printBFS_();
	void printNodeByLevel();
	void printNodeByLevel_();
	bool preOrderTraverse(BinaryNode<Object> *T);   //还可以将遍历完的结点加入到队列中，最后输出。这样就遍历完毕
	bool inOrderTraverse(BinaryNode<Object> *T);
	bool postOrderTraverse(BinaryNode<Object> *T);
	bool levelOrderTraverse(BinaryNode<Object> *T);
	void pirntBFS(BinaryNode<Object> *root);
	void printBFS_(BinaryNode<Object> *root);
	void printNodeByLevel(BinaryNode<Object> *root);
	void printNodeByLevel_(BinaryNode<Object> *root);

	void *operator new(size_t size);
	void operator delete(void *p);
};

template<class Object>
void* BinaryTree<Object>::operator new(size_t size)
{
	void *p = malloc(size);
	return p;
}

template<class Object>
void BinaryTree<Object>::operator delete(void *p)
{
	free(p);
}

//typedef char Object;
template<class Object>
class BinaryNode
{
	friend class BinaryTree<Object>;
private:
	Object elem;
	BinaryNode *leftChild;
	BinaryNode * rightChild;
};

template<class Object>
void BinaryTree<Object>::create()
{
	
	create(root);
}

template<class Object>
bool BinaryTree<Object>::create(BinaryNode<Object> *&T)   //指针申请的内存，所以用指向指针的指针或引用
{
	cout << "enter the value of the elem:";
	Object x;
	cin >> x;
	if(x == '#') {T = NULL; delete T;}
	else
	{
		T = new BinaryNode<Object>;   //对外不起作用， //指针参数是如何传递内存的。除非使用指向指针的引用
		T->elem = x;
		create(T->leftChild);
		create(T->rightChild);
	}
	return true;
}

template<class Object>
void BinaryTree<Object>::preOrderTraverse()
{
	cout << "the preOrder: ";
	preOrderTraverse(root);
	cout << endl;
}
template<class Object>
bool BinaryTree<Object>::preOrderTraverse(BinaryNode<Object> *T)
{
	if(T != NULL)
	{
		cout << T->elem << " ";
		preOrderTraverse(T->leftChild);
		preOrderTraverse(T->rightChild);
	}
	return true;
}

template<class Object>
void BinaryTree<Object>::inOrderTraverse()
{
	cout << "the inOrder: ";
	inOrderTraverse(root);
	cout << endl;
}
template<class Object>
bool BinaryTree<Object>::inOrderTraverse(BinaryNode<Object> *T)
{
	if(T != NULL)
	{
		inOrderTraverse(T->leftChild);
		cout << T->elem << " ";
		inOrderTraverse(T->rightChild);
	}
	return true;
}

template<class Object>
void BinaryTree<Object>::postOrderTraverse()
{
	cout << "the postOrder: ";
	postOrderTraverse(root);
	cout << endl;
}
template<class Object>
bool BinaryTree<Object>::postOrderTraverse(BinaryNode<Object> *T)
{
	if(T != NULL)
	{
		postOrderTraverse(T->leftChild);
		postOrderTraverse(T->rightChild);
		cout << T->elem << " ";
	}
	return true;
}

/*************************************************************************************************************/
//按层次遍历的几种方法
//method1:
//层次遍历的vector存储模型
template<class Object>
void BinaryTree<Object>::levelOrderTraverse()
{
	cout <<  "the levelOrder: ";
	levelOrderTraverse(root);
}

template<class Object>
bool BinaryTree<Object>::levelOrderTraverse(BinaryNode<Object> *T)
{
	vector<BinaryNode<Object>*> Node;   //注意定义是结点指针
	if(T != NULL)
	{	
		Node.push_back(T);
		int cur = 0;
		int last = 1;
		while(cur < Node.size())
		{
			last = Node.size();
			while(cur < last)
			{
				cout << Node[cur]->elem << " ";
				if(Node[cur]->leftChild)
					Node.push_back(Node[cur]->leftChild);
				if(Node[cur]->rightChild)
					Node.push_back(Node[cur]->rightChild);
				cur++;
			}
		}
		cout << endl;
	}
	return true;
}

//method2:
//利用queue双向队列进行实现，
template<class Object>
void BinaryTree<Object>::printBFS_()
{
	cout << "the level order: ";
	printBFS_(root);
}
template<class Object>
void BinaryTree<Object>::printBFS_(BinaryNode<Object> *root)
{
	queue<BinaryNode<Object> *> Node;
	Node.push(root);
	do
	{
		BinaryNode<Object> *node = Node.front(); //第一个结点
		Node.pop();
		cout << node->elem << " ";
		if(node->leftChild)
			Node.push(node->leftChild);
		if(node->rightChild)
			Node.push(node->rightChild);
	}
	while(!Node.empty());
}

//mothod3:
//换行
template<class Object>
void BinaryTree<Object>::printNodeByLevel_()
{
	cout << "the level order: ";
	printNodeByLevel_(root);
}
template<class Object>
void BinaryTree<Object>::printNodeByLevel_(BinaryNode<Object> *root)
{
	deque<BinaryNode<Object> *>Q1, Q2;
	Q1.push_back(root);
	do
	{
		do
		{
			BinaryNode<Object>* node = Q1.front();
			Q1.pop_front();
			cout << node->elem << " ";
			if(node->leftChild)
				Q2.push_back(node->leftChild);
			if(node->rightChild)
				Q2.push_back(node->rightChild);
		}while(!Q1.empty());
		cout << endl;
		Q1.swap(Q2);   //exchange the node
	}while(!Q1.empty());
}


//method 4:
template<class Object>
void BinaryTree<Object>::printNodeByLevel()
{
	cout << "the level order: ";
	printNodeByLevel(root);
}
template<class Object>
void BinaryTree<Object>::printNodeByLevel(BinaryNode<Object> *root)
{
	queue<BinaryNode<Object> *> Q;
	Q.push(root);
	Q.push(0);
	do
	{
		BinaryNode<Object> *node = Q.front();
		Q.pop();
		if(node)
		{
			cout << node->elem << " ";
			if(node->leftChild)
				Q.push(node->leftChild);   //左压入，没有递归哦
			if(node->rightChild)
				Q.push(node->rightChild);  //右压入
		}
		else if(!Q.empty())  //当发现空指针(结束信号)时，要检查队列内是否还有节点，如果没有的话还插入新的结束信号，则会做成死循环
		{
			Q.push(0);
			cout << endl;
		}
	}while(!Q.empty());
}

//method5:
//多加一个level 成员
template<class Object>
void BinaryTree<Object>::pirntBFS()
{
	cout << "the level order: ";
	pirntBFS(root);
}
template<class Object>
void BinaryTree<Object>::pirntBFS(BinaryNode<Object> *root)
{
	queue<BinaryNode<Object> *> Q;
	Q.push(root);
	int curlevel = 0;
	do
	{
		BinaryNode<Object> *node = Q.front();
		int level = node->level;
		Q.pop();
		cout << node->elem << " ";
		if(node->leftChild)
		{
			node->leftChild.level = level + 1;
			Q.push(node->leftChild);
		}
		if(node->rightChild)
		{
			node->rightChild.level = level + 1;
			Q.push(node->rightChild);
		}
	}
	while(!Q.empty());
}
/****************************************************************************************************************/

int main()
{
	BinaryTree<char> tree;
	tree.create();

	tree.preOrderTraverse();  //先序遍历
	tree.inOrderTraverse();   //中序遍历
	tree.postOrderTraverse(); //后序遍历
	tree.levelOrderTraverse();//层次遍历
	tree.printNodeByLevel();

	cin.get();
	cin.get();
	return 0;
}