C++ 从前序数组和顺序数组构造bst时出现错误 #包括 使用名称空间std； #定义是1 #定义0 类树 { 私人： 结构叶 { int数据； 叶*1； 叶*r； }; 结构叶*p； 公众： 树（）； ~tree（）； 空洞破坏（叶*q）； tree（tree&a）； void findparent（int n，int&found，leaf*&父项）； void findfordel（int n，int&found，leaf*&父，leaf*&x）； 无效添加（int n）； 空隙横向（）； 叶片中的空隙（叶*q）； 预空（叶*q）； 空柱（叶*q）； void del（int n）； leaf*&创建bst（int*前序，int*内序，int len）； }; tree:：tree（） { p=零； } 树：：~tree（） { 破坏（p）； } 无效树：：析构函数（叶*q） { 如果（q！=NULL） { 自毁（q->l）； del（q->data）； 自毁（q->r）； } } void树：：findparent（int n，int&found，leaf*&父） { 叶*q； 发现=否； parent=NULL； if（p==NULL） 返回； q=p； while（q！=NULL） { 如果（q->data==n） { 发现=是； 返回； } 如果（q->data>n） { 父母=q； q=q->l； } 其他的 { 父母=q； q=q->r； } } } 无效树：：添加（int n） { int-found； 叶*t，*亲本； findparent（n，已找到，父级）； 如果（找到==是） coutl=NULL； t->r=NULL； 如果（父项==NULL） p=t； 其他的 父级->数据->n？父级->l=t:父级->r=t； } } void树：：横向（） { INTC； coutc； 开关（c） { 案例1： in（p）； 打破 案例2： pre（p）； 打破 案例3： 员额（p）； 打破 } } 空树：：in（叶*q） { 如果（q！=NULL） { in（q->l）； coutr==NULL） { 如果（父->r==x） 父->r=NULL； 其他的 父->l=NULL； 删除x； 返回； } //如果节点只有右叶 如果（x->l==NULL&&x->r！=NULL） { 如果（父->l==x） 父->l=x->r； 其他的 父->r=x->r； 删除x； 返回； } //如果要删除的节点只剩下子节点 如果（x->l！=NULL&&x->r==NULL） { 如果（父->l==x） 父->l=x->l； 其他的 父->r=x->l； 删除x； 返回； } } 叶*&树：：createBST（int*preOrder，int*inoorder，int len） { int i； bst=新叶； //树bst； if（lendata=*预订单； 对于（i=0；il=createBST（预订单+1，顺序，i）； bst->r=createBST（前序+i+1，顺序+i+1，len-i-1）； 返回bst； } int main（） { /*树t； int data[]={32,16,34,1,87,13,7,18,14,19,23,24,41,5,53}； 对于（int-iter=0；iter

改变这一点：

#include <iostream>

using namespace std;

#define YES 1
#define NO 0

class tree
{
    private:
        struct leaf
        {
            int data;
            leaf *l;
            leaf *r;
        };
        struct leaf *p;

    public:
        tree();
        ~tree();
        void destruct(leaf *q);
        tree(tree& a);
        void findparent(int n,int &found,leaf* &parent);
        void findfordel(int n,int &found,leaf *&parent,leaf* &x);
        void add(int n);
        void transverse();
        void in(leaf *q);
        void pre(leaf *q);
        void post(leaf *q);
        void del(int n);
        leaf*&  createBST(int *preOrder, int* inOrder, int len);

};

tree::tree()
{
    p=NULL;
}

tree::~tree()
{
    destruct(p);
}

void tree::destruct(leaf *q)
{
    if(q!=NULL)
    {
        destruct(q->l);
        del(q->data);
        destruct(q->r);
    }
}
void tree::findparent(int n,int &found,leaf *&parent)
{
    leaf *q;
    found=NO;
    parent=NULL;

    if(p==NULL)
        return;

    q=p;
    while(q!=NULL)
    {
        if(q->data==n)
        {
            found=YES;
            return;
        }
        if(q->data>n)
        {
            parent=q;
            q=q->l;
        }
        else
        {
            parent=q;
            q=q->r;
        }
    }
}

void tree::add(int n)
{
    int found;
    leaf *t,*parent;
    findparent(n,found,parent);
    if(found==YES)
        cout<<"\nSuch a Node Exists";
    else
    {
        t=new leaf;
        t->data=n;
        t->l=NULL;
        t->r=NULL;

        if(parent==NULL)
            p=t;
        else
            parent->data > n ? parent->l=t : parent->r=t;
    }
}

void tree::transverse()
{
    int c;
    cout<<"\n1.InOrder\n2.Preorder\n3.Postorder\nChoice: ";
    cin>>c;
    switch(c)
    {
        case 1:
            in(p);
            break;

        case 2:
            pre(p);
            break;

        case 3:
            post(p);
            break;
    }
}

void tree::in(leaf *q)
{
    if(q!=NULL)
    {
        in(q->l);
        cout<<"\t"<<q->data<<endl;
        in(q->r);
    }

}

void tree::pre(leaf *q)
{
    if(q!=NULL)
    {
        cout<<"\t"<<q->data<<endl;
        pre(q->l);
        pre(q->r);
    }

}

void tree::post(leaf *q)
{
    if(q!=NULL)
    {
        post(q->l);
        post(q->r);
        cout<<"\t"<<q->data<<endl;
    }

}

void tree::findfordel(int n,int &found,leaf *&parent,leaf *&x)
{
    leaf *q;
    found=0;
    parent=NULL;
    if(p==NULL)
        return;

    q=p;
    while(q!=NULL)
    {
        if(q->data==n)
        {
            found=1;
            x=q;
            return;
        }
        if(q->data>n)
        {
            parent=q;
            q=q->l;
        }
        else
        {
            parent=q;
            q=q->r;
        }
    }
}

void tree::del(int num)
{
    leaf *parent,*x,*xsucc;
    int found;

    // If EMPTY TREE
    if(p==NULL)
    {
        cout<<"\nTree is Empty";
        return;
    }
    parent=x=NULL;
    findfordel(num,found,parent,x);
    if(found==0)
    {
        cout<<"\nNode to be deleted NOT FOUND";
        return;
    }

    // If the node to be deleted has 2 leaves
    if(x->l != NULL && x->r != NULL)
    {
        parent=x;
        xsucc=x->r;

        while(xsucc->l != NULL)
        {
            parent=xsucc;
            xsucc=xsucc->l;
        }
        x->data=xsucc->data;
        x=xsucc;
    }

    // if the node to be deleted has no child
    if(x->l == NULL && x->r == NULL)
    {
        if(parent->r == x)
            parent->r=NULL;
        else
            parent->l=NULL;

        delete x;
        return;
    }

    // if node has only right leaf
    if(x->l == NULL && x->r != NULL )
    {
        if(parent->l == x)
            parent->l=x->r;
        else
            parent->r=x->r;

        delete x;
        return;
    }

    // if node to be deleted has only left child
    if(x->l != NULL && x->r == NULL)
    {
        if(parent->l == x)
            parent->l=x->l;
        else
            parent->r=x->l;

        delete x;
        return;
    }
}


leaf*& tree::createBST(int *preOrder, int* inOrder, int len)
{
    int i;
    bst = new leaf;
//  tree bst;
    if(len < 0)
        return bst;

    bst->data = *preOrder;
    for(i = 0; i < len; i++)
        if(*(inOrder + i) == *preOrder)
        break;
    bst->l = createBST(preOrder + 1, inOrder, i);
    bst->r = createBST(preOrder + i +1, inOrder + i + 1, len-i-1);
    return bst;

}

int main()
{
/*  tree t;
    int data[]={32,16,34,1,87,13,7,18,14,19,23,24,41,5,53};
    for (int iter=0; iter<15; iter++)
    {
        t.add(data[iter]);
    }
    t.transverse();
    t.del(16);
    t.transverse();
    tdel(41);
    t.tranverse();
*/  

    tree bst;
    int pre_data[] = {20,8,4,12,10,14,22};
    int in_data[] = {4,8,10,12,14,20,22};
    bst.createBST(pre_data, in_data, 7);
    bst.transverse();

    return 0;
}

为此：

leaf*& tree::createBST(int *preOrder, int* inOrder, int len)

---

祝你好运。

使用@ybungalobill更正，你也应该这样做以避免语法错误-

tree::leaf*& tree::createBST(int *preOrder, int* inOrder, int len)

---

谢谢。编译现在很好。但是当我输出这棵树时。什么都没有。我想我需要创建一个新问题。@user658266:一旦进入类范围，

tree:：

就不是必需的。但是为了增加可读性，可以放置它。为什么createBST返回指针的引用？为什么不返回指针呢？

tree::leaf*& tree::createBST(int *preOrder, int* inOrder, int len)
{
    tree::leaf *bst = new tree::leaf;
    // ...

}