#ifndef BINARYTREENODE
#define BINARYTREENODE
template <typename T >
class BinaryTreeNode
{
private:
int counter; //计数
T element;
BinaryTreeNode < T > *left;
BinaryTreeNode < T > *right;
public:
BinaryTreeNode ();
BinaryTreeNode (const T& ele);
BinaryTreeNode (const T& ele,BinaryTreeNode < T > *l,BinaryTreeNode < T > *r);
T GetValue() const; //返回当前结点的数据
int GetCounter() const;
BinaryTreeNode < T > * GetLeftChild()const;
BinaryTreeNode < T > * GetRightChild() const;
void SetLeftChild(BinaryTreeNode < T > *);
void SetRightChild(BinaryTreeNode < T > *);
void SetValue(const T & val); //设置当前结点的数据
void SetCounter();
bool IsLeaf() const;
BinaryTreeNode < T > & operator =(const BinaryTreeNode < T > & Node);
};
template <typename T >
class BinaryTree
{
private:
BinaryTreeNode < T > *root;
public:
BinaryTree( BinaryTreeNode < T > * node = NULL)
{
root=node;
}
~BinaryTree()
{
cout<<"依次被删除的BinaryTreeNode 结点"<<endl;
DeleteBinaryTree(root);
}
bool IsEmpty() const
{
return (root?(false,true));
}
T Visit(BinaryTreeNode < T > *current); //访问元素值
BinaryTreeNode < T > *Serach(T v);
void Insert(T v); //插入元素
BinaryTreeNode < T > *GetRoot();
void CreatTree(const T & ele,BinaryTree< T > &leftTree,BinaryTree < T > &rightTree);
void PreOrder(BinaryTreeNode < T > *root); //前序周游
void PreOrder1(BinaryTreeNode < T > *root); //前序周游(递归)
void InOrder(BinaryTreeNode < T > *root); //中序周游
void InOrder1(BinaryTreeNode < T > *root); //中序周游(递归)
void PostOrder(BinaryTreeNode < T > *root); //后序周游
void PostOrder1(BinaryTreeNode < T > *root);//后序周游(递归)
void LeveOrder(BinaryTreeNode < T > *root); //按层次周游
void DeleteBinaryTree(BinaryTreeNode < T > *root);
};
#endif
#include "BinaryTree.h"
#include <iostream>
#include <stack>
#include <queue>
#include <string>
#include <fstream>
using namespace std;
/*------------------------------------------------------BinaryTreeNode----------------------------------------------------*/
template <typename T >
BinaryTreeNode < T > ::BinaryTreeNode ()
{
counter=1;
left=right=NULL;
}
template <typename T >
BinaryTreeNode < T > ::BinaryTreeNode (const T& ele)
{
element=ele;
counter=1;
left=right=NULL;
}
template <typename T >
BinaryTreeNode < T > ::BinaryTreeNode(const T& ele, BinaryTreeNode<T> *l, BinaryTreeNode<T> *r)
{
element=ele;
counter=1;
left=l;
right=r;
}
template <typename T >
T BinaryTreeNode < T > ::GetValue() const
{
return this->element;
}
template <typename T >
int BinaryTreeNode < T > ::GetCounter() const
{
return this->counter;
}
template <typename T >
BinaryTreeNode < T > * BinaryTreeNode < T > ::GetLeftChild()const
{
return this->left;
}
template <typename T >
BinaryTreeNode < T > * BinaryTreeNode < T > ::GetRightChild() const
{
return this->right;
}
template <typename T >
void BinaryTreeNode < T >::SetLeftChild(BinaryTreeNode < T > * l)
{
this->left=l;
}
template <typename T >
void BinaryTreeNode < T > ::SetRightChild(BinaryTreeNode < T > * r)
{
this->right=r;
}
template <typename T >
void BinaryTreeNode < T > ::SetValue(const T & val)
{
this->element=val;
}
template <typename T >
void BinaryTreeNode < T >::SetCounter()
{
this->counter++;
}
template <typename T >
bool BinaryTreeNode < T > :: IsLeaf() const
{
if (this->left ==NULL && this ->right)
return true;
else
return false;
}
template <typename T >
BinaryTreeNode < T > & BinaryTreeNode < T >::operator =(const BinaryTreeNode < T > & Node)
{
this->value=node.value;
this->left=node.left;
this->right=node.right;
return *this;
}
/*----------------------------------------------------------------BinaryTree--------------------------------------------------------------------*/
template <typename T >
void BinaryTree < T > :: CreatTree(const T & ele,BinaryTree< T > &leftTree,BinaryTree < T > &rightTree)
{
root=new BinaryTreeNode < T > (v);
root->left=leftTree.root;
root->right=rightTree.root;
leftTree.root=rightTree.root=NULL;
}
template <typename T >
BinaryTreeNode < T > * BinaryTree < T > ::Serach(T v)
{
queue <BinaryTreeNode < T > *> q;
BinaryTreeNode < T > *curNode=root;
if (curNode)
q.push(curNode);
while (!q.empty())
{
curNode=q.front();
q.pop();
if (curNode->GetValue()==v)
return curNode;
if (curNode->GetLeftChild())
q.push(curNode->GetLeftChild());
if (curNode->GetRightChild())
q.push(curNode->GetRightChild());
}
return NULL;
}
template <typename T >
void BinaryTree < T > ::Insert(T v)
{
queue <BinaryTreeNode < T >* > q;
BinaryTreeNode < T > *newPointer,*p;
if(root==NULL)
{
root=new BinaryTreeNode < T >(v);
return ;
}
BinaryTreeNode < T > *pointer=root;
if (pointer!=NULL)
{
q.push(pointer);
}
while (!q.empty())
{
pointer=q.front();
q.pop();
p=this->Serach(v);
if (p!=NULL)
{
p->SetCounter();
return ;
}
if (pointer->GetLeftChild()!=NULL)
q.push(pointer->GetLeftChild());
else
{
newPointer=new BinaryTreeNode < T > (v);
pointer->SetLeftChild(newPointer);
return ;
}
if (pointer->GetRightChild()!=NULL)
q.push(pointer->GetRightChild());
else
{
newPointer=new BinaryTreeNode < T > (v);
pointer->SetRightChild(newPointer);
return ;
}
}
}
template <typename T >
BinaryTreeNode < T > * BinaryTree < T > ::GetRoot()
{
return root;
}
template <typename T >
T BinaryTree < T > ::Visit(BinaryTreeNode<T> *cur)
{
if (cur)
{
return cur->GetValue();
}
}
template <typename T >
void BinaryTree < T > ::PreOrder1(BinaryTreeNode<T> *root)
{
ofstream fout("output.txt",ios::app);
if (root!=NULL)
{
fout<<root->GetCounter()<<" ";
fout<<this->Visit(root)<<endl;
PreOrder1(root->GetLeftChild());
PreOrder1(root->GetRightChild());
}
}
template <typename T >
void BinaryTree < T > ::PreOrder(BinaryTreeNode<T> *root)
{
ofstream fout("output.txt",ios::app);
stack < BinaryTreeNode < T > *> s;
BinaryTreeNode < T > *curNode;
curNode=root;
if (curNode)
{
s.push(curNode);
}
while (!s.empty())
{
curNode =s.top();
fout<<curNode->GetCounter()<<" ";
fout<<this->Visit(curNode)<<endl;
s.pop();
if (curNode->GetRightChild())
s.push(curNode->GetRightChild());
if (curNode->GetLeftChild())
s.push(curNode->GetLeftChild());
}
}
template <typename T >
void BinaryTree < T > ::InOrder(BinaryTreeNode<T> *root)
{
ofstream fout("output.txt",ios::app);
stack < BinaryTreeNode < T >* > s;
BinaryTreeNode < T > *curNode;
if (root==NULL)
return ;
curNode=root;
while (curNode || !s.empty())
{
if (curNode )
{
s.push(curNode);
curNode=curNode->GetLeftChild();
}
else
{
curNode=s.top();
s.pop();
fout<<curNode->GetCounter()<<" ";
fout<<this->Visit(curNode)<<endl;
curNode=curNode->GetRightChild();
}
}
}
template <typename T >
void BinaryTree < T >::InOrder1(BinaryTreeNode<T> *root)
{
ofstream fout("output.txt",ios::app);
if (root!=NULL)
{
InOrder1(root->GetLeftChild());
fout<<root->GetCounter()<<" ";
fout<<this->Visit(root)<<endl;
InOrder1(root->GetRightChild());
}
}
enum Tags {left,right};
template <typename T >
struct NewBinaryTreeNode
{
BinaryTreeNode < T > *curNode;
Tags tag;
};
template <typename T >
void BinaryTree < T > ::PostOrder(BinaryTreeNode<T> *root)
{
ofstream fout("output.txt",ios::app);
stack < NewBinaryTreeNode < T > > s;
BinaryTreeNode < T > *curNode=root;
NewBinaryTreeNode < T > curNewNode;
while (!s.empty() || curNode )
{
while (curNode!=NULL)
{
curNewNode.curNode=curNode;
curNewNode.tag=(enum Tags) 0;
s.push(curNewNode);
curNode=curNode->GetLeftChild();
}
curNewNode=s.top();
s.pop();
curNode=curNewNode.curNode;
if (curNewNode.tag==(enum Tags) 0)
{
curNewNode.tag=(enum Tags) 1;
s.push(curNewNode);
curNode=curNode->GetRightChild();
}
else
{
fout<<curNode->GetCounter()<<" ";
fout<<this->Visit(curNode)<<endl;
curNode=NULL;
}
}
}
template <typename T >
void BinaryTree < T > ::PostOrder1(BinaryTreeNode<T> *root)
{
ofstream fout("output.txt",ios::app);
if (root!=NULL)
{
PostOrder1(root->GetLeftChild());
PostOrder1(root->GetRightChild());
fout<<root->GetCounter()<<" ";
fout<<this->Visit(root)<<endl;
}
}
template <typename T >
void BinaryTree < T > ::LeveOrder(BinaryTreeNode<T> *root)
{
ofstream fout("output.txt",ios::app);
queue <BinaryTreeNode < T > *> q;
BinaryTreeNode < T > *curNode=root;
if (curNode)
q.push(curNode);
while (!q.empty())
{
curNode=q.front();
q.pop();
fout<<curNode->GetCounter()<<" ";
fout<<this->Visit(curNode)<<endl;
if (curNode->GetLeftChild())
q.push(curNode->GetLeftChild());
if (curNode->GetRightChild())
q.push(curNode->GetRightChild());
}
}
template <typename T >
void BinaryTree < T > ::DeleteBinaryTree(BinaryTreeNode<T> *root)
{
queue <BinaryTreeNode < T > *> q;
BinaryTreeNode < T > *curNode=root;
if (curNode)
q.push(curNode);
while (!q.empty())
{
curNode=q.front();
q.pop();
cout<<curNode->GetCounter()<<" ";
cout<<this->Visit(curNode)<<endl;
if (curNode->GetLeftChild())
q.push(curNode->GetLeftChild());
if (curNode->GetRightChild())
q.push(curNode->GetRightChild());
delete curNode;
}
/*
if (root->GetLeftChild()==NULL && root->GetRightChild()==NULL)
{
root->~BinaryTreeNode();
}
else
{
if (root->GetLeftChild()!=NULL)
this->DeleteBinaryTree(root->GetLeftChild());
if (root->GetRightChild()!=NULL)
this->DeleteBinaryTree(root->GetRightChild());
}*/
}