DS二叉树—二叉树镜面反转

题目描述

假设二叉树用二叉链表存储，用先序序列结果创建。输入二叉树的先序序列，请你先创建二叉树，并对树做个镜面反转，再输出反转后的二叉树的先序遍历、中序遍历、后序遍历和层序遍历的序列。所谓镜面反转，是指将所有非叶结点的左右孩子对换。

–程序要求–

若使用C++只能include一个头文件iostream；若使用C语言只能include一个头文件stdio.h
程序中若include多过一个头文件，不看代码，作0分处理 不允许使用第三方对象或函数实现本题的要求

输入

t组测试数据

每组测试数据是一个二叉树的先序遍历序列，#表示空树

输出

对每棵二叉树，输出镜面反转后的先序、中序、后序和层次遍历序列。如果空树，输出四个NULL（后面不加空格）。如下：

NULL
NULL
NULL
NULL

样例输入

3
41#32###65##7##
AB#C##D##
AB##C##

样例输出

4 6 7 5 1 3 2
7 6 5 4 3 2 1
7 5 6 2 3 1 4
4 6 1 7 5 3 2
A D B C
D A C B
D C B A
A D B C
A C B
C A B
C B A
A C B

#include <iostream>
#include <queue>
using namespace std;

class Binary_tree_node
{
public:
    char data;                                //数据区域
    Binary_tree_node *LeftChild, *RightChild; //左右孩子
    Binary_tree_node() : LeftChild(NULL), RightChild(NULL) {}
    ~Binary_tree_node()
    {
        delete LeftChild;
        delete RightChild;
    }
};

class Binary_tree
{
public:
    Binary_tree_node *root; //根节点
    Binary_tree() {}
    ~Binary_tree() {}
    //先序创建二叉树
    void CreateTree()
    {
        CreateTree(root);
    }
    void CreateTree(Binary_tree_node *&p)
    {
        char ch;
        cin >> ch;
        if (ch == '#') //结点为空
        {
            p = NULL;
        }
        else //结点不为空
        {
            p = new Binary_tree_node;
            p->data = ch;
            CreateTree(p->LeftChild);
            CreateTree(p->RightChild);
        }
    }
    //镜像反转
    void Mirror_inversion()
    {
        Mirror_inversion(root);
    }
    void Mirror_inversion(Binary_tree_node *p)
    {
        if (p != NULL)
        {
            Mirror_inversion(p->LeftChild);
            Mirror_inversion(p->RightChild);
            swap(p->LeftChild, p->RightChild);
        }
    }
    //先序遍历
    void PreOrder()
    {
        PreOrder(root);
    }
    void PreOrder(Binary_tree_node *p)
    {
        if (p == NULL) //递归中遇到节点为空，返回上一层节点
        {
            return;
        }
        //根左右
        cout << p->data;
        PreOrder(p->LeftChild);
        PreOrder(p->RightChild);
    }

    //中序遍历
    void InOrder()
    {
        InOrder(root);
    }
    void InOrder(Binary_tree_node *p)
    {
        if (p == NULL) //递归中遇到节点为空，返回上一层节点
        {
            return;
        }
        //左根右
        InOrder(p->LeftChild);
        cout << p->data;
        InOrder(p->RightChild);
    }

    //后序遍历
    void PostOrder()
    {
        PostOrder(root);
    }
    void PostOrder(Binary_tree_node *p)
    {
        if (p == NULL) //递归中遇到节点为空，返回上一层节点
        {
            return;
        }
        //左右根
        InOrder(p->LeftChild);
        InOrder(p->RightChild);
        cout << p->data;
    }

    //层序遍历
    void LevelOrder()
    {
        LevelOrder(root);
    }
    void LevelOrder(Binary_tree_node *p)
    {
        queue<Binary_tree_node *> tq; //建立队列tq,队列的每个元素都是结点指针
        tq.push(p);
        if (root == NULL) //树为空，直接返回
        {
            return;
        }
        while (!tq.empty())
        {
            p = tq.front();
            tq.pop();
            cout << p->data;
            if (p->LeftChild != NULL)
            {
                tq.push(p->LeftChild);
            }
            if (p->RightChild != NULL)
            {
                tq.push(p->RightChild);
            }
        }
    }
};

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        Binary_tree Bt;
        Bt.CreateTree();
        Bt.Mirror_inversion();
        Bt.PreOrder();
        cout<<endl;
        Bt.InOrder();
        cout<<endl;
        Bt.PostOrder();
        cout<<endl;
        Bt.LevelOrder();
        cout<<endl;
    }
    return 0;
}