不递归地镜像二叉树

Question

我试图通过使用我创建的两个队列和一个二叉树来镜像不使用递归方法的二叉树。 以下是我使用过的功能。 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);

}

    

这里是输入和输出

在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

Answer 1

问题是您将Node *mirror_root 声明为mirror_tree 中的局部变量，而您希望代码为具有相同名称的类成员赋值。

所以从mirror_tree 函数中删除该行。