旭辉夜夜访 2022-05-08 02:18 采纳率: 100%
浏览 27
已结题

C++二叉树遍历函数不接受参数

我的三个遍历函数都不接受参数,我尝试了修改,但是没能成功。
我该如何改正。

img


```c++
#include<iostream>
using namespace std;
const int Maxsize = 100;
template <class T>
struct BiNode
{
    T data;
    BiNode *lchild;
    BiNode* rchild;
};
template<class T>
class BiTree
{
public:
    BiTree() { r = Creat(); }   //构造函数,建立一棵二叉树
    ~BiTree() { Release(r); }  //析构函数,释放各结点的内存空间
    void CreatBTNode(char* str);
    void PreOrder() { PreOrder(r); }       //先序遍历
    void InOrder() { InOrder(r); }       //中序遍历
    void PostOrder() { PostOrder(r); }     //后序遍历
    void DispBiNode();                            //将二叉链转换成括号表示法
private:
    BiNode<T>* Creat();          //构造函数调用
    void Release(BiNode<T>* bt);  //析构函数调用
    friend void PreOrder(BiNode<T>* bt);   //先序遍历函数调用
    friend void InOrder(BiNode<T>* bt);    //中序遍历函数调用
    friend void PostOrder(BiNode<T>* bt);  //后序遍历函数调用
    friend void DispBiNode(BiNode<T>* bt);                //被DispBiNode函数调用
    BiNode<T>* r;       //指向根结点的头指针
};

template<class T>
BiNode<T>* BiTree<T>::Creat()   //构造函数实现
{
    BiNode<T>* bt;
    char ch;
    cin >> ch;         //输入结点数据信息,设定为字符
    if (ch == '#') bt = NULL;     //建立一颗空树
    else {
        bt = new BiNode<T>;
        bt->data = ch;
        bt->lchild = Creat();
        bt->rchild = Creat();
    }
}

template<class T>
void BiTree<T>::Release(BiNode<T>* bt)         //析构函数实现
{
    if (bt == NULL) return;
    else {
        Release(bt->lchild);      //释放左子树
        Release(bt->rchild);     //释放右子树
        delete bt;               //释放根结点
    }
}

template <class T>
void BiTree<T>::CreatBTNode(char* str)    //创建以r为根结点的二叉链存储结构
{
    BiNode<T>* St[Maxsize];        //建立一个顺序栈
    BiNode<T>* p;
    int top = -1, k = 0, j = 0;
    char ch;
    while (str[j] != '\0')        //循环扫描str中每个字符
    {
        ch = str[j];
        switch (ch)
        {
        case '(':top++; St[top] = p; k = 1; break;    //新建结点有孩子,将其进栈
        case ')':top--; break;
        case ',':k = 2; break;                    //开始处理右孩子结点
        default: p = new BiNode<T>();                //新建一个结点
            p->lchild = p->rchild = NULL;
            p->data = ch;
            if (r == NULL) r = p;                    //若未建立根结点,*p作为根结点
            else                                //已建立二叉树根结点
            {
                switch (k)
                {
                case 1:St[top]->lchild = p; break;//新建结点作为栈顶结点的左孩子
                case 2:St[top]->rchild = p; break;//新建结点作为栈顶结点的右孩子
                }
            }
            break;
        }
        j++;                    //继续遍历其他字符
    }
}

template<class T>
void PreOrder(BiNode<T>* bt)       //前序遍历函数实现
{
    if (bt == NULL) return;       //递归调用的结束条件
    else {
        cout << bt->data << "\t";        //访问根结点bt的数据域
        PreOrder(bt->lchild);            //前序递归遍历bt的左子树
        PreOrder(bt->rchild);            //前序递归遍历bt的右子树
    }
}

template<class T>
void InOrder(BiNode<T>* bt)    //中序遍历函数实现
{
    if (bt == NULL) return;       //递归调用的结束条件
    else {
        InOrder(bt->lchild);            //中序递归遍历bt的左子树
        cout << bt->data << "\t";        //访问根结点bt的数据域
        InOrder(bt->rchild);            //中序递归遍历bt的右子树
    }
}

template<class T>             //后序遍历函数实现
void PostOrder(BiNode<T>* bt)    //中序遍历函数实现
{
    if (bt == NULL) return;       //递归调用的结束条件
    else {
        PostOrder(bt->lchild);             //后序递归遍历bt的左子树
        PostOrder(bt->rchild);            //后序递归遍历bt的右子树
        cout << bt->data << "\t";        //访问根结点bt的数据域
    }
}

template <typename T>
void BiTree<T>::DispBiNode()    //将二叉链转换成括号表示法
{
    DispBiNode(r);
}

template <typename T>
void DispBiNode(BiNode<T>* bt)    //被DispBiNode函数调用
{
    if (bt != NULL)
    {
        cout << bt->data;            //输出根结点值
        if (bt->lchild != NULL || bt->rchild != NULL)
        {
            cout << "(";            //有孩子结点时输出"("
            DispBiNode(bt->lchild);    //递归输出左子树
            if (bt->rchild != NULL)
                cout << ",";        //有右孩子结点时输出","
            DispBiNode(bt->rchild);    //递归输出右子树
            cout << ")";            //输出")"
        }
    }
}

int main()
{
    char str1[]="A(B(D(,G)),C(E,F))";
    char* str = str1;       
    BiTree<char> T{};
    T.CreatBTNode(str);     //创建二叉链存储结构
    cout << "二叉树bt:"; T.DispBiNode(); cout << endl;
    cout << "前序遍历结果:" << endl;
    T.PreOrder();           //前序递归遍历函数调用
    cout << "中序遍历结果:" << endl;
    T.InOrder();            //中序递归遍历函数调用
    cout << "后序遍历结果:" << endl;
    T.PostOrder();          //后序递归遍历函数调用
    T.~BiTree();            //析构函数调用,释放空间
    return 0;
}


```

  • 写回答

1条回答 默认 最新

  • 旭辉夜夜访 2022-05-08 14:50
    关注

    经过学习,我已经修改成功,修改后代码如下

    #include<iostream>
    using namespace std;
    const int Maxsize = 100;
    template <class T>
    struct BiNode
    {
        T data;
        BiNode* lchild;
        BiNode* rchild;
    };
    template<class T>
    class BiTree
    {
    public:
        BiTree();   //构造函数,建立一棵二叉树
        ~BiTree() { Release(r); }  //析构函数,释放各结点的内存空间
        void CreatBTNode(char* str);
        void PreOrder() { PreOrder(r); }       //先序遍历
        void InOrder() { InOrder(r); }       //中序遍历
        void PostOrder() { PostOrder(r); }     //后序遍历
        void DispBiNode() { DispBiNode(r); };    //将二叉链转换成括号表示法
    private:
        
        void Release(BiNode<T>* bt);  //析构函数调用
        void PreOrder(BiNode<T>* bt);   //先序遍历函数调用
        void InOrder(BiNode<T>* bt);    //中序遍历函数调用
        void PostOrder(BiNode<T>* bt);  //后序遍历函数调用
        void DispBiNode(BiNode<T>* bt);                //被DispBiNode函数调用
        BiNode<T>* r;       //指向根结点的头指针
    };
    
    template<class T>
    BiTree<T>::BiTree()   //构造函数实现
    {
        r = NULL;
    }
    
    template<class T>
    void BiTree<T>::Release(BiNode<T>* bt)         //析构函数实现
    {
        if (bt == NULL) return;
        else {
            Release(bt->lchild);      //释放左子树
            Release(bt->rchild);     //释放右子树
            delete bt;               //释放根结点
        }
    }
    
    template <class T>
    void BiTree<T>::CreatBTNode(char* str)    //创建以r为根结点的二叉链存储结构
    {
        BiNode<T>* St[Maxsize]{};        //建立一个顺序栈
        BiNode<T>* p{};
        int top = -1, k = 0, j = 0;
        char ch;
        while (str[j] != '\0')        //循环扫描str中每个字符
        {
            ch = str[j];
            switch (ch)
            {
            case '(':top++; St[top] = p; k = 1; break;    //新建结点有孩子,将其进栈
            case ')':top--; break;
            case ',':k = 2; break;                    //开始处理右孩子结点
            default: p = new BiNode<T>();                //新建一个结点
                p->lchild = p->rchild = NULL;
                p->data = ch;
                if (r == NULL) r = p;                    //若未建立根结点,*p作为根结点
                else                                //已建立二叉树根结点
                {
                    switch (k)
                    {
                    case 1:St[top]->lchild = p; break;//新建结点作为栈顶结点的左孩子
                    case 2:St[top]->rchild = p; break;//新建结点作为栈顶结点的右孩子
                    }
                }
                break;
            }
            j++;                    //继续遍历其他字符
        }
    }
    
    template<class T>
    void BiTree<T>::PreOrder(BiNode<T>* bt)       //前序遍历函数实现
    {
        if (bt == NULL) return;       //递归调用的结束条件
        else {
            cout << bt->data << "\t";        //访问根结点bt的数据域
            PreOrder(bt->lchild);            //前序递归遍历bt的左子树
            PreOrder(bt->rchild);            //前序递归遍历bt的右子树
        }
    }
    
    template<class T>
    void BiTree<T>::InOrder(BiNode<T>* bt)    //中序遍历函数实现
    {
        if (bt == NULL) return;       //递归调用的结束条件
        else {
            InOrder(bt->lchild);            //中序递归遍历bt的左子树
            cout << bt->data << "\t";        //访问根结点bt的数据域
            InOrder(bt->rchild);            //中序递归遍历bt的右子树
        }
    }
    
    template<class T>             //后序遍历函数实现
    void BiTree<T>::PostOrder(BiNode<T>* bt)    //中序遍历函数实现
    {
        if (bt == NULL) return;       //递归调用的结束条件
        else {
            PostOrder(bt->lchild);             //后序递归遍历bt的左子树
            PostOrder(bt->rchild);            //后序递归遍历bt的右子树
            cout << bt->data << "\t";        //访问根结点bt的数据域
        }
    }
    
    
    template <typename T>
    void BiTree<T>::DispBiNode(BiNode<T>* bt)    //被DispBiNode函数调用
    {
        if (bt != NULL)
        {
            cout << bt->data;            //输出根结点值
            if (bt->lchild != NULL || bt->rchild != NULL)
            {
                cout << "(";            //有孩子结点时输出"("
                DispBiNode(bt->lchild);    //递归输出左子树
                if (bt->rchild != NULL)
                    cout << ",";        //有右孩子结点时输出","
                DispBiNode(bt->rchild);    //递归输出右子树
                cout << ")";            //输出")"
            }
        }
    }
    
    int main()
    {
        char str1[] = "A(B(D(,G)),C(E,F))";   //建立一个树
        char* str = str1;
        BiTree<char> T{};
        T.CreatBTNode(str);     //创建二叉链存储结构
        cout << "二叉树括号表示:" << endl;
        T.DispBiNode(); 
        cout << endl;
        cout << "前序遍历结果:" << endl;
        T.PreOrder();           //前序递归遍历函数调用
        cout << endl;
        cout << "中序遍历结果:" << endl;
        T.InOrder();            //中序递归遍历函数调用
        cout << endl;
        cout << "后序遍历结果:" << endl;
        T.PostOrder();          //后序递归遍历函数调用
        T.~BiTree();            //析构函数调用,释放空间
        return 0;
    }
    
    
    本回答被题主选为最佳回答 , 对您是否有帮助呢?
    评论

报告相同问题?

问题事件

  • 系统已结题 5月16日
  • 已采纳回答 5月8日
  • 创建了问题 5月8日

悬赏问题

  • ¥15 爬取豆瓣电影相关处理
  • ¥15 手机淘宝抓清除消息接口
  • ¥15 C#无selenium
  • ¥15 LD衰减计算的结果过大
  • ¥15 用机器学习方法帮助保险公司预测哪些是欺诈行为
  • ¥15 计算300m以内的LD衰减
  • ¥15 数据爬取,python
  • ¥15 怎么看 cst中一个面的功率分布图,请说明详细步骤。类似下图
  • ¥15 为什么我的pycharm无法用pyqt6的QtWebEngine
  • ¥15 FOR循环语句显示查询超过300S错误怎么办