二叉树（上机作业版）

#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());

 }*/

}