-----BST类模版----求助啊

来源：互联网发布：下载windows 编辑：程序博客网时间：2024/06/10 04:28

下面是自己归纳写了个BST树
//----BST二叉树.h
//----------------BST类模版----------------

//****************************************************************

#ifndef BINARY_SEARCH_TREE
#define BINARY_SEARCH_TREE
#include <iostream>
using namespace std;
template<class DataType>
class BST
{
    private:
        /******节点结构******/
        class BInNode
        {
        public:
            DataType data;
            BInNode *left,
                *right;
            /********构造函数*******/
            BInNode()
            {
                left=right=0;
            }
            BInNode(DataType item)
            {
                data=item;
                left=right=0;
            }
        };
        typedef BInNode *BinNodePointer;
        public:
            BST();         //--------构造函数
            bool Empty()const;//------判空树
            bool Search(const DataType &item)const;//----查找
            void Insert(const DataType &item);//------插入
            void InOrder(ostream &out);         //--------中序遍例
            void InOrderAux(ostream &out,BinNodePointer ptr);//-------中序遍例
            bool Search1(const DataType &item);//--------递归查找
            bool SearchAux(BinNodePointer locptr,const DataType &item);//---------递归查找
            void Insert1(const DataType &item);//--------递归插入
            void InsertAux(BinNodePointer locptr,const DataType &item);//--------递归插入
            void Delete(const DataType &item);//--------------删除节点
            void Search2(const DataType &item,bool &found,
                BinNodePointer &locptr,BinNodePointer &parent);//-------找出包含项的节点及其父节点
            void Delete2(const DataType &item);//-----------删除节点递归版本
            void DeleteAux(const DataType &item,BinNodePointer &root);//-------辅助函数

        private:
            BinNodePointer root;

};
//-----构造函数
template<class DataType>
inline BST<DataType>::BST()
{
    root=0;
}
//----empty()定义
template<class DataType>
inline bool BST<DataType>::Empty()const
{
    return root=0;
}
//-------------查找
template<class DataType>
bool BST<DataType>::Search(const DataType &item)const
{
    bool found=false;
    BinNodePointer locptr=root;
    for(;;)
    {
        if(found||locptr==0)break;
        if(item<locptr->data)
            locptr=locptr->left;
        else if(item>locptr->data)
            locptr=locptr->right;
        else
            found=true;
    }
    return found;
}
//-----------插入
template<class DataType>
void BST<DataType>::Insert(const DataType &item)
{
    BinNodePointer
        locptr=root,
        parent=0;
    bool found=false;
    for(;;)
    {
        if(found||locptr==0)break;
        parent=locptr;//--------使用parent来记录当前所在查找的节点
        if(item<locptr->data)
            locptr=locptr->left;
        else
            if(item>locptr->data)
                locptr=locptr->right;
            else
                found=true;
    }
    if(found)
        cerr<<"Item已经在这个树中了/n";
    else
    {
        locptr=new BInNode(item);//------这一步操作将item放入节点类locptr中
        if(parent==0)//--------如果没有节点那么查入的节点就是根节点
            root=locptr;
        else
            if(item<parent->data)
                parent->left=locptr;
            else
                parent->right=locptr;

    }
}
//------中序遍例定义
template<class DataType>
void BST<DataType>::InOrder(ostream &out)
{
    InOrderAux(out,root);
}
//-------InorderAux()定义
template<class DataType>
void BST<DataType>::InOrderAux(ostream &out,BinNodePointer ptr)
{
    if(ptr!=0)
    {
        InOrderAux(out,ptr->left);
        out<<ptr->data<<" ";
        InOrderAux(out,ptr->right);
    }
}
//-------Search1()定义
template<class DataType>
bool BST<DataType>::Search1(const DataType &item)
{
    return SearchAux(root,item);
}
//----------SearchAux()定义
template<class DataType>
bool BST<DataType>::SearchAux(BinNodePointer locptr,const DataType &item)
{
    if(locptr=0)
        return false;
    if(item<locptr->data)
        return SearchAux(locptr->left,item);
    else if(item>locptr->data)
        return SearchAux(locptr->right,item);
    else
        return true;
}
//-------------Insert1()定义
template<class DataType>
void Insert1(const DataType &item)
{
    InsertAux(root,item);
}
//-------------InsertAux()定义
template<class DataType>
void BST<DataType>::InsertAux(BinNodePointer locptr,const DataType &item)
{
    if(locptr==0)
        locptr=new BInNode(item);
    if(item<locptr->data)
        InsertAux(locptr->left,item);
    else if(item>locptr->data)
        InsertAux(locptr->right,item);
    else cerr<<"Item 已经在树中了/n";
}
//-------Delete()定义
template<class DataType>
void BST<DataType>::Delete(const DataType & item)
{
    bool found;
    BinNodePointer x,
        parent;
    Search2(item,found,x,parent);
    if(!found)
    {
        cerr<<"要查找的节点不在树中/n";
    }
    //else
    if(x->left!=0&&x->right!=0)
    {
        //寻找X中序后继的前驱
        BinNodePointer xsucc=x->right;
        parent=x;
        while(xsucc->left!=0)
        {
            parent =xsucc;
            xsucc=xsucc->left;
        }
        //把xsucc的内容一到X，并令X指向后继，该后继将被删除
        x->data=xsucc->data;
        x=xsucc;
    }
    //处理节点只有0和1个儿子的情况
    BinNodePointer subtree=x->left;
    if(subtree==0)
        subtree=x->right;
    if(parent==0)
        root=subtree;
    else if(parent->left==x)
        parent ->left=subtree;
    else
        parent->right=subtree;
    delete x;

}
//--------search2()定义
template<typename DataType>
void BST<DataType>::
Search2(const DataType &item,bool &found,
        BinNodePointer &locptr,BinNodePointer &parent)
{
    locptr=root;
    parent=0;
    found =false;
    for(;;)
    {
        if(found||locptr==0)return;
        if(item<locptr->data)
        {
            parent=locptr;
            locptr=locptr->left;
        }
        else
            if(item>locptr->data)
            {
                parent=locptr;
                locptr=locptr->right;
            }
            else
                found=true;
    }

}
//---------delete2()定义
template<class DataType>
void BST<DataType>::Delete2(const DataType &item)
{
    DeleteAux(root,item);

}
//辅助函数DeleteAux()定义
template<class DataType>
void BST<DataType>::DeleteAux(const DataType &item,
                              BinNodePointer &root)
{
    if(locptr==0)
    {
        cerr<<"Item not in the BST/n";
        return;
    }
    //否则递归查找包含项的节点并且删除他
    if(item<root->data)
        DeleteAux(item,root->left);
    else if(item>root->data)
        DeleteAux(item,root->right);
    else
    {
        BinNodePointer ptr;
        if(root->left==0)
        {
            ptr=root->right;
            delete root;
            root=ptr;
        }
        else
            if(root->right==0)
            {
                ptr=root->left;
                delete root;
                root=ptr;
            }
            else
            {
                //寻找中序遍例
                ptr=root->right;
                while(ptr->left!=0)
                    ptr=ptr->left;
                //把后继的内容依到当前子树的根，然后删除该后继节点
                root->data=ptr->data;
                DeleteAux(ptr->data,root->right);
            }

    }
}

#endif
自己上机编译发现错误百出
下面是在写的一个测试程序

#include<iostream>
#include<fstream>
#include<string>
#include"BST二叉树.h"
using namespace std;
/*程序对计算机用户标识和密码进行验证，合法的标识和密码从UserFile中读取并

  存放在一棵BST二叉树中，之后，当用户标识和密码被输入时，程序查找这棵BST

  来确定该用户是否合法


  *输入（文件）：合法用户USerInfo的记录

  *输入（键盘）：用户登陆时的标识和密码

  *输出（屏幕）：用户标识和密码是否合法的信息

**************************************************************************/

/*----------包含用户信息的类-----------*/
//含有操作符>>,==,<
struct UserInfo
{
public:
    /*****函数成员和友好成员****/
    //---------输入操作符
    friend istream &operator>>(istream &in,UserInfo &user);
    //----------等于操作符
    bool operator==(const UserInfo &user)
    {
        return ((myid==user.myid)&&(mypassword==user.mypassword));
    }
    //----------小于操作符
    bool operator<(const UserInfo &user)
    {
        return myid<user.myid;
    }
    //---------大于操作符
    bool operator>(const UserInfo &user)
    {
        return myid>user.myid;
    }
    /*********数据成员**********/
    string myid,mypassword;

};
//---输入操作符
istream &operator>>(istream &in,UserInfo &user)
{
    in>>user.myid>>user.mypassword;
    return in;
}
//-----------------------------------------------------------------
int main()
{
    //打开合法的用户标识和密码文件
    ifstream userFile("UserFile");
    if(!userFile.is_open())
    {
        cerr<<"cannot open UserFile/n";
        exit(-1);
    }
    //构造用户记录BST
    BST<UserInfo> userTree;        //用户记录BST
    UserInfo user;
    for(;;)
    {
        userFile>>user;
        if(userFile.eof())break;
        userTree.Insert(user);
    }
    //登陆验证
    cout<<"Enter Q Q to stop processing./n";
    for(;;)
    {
        cout<<"/n输入用户 id和password:";
        cin>>user;
        if(user.myid=="Q")break;
        if(userTree.Search(user))
            cout<<"有效的使用者/n";
        else
            cout<<"不是一个有效的使用者/n";
    }
    return 0;
}

偶是初学者主要是为了学习

所以用了普通和递归两种形式写的
那位大虾帮我编译一下
特别是C2061和C2593这两个错误
怎么还回出现这样的错误的
error C2593: 'operator >>' is ambiguous
error C2061: syntax error : identifier 'ostream'
自己明明做的很好
重载也是友员函数为什么还提示不能访问私有成员
昨天也遇到这样的问题

在VCHELP上面问了几位大虾他们也被搞混了

错误很多都出在.h文件里面小弟是自学没人教求教这里的哥哥姐姐了