二叉树

#include <iostream>
using namespace std;
//类BinTreeNode定义
template <class Type>
class BinTreeNode
{
public :
 BinTreeNode(void);
 BinTreeNode(Type item,BinTreeNode<Type>* left,BinTreeNode<Type>* right);
 Type GetData(void) const ;
 BinTreeNode<Type>* GetLeft(void)const ;
 BinTreeNode<Type>* GetRight(void)const ;
 void setData(const Type& item);
 void setLeft(const BinTreeNode<Type>& L);
 void setRight(const BinTreeNode<Type>& R);
 
private :
 BinTreeNode <Type> * LeftChild,* RightChild;
 Type data;
};
//类BinaryTree定义
template <class Type>
class BinaryTree
{
public :
 BinaryTree();
 BinaryTree(Type value);
 BinaryTree(BinaryTree<Type> &s);
 ~BinaryTree(void);
 bool IsEmpty(void);
 BinTreeNode<Type>* Parent(BinTreeNode<Type>* current);
 BinTreeNode<Type>* LeftChild(BinTreeNode<Type>* current);
 BinTreeNode<Type>* RightChild(BinTreeNode<Type>* current);
 void Insert(const Type& item);
 BinTreeNode<Type>* Find(const Type& item);
 const BinTreeNode<Type>* GetRoot (void) const;
 friend istream& operator >> (istream& in ,BinTreeNode<Type>& Tree);
 friend ostream& operator << (ostream& out,BinTreeNode<Type>& Tree);
private :
 BinTreeNode<Type>* root;
 Type RefValue;
 BinTreeNode<Type>* Parent(BinTreeNode<Type>* start,BinTreeNode<Type>* current);
 void Traverse(BinTreeNode<Type>* current,ostream& out) const ;
 void Destroy(BinTreeNode<Type>* current);
 void Insert(const Type& item,BinTreeNode<Type>* & current);
 BinTreeNode<Type>* Find(BinTreeNode<Type>* current,const Type* item) const;
};

//类BinTreeNode实现
template <class Type>
BinTreeNode<Type>::BinTreeNode():LeftChild(NULL),RigthChild(NULL)
{}

template <class Type>
BinTreeNode<Type>::BinTreeNode(Type item, BinTreeNode<Type> *left, BinTreeNode<Type> *right):
data(item),LeftChild(left),RightChild(right)
{}

template <class Type>
Type BinTreeNode<Type>::GetData(void) const
{
 return this->data;
}

template <class Type>
BinTreeNode<Type>* BinTreeNode<Type>::GetLeft(void) const
{
 return this->LeftChild;
}

template <class Type>
BinTreeNode<Type>* BinTreeNode<Type>::GetRight(void) const
{
 return this->RightChild;
}

template <class Type>
void BinTreeNode<Type>::setData(const Type &item)
{
 data = item;
}

template <class Type>
void BinTreeNode<Type>::setLeft(const BinTreeNode<Type>& L)
{
 LeftChild = L;
}

template <class Type>
void BinTreeNode<Type>::setRight(const BinTreeNode<Type>& R)
{
 RightChild = R;
}

//类BinaryTree实现；
template <class Type>
BinaryTree<Type>::BinaryTree()
{
 root = NULL;
}

template <class Type>
BinaryTree<Type>::BinaryTree(Type value):root(NULL),RefValue(value)
{}

template <class Type>
BinaryTree<Type>::~BinaryTree()
{
 Destroy(root);
}

template <class Type>
bool BinaryTree<Type>::IsEmpty(void)
{
 return root == NULL;
}

template <class Type>
BinTreeNode<Type>* BinaryTree<Type>::Parent(BinTreeNode<Type>* current)
{
 return (root==NULL||root==current)?NULL:current->Parent(root,current);
}

template <class Type>
BinTreeNode<Type>* BinaryTree<Type>::LeftChild(BinTreeNode<Type>* current)
{
 return (current!=NULL)?current->LeftChild:NULL;
}

template <class Type>
BinTreeNode<Type>* BinaryTree<Type>::RightChild(BinTreeNode<Type>* current)
{
 return (current!=NULL)?current->RightChild:NULL;
}

template <class Type>
void BinaryTree<Type>::Insert(const Type& item)
{
 Insert(root,item);
}

template <class Type>
BinTreeNode<Type>* BinaryTree<Type>::Find(const Type& item)
{
 return Find(root,item);
}

template <class Type>
const BinTreeNode<Type>* BinaryTree<Type>::GetRoot (void) const
{
 return root;
}
//BinaryTree的私有函数实现
template <class Type>
BinTreeNode<Type>* BinaryTree<Type>::Parent(BinTreeNode<Type> *start, BinTreeNode<Type> *current)
{
 if (start == NULL)
 {
  return NULL;
 }
 if (start->GetLeft() == current || start->GetRight() == current)
 {
  return start;
 }
 if (Parent(start->GetLeft(),current) != NULL)
 {
  return Parent(start->GetLeft(),current);
 }
 else
 {
  return Parent(start->GetRight,current);
 }
}

template <class Type>
void BinaryTree<Type>::Destroy(BinTreeNode<Type> *current)
{
 if (current != NULL)
 {
  Destroy(current->GetLeft());
  Destroy(current->GetRight());
  delete current;
 }
}

template <class Type>
void BinaryTree<Type>::Traverse(BinTreeNode<Type> *current, std::ostream &out) const
{
 if (current != NULL)
 {
  out<<current->GetData()<<' ';
  Traverse(current->GetLeft(),out);
  Traverse(current->GetRight(),out);
 }
}

template <class Type>
BinTreeNode<Type>* BinaryTree<Type>::Find(BinTreeNode<Type> *current, const Type *item) const
{
 if (current == NULL)
 {
  return NULL;
 }
 if (item != current->GetData())
 {
  if (!Find(current->GetLeft(),item))
  {
   return Find(current->GetLeft(),item);
  }
  else
  {
   return Find(current->GetRight(),item);
  }
 }
 else
 {
  return current;
 }
}

template <class Type>
void BinaryTree<Type>::Insert(const Type& item,BinTreeNode<Type>* & current)
{
 if (current == NULL)
 {
  current = new BinTreeNode<Type>(item);
 }
 else
 {
  if (item < current->GetData)
  {
   Insert(current->GetLeft(),item);
  }
  else
  {
   Insert(current->GetRight(),item);
  }
 }
}

//BinaryTree的友元函数实现；
template <class Type>
istream& operator >> (istream& in ,BinaryTree<Type>& Tree)
{
 Type item;
 cout<<"Construct binary tree:\n";
 cout<<"Input data (end with:"<<Tree.RefValue<<"):";
 cin>>item;
 while(item != Tree.RefValue)
 {
  Tree.Insert(item);
  cout<<"Input data (end with"<<Tree.RefValue<<"(::";
  cin>>item;
 }
 return in;
}

template <class Type>
ostream& operator << (ostream& out,BinaryTree<Type>& Tree)
{
 out<<"Preorder travesal of binary tree.\n";
 Tree.Traverse(Tree.root,out);
 out<<endl;
 return out;
}
void main()
{
 cout<<"flsafdsafasdds\n";
}

 

 

================================================================

 

#include <iostream>
using namespace std;
//类BinTreeNode定义
template <class T>
struct BinTreeNode
{
 T data;
 BinTreeNode <T> * leftChild,* rightChild;
 BinTreeNode():leftChild(NULL),rightChild(NULL){}
 BinTreeNode(T x,BinTreeNode<T>* left=NULL,BinTreeNode<T>* right=NULL):data(x),legtChild(left),rightChild(right){};
};
template<class T>
class BinaryTree
{
 protected:
  BinTreeNode <T> *root;
  T RefValue;
  
 public:
  BinaryTree():root(NULL){}
  BinaryTree(T value):RefValue(value),root(NULL){}
  BinaryTree(BinaryTree<T>&s);
 // ~BinaryTree{void destroy(root);}
  
  void CreatBintree(istream& in,BinTreeNode<T>*&subTree);
  void destroy(BinaryTree<T> * &subTree);
  bool IsEmpty(){return(root==NULL)?true:false;}

  BinTreeNode<T> * Parent(BinTreeNode<T>*subTree,BinTreeNode<T> *current);
  BinTreeNode<T> * LeftChild(BinTreeNode<T>*current){return (current!=NULL)?current->leftChild:NULL;}
  BinTreeNode<T> * RightChild(BinTreeNode<T>*current){return (current!=NULL)?current->rightChild:NULL;}

  int Height(BinTreeNode<T> *subTree);
  int Size(BinTreeNode<T> *subTree);

};
//实现
template<class T>
void BinaryTree<T>::CreatBintree(istream& in,BinTreeNode<T>*&subTree)
{
 BinaryTree<T> *s[80];//s数组作为存储二叉树中根结点指针的栈
 int top=-1;      //top作为s栈的栈顶指针
 left=NULL;       //先将left作为树根指针给予置空
 BinaryTree<T> *p=NULL;//定义p为指向二叉树结点的指针
 //用k作为处理结点的左子树和右子树的标记,k=1处理左子树,k=2处理右子树
 int k;
 istrstream ins(a);//把字符串a定义为输入字符串流对象ins
 char ch;
 ins>>ch;//从ins流对象顺序读入一个字符，
 while (ch!='@')
 {//每循环一次处理一个读入的字符,直到扫描到'@'字符为止
  switch(ch)
  {case '(':top++;s[top]=p;k=1;break;
  case ')':top--;break;
  case ',':top++;k=2;break;
  default:p=new BTree<T>;
   p->data=ch;p->left=p->right=NULL;
   cout<<setw(2)<<p->data;
   if(left==NULL) left=p;
   else {
    if(k==1) s[top]->left=p;
    else s[top]->right=p;
   }
  }
  ins>>ch;
 }
}
/*
template<class T>
void BinaryTree<T>::destroy(BinaryTree<T> *subTree)
{
 if (subTree != NULL)
 {
  destroy(subTree->GetLeft());
  destroy(subTree->GetRight());
  delete subTree;
 }
}
*/
void main()
{
 BinaryTree<char> tree;
 cout<<"lakf";
}