#pragma once
#include <iostream>
using namespace std;
template <typename DataType>
struct BinTreeNode
{
DataType data;
BinTreeNode* lChild;
BinTreeNode* rChild;
};
template <class DataType>
class BinTree
{
public:
BinTree();
~BinTree();
BinTreeNode<DataType>* Create(BinTreeNode<DataType>* bt);
void Vistied(BinTreeNode<DataType>* bt);
void PreOrder();
void InOrder();
void PostOrder();
void NPreOrder();
void NInOrder();
void NPostOrder();
void LevelOrder();
int Depth();
private:
BinTreeNode<DataType>* root;
void PreOrder(BinTreeNode<DataType>* bt);
void InOrder(BinTreeNode<DataType>* bt);
void PostOrder(BinTreeNode<DataType>* bt);
void Destory(BinTreeNode<DataType>* bt);
int Depth(BinTreeNode<DataType>* bt);
};
#include "BiTree.h"
template<class DataType>
BinTree<DataType>::BinTree()
{
root = Create(root);
}
template<class DataType>
BinTree<DataType>::~BinTree()
{
Destory(root);
}
template<class DataType>
BinTreeNode<DataType>* BinTree<DataType>::Create(BinTreeNode<DataType>* bt)
{
DataType data;
cin >> data;
if (data == '#')
{
bt = NULL;
}
else
{
bt = new BinTreeNode<DataType>();
bt->data = data;
bt->lChild = Create(bt->lChild);
bt->rChild = Create(bt->rChild);
}
return bt;
}
template<class DataType>
void BinTree<DataType>::Destory(BinTreeNode<DataType>* bt)
{
if (bt)
{
Destory(bt->lChild);
Destory(bt->rChild);
delete bt;
}
}
template<class DataType>
int BinTree<DataType>::Depth(BinTreeNode<DataType>* bt)
{
if (!bt)
{
return 0;
}
int lDepth = Depth(bt->lChild);
int rDepth = Depth(bt->rChild);
return lDepth > rDepth ? lDepth + 1 : rDepth + 1;
}
template<class DataType>
void BinTree<DataType>::Vistied(BinTreeNode<DataType>* bt)
{
cout << bt->data << "\t";
}
template<class DataType>
void BinTree<DataType>::PreOrder()
{
PreOrder(root);
}
template<class DataType>
void BinTree<DataType>::InOrder()
{
InOrder(root);
}
template<class DataType>
void BinTree<DataType>::PostOrder()
{
PostOrder(root);
}
template<class DataType>
void BinTree<DataType>::NPreOrder()
{
BinTreeNode<DataType>* stack[50];
int top = -1;
if (!root)
{
return;
}
stack[++top] = root;
while (top > -1){
BinTreeNode<DataType>* pop = stack[top--];
if (pop)
{
Vistied(pop);
stack[++top] = pop->rChild;
stack[++top] = pop->lChild;
}
}
}
template<class DataType>
void BinTree<DataType>::NInOrder()
{
BinTreeNode<DataType>* stack[50];
int top = -1;
BinTreeNode<DataType>* p = root;
while (p || top > -1) {
if (p)
{
stack[++top] = p;
p = p->lChild;
}
else
{
p = stack[top--];
Vistied(p);
p = p->rChild;
}
}
}
template<class DataType>
void BinTree<DataType>::NPostOrder()
{
}
template<class DataType>
void BinTree<DataType>::PreOrder(BinTreeNode<DataType>* bt)
{
if (bt !=NULL)
{
Vistied(bt);
PreOrder(bt->lChild);
PreOrder(bt->rChild);
}
return;
}
template<class DataType>
void BinTree<DataType>::InOrder(BinTreeNode<DataType>* bt)
{
if (bt)
{
InOrder(bt->lChild);
Vistied(bt);
InOrder(bt->rChild);
}
return;
}
template<class DataType>
void BinTree<DataType>::PostOrder(BinTreeNode<DataType>* bt)
{
if (bt)
{
PostOrder(bt->lChild);
PostOrder(bt->rChild);
Vistied(bt);
}
return;
}
template<class DataType>
void BinTree<DataType>::LevelOrder()
{
if (!root)
{
return;
}
BinTreeNode<DataType>* queue[50];
int front = -1;
int rear = -1;
queue[++rear] = root;
while (front != rear)
{
BinTreeNode<DataType>* p = queue[++front];
Vistied(p);
if (p->lChild != NULL)
{
queue[++rear] = p->lChild;
}
if (p->rChild != NULL)
{
queue[++rear] = p->rChild;
}
}
return;
}
template<class DataType>
int BinTree<DataType>::Depth()
{
return Depth(root);
}