镜像二叉树而无需递归

问题描述

我试图通过使用两个队列和我创建的一个二叉树来镜像没有递归方法的二叉树。 以下是我使用的功能。 root是指向原始二叉树的根节点的指针，而mirrior_root是镜像二叉树的指针。 错误似乎出在逻辑部分！

我们将不胜感激！

#include<iostream>
#include<queue>

using namespace std;

class Node
{
    public:
        Node *lchild;
        int data;
        Node *rchild; 
};

class Tree
{
    public:
        Node *root;
        Node *mirror_root;
        Tree()
        {
            root = NULL;
        }
        void create_Tree()
        {
            Node *p;
            Node *t;
            int x;
            queue <Node *> q;

            root = new Node ;
            cout << "Enter the data you want to insert in root";
            cin >> x;
            root->data = x;
            root->lchild = root ->rchild = NULL;
            q.emplace(root);

            while(! q.empty())
            {
                p = q.front();
                q.pop();

                cout << "Enter the left child of " << p->data << ":";
                cin >> x;
                if(x != -1)
                {
                    t= new Node;
                    t->data = x;
                    t->lchild = t->rchild = NULL;
                    p->lchild = t;
                    q.emplace(t);
                }
                cout << "Enter the right child of " << p->data << ":";
                cin >> x;
                if(x != -1)
                {
                    t= new Node;
                    t->data = x;
                    t->lchild = t->rchild = NULL;
                    p->rchild = t;
                    q.emplace(t);
                }
            }

        }
        void Preorder(Node *p)
        {
            if(p)
            {
                cout << p->data << " " ;
                Preorder(p->lchild);
                Preorder(p->rchild);
            }
        }
        void Level_order(Node *p)
        {
            queue <Node *> q;
            q.emplace(p);
            cout << p->data << " " ;

            while(!q.empty())
            {
                p = q.front();
                q.pop();

                if(p->lchild)
                {
                    cout << p->lchild->data << " ";
                    q.emplace(p->lchild);
                }
                if(p->rchild)
                {
                    cout << p->rchild->data << " ";
                    q.emplace(p->rchild);
                }
            }
        }
        void mirror_tree(Node *p)
        {
            Node *mirror_root;
            Node *t;
            Node *k;

            queue <Node *> q_root;
            queue <Node *> q_mirror;

            mirror_root = new Node;
            mirror_root->data = p->data;
            mirror_root->lchild = mirror_root->rchild = NULL;

            t=mirror_root;

            q_root.emplace(p);
            q_mirror.emplace(t);

            while(!q_root.empty())
            {
                p=q_root.front();
                q_root.pop();

                t = q_mirror.front();
                q_mirror.pop();

                if(p->lchild)
                {
                    k = new Node;
                    k->data = p->lchild->data;
                    k->lchild = k->rchild = NULL;
                    t->rchild = k;
                    q_root.emplace(p->lchild);
                    q_mirror.emplace(t->rchild);

                }

                if(p->rchild)
                {
                    k = new Node;
                    k->data = p->rchild ->data;
                    k->lchild = k->rchild = NULL;
                    t->lchild = k;
                    q_root.emplace(p->rchild);
                    q_mirror.emplace(t->lchild);
                }
            }
        }
};

int main()
{
    Tree bt;
    bt.create_Tree();
    bt.mirror_tree(bt.root);

    cout << "Level order of mirrored binary tree is  : ";
    bt.Level_order(bt.mirror_root);

}

    

这里是输入和输出

输入要在根目录中插入的数据：5

输入5：6的左孩子

输入5：7的右孩子

输入6：8的左孩子

输入6：9的右孩子

输入7:10的左孩子

输入7:11的右孩子

输入8：-1的左孩子

输入8：-1的右孩子

输入9：-1的左孩子 输入9：-1的右孩子

输入10：-1的左孩子

输入10：-1的右孩子

输入11：-1的左孩子

输入11：-1的右孩子

镜像的二叉树的级别顺序为：7769539

我期望的输出是

镜像二叉树的级别顺序为5 7 6 11 10 9 8

解决方法

问题在于，您希望将Node *mirror_root声明为mirror_tree中的局部变量，同时希望代码为同名的类成员提供值。

因此，从mirror_tree函数中删除该行。