二叉树的创建--（2）运算符重载<<、>>以及CreateBinaryTree、Traverse、PrintBTree函数

//operator >>
template <class T>
istream& operator>>(istream &is,BinaryTree<T> &tree)                               //重载操作，输入并建立一棵二叉树，is是输入流对象
{
    tree.CreateBinaryTree(is,tree);
    return is;

}


//operator <<
template <class T>
ostream&operator<<(ostream &os,BinaryTree<T> &tree)                              //重载操作，调用traverse前序遍历输出二叉树
{
    os<<"二叉树的前序遍历:"<<endl;
    tree.Traverse(tree.root,os);
    os<<endl;
    return os;
}

 <pre name="code" class="cpp">//CreateBinaryTree 以输入广义表的形式创建二叉树
template <class T>
void BinaryTree<T>::CreateBinaryTree(istream&is,BinaryTree<T> &BT)                //以输入广义表的方式表示要建立的二叉树
{
    stack<Node<T>*> s;
    BT.root=NULL;
    Node<T> *p,*t;
    int k=0;                                                                      //k作为处理左右子树标记
    cout<<"请按照广义表形式输入二叉树"<<endl;
    cout<<"注意：只有左子女或者右子女括号内逗号不能省略"<<endl;
    T ch;
    is>>ch;
    while(ch!=refvalue)                                                         //逐个字符处理
    {
        switch(ch)
        {
            case '(':s.push(p);k=1;break;  //遇到左括号将前一次创建的结点p压栈，k=1，标记即将输入的字符要连接于p的左子女
            case ')':t=s.top();s.pop();break; //遇到右括号，得到栈顶元素并退栈，实际上就是退出子树
            case ',':k=2;break;               //遇到逗号，k=2，标记即将输入的字符要连接于栈顶结点的右子女上
            default:p=new Node<T>(ch);            //创建结点保存输入的字符值
                  if(BT.root==NULL) BT.root=p;           //第一次输入，将BT保存树的根结点p
                  else if(k==1)
                        {
                            t=s.top();t->lchild=p;             //链接t的左子女
                        }
                  else if(k==2)
                  {
                      t=s.top();t->rchild=p;                   //链接t的右子女
                  }

        }
          is>>ch;
    }
}

 

//CreateBinaryTree  通过前序遍历输入创建二叉树，注意左或者右子树为空时，要输入refvalue作为终止符，都为空，则要输入两个refvalue
template <class T>
void BinaryTree<T>::CreateBinaryTree(istream&is,Node<T> *&subtree)
//私有函数，以递归方式建立二叉树
{
    T item;
    if(!is.eof())                       //未读完，输入流仍有值，继续读入并建树
    {
        is>>item;
        if(item!=refvalue)                  //输入的不是终止标记
        {
            subtree=new Node<T>(item);      //新建根节点，并赋入刚刚输入的数据
            if(subtree==NULL)
            {
                cerr<<"存储分配错！"<<endl;          //分配失败，异常退出
            }
            CreateBinaryTree(is,subtree->lchild);         //递归建立左子树
            CreateBinaryTree(is,subtree->rchild);         //递归建立右子树
        }
    }
}


//Traverse 前序遍历输出二叉树
template <class T>bool BinaryTree<T>::Traverse(Node<T>* subtree,ostream &os) //从subtree结点开始，前序遍历并输出
{ 
   if(subtree!=NULL) 
  { 
      os<<subtree->data<<" "; 
      Traverse(subtree->lchild,os);
     Traverse(subtree->rchild,os);
  }
 return true;
}

//PrintBTree 以广义表的形式输出二叉树
template <class T>
void PrintBTree(Node<T> *BT)
//以广义表的形式输出二叉树
{
    if(BT!=NULL)                                     //树为空时结束递归
    {
        cout<<BT->data;                              //输出根结点数据
        if(BT->lchild!=NULL||BT->rchild!=NULL)       //根结点子树不全为空
        {
            cout<<"(";
            PrintBTree(BT->lchild);                  //递归输出左子树
            cout<<",";
            PrintBTree(BT->rchild);                  //递归输出右子树
            cout<<")";
        }
    }
}