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

题目描述

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

输入

测试次数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

思路：

二叉树采用的链表实现

定义一个交换函数，参数是结点，作用是交换左右孩子

从根结点开始，对左孩子调用函数，再对右孩子调用函数，最后再交换左右孩子

例如：

void BiTree::exchange(BiTreeNode *t)
{
    if(t!=NULL)
    {
        exchange(t->LeftChild);
        exchange(t->RightChild);
        BiTreeNode *temp;
        temp = t->LeftChild;
        t->LeftChild = t->RightChild;
        t->RightChild = temp;
    }
}

递归交换，最后就可以达到题目要求

代码：

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

class BiTreeNode
{
public:
    char data;
    BiTreeNode *LeftChild;
    BiTreeNode *RightChild;
    BiTreeNode():LeftChild(NULL),RightChild(NULL){}
    ~BiTreeNode(){}
};

class BiTree
{
public:
    BiTreeNode *Root;
    int pos;
    string strTree;
    BiTreeNode *CreateBiTree();
    void PreOrder(BiTreeNode *t);
    void InOrder(BiTreeNode *t);
    void PostOrder(BiTreeNode *t);
    void level_Order(BiTreeNode *t);
public:
    BiTree(){};
    ~BiTree(){};
    void CreateTree(string TreeArray);
    void PreOrder();
    void InOrder();
    void PostOrder();
    void exchange(BiTreeNode *t);
};
void BiTree::exchange(BiTreeNode *t)
{
    if(t!=NULL)
    {
        exchange(t->LeftChild);
        exchange(t->RightChild);
        BiTreeNode *temp;
        temp = t->LeftChild;
        t->LeftChild = t->RightChild;
        t->RightChild = temp;
    }
}
void BiTree::CreateTree(string TreeArray)
{
    pos=0;
    strTree.assign(TreeArray);
    Root =CreateBiTree();
}
BiTreeNode *BiTree::CreateBiTree()
{
    BiTreeNode *T;
    char ch;
    ch= strTree[pos++];
    if(ch == '#')
        T=NULL;
    else
    {
        T=new BiTreeNode();
        T->data=ch;
        T->LeftChild = CreateBiTree();
        T->RightChild = CreateBiTree();
    }
    return T;
}
void BiTree::PreOrder()
{
    if(strTree[0]=='#')
        cout<<"NULL";
    else
        PreOrder(Root);
    cout<<endl;
}
void BiTree::PreOrder(BiTreeNode *t)
{
    if(t)
    {
        cout<<t->data<<' ';
        PreOrder(t->LeftChild);
        PreOrder(t->RightChild);
    }
}
void BiTree::InOrder()
{
    if(strTree[0]=='#')
        cout<<"NULL";
    else
        InOrder(Root);
    cout<<endl;
}
void BiTree::InOrder(BiTreeNode *t)
{
    if(t)
    {
        InOrder(t->LeftChild);
        cout<<t->data<<' ';
        InOrder(t->RightChild);
    }
}
void BiTree::PostOrder()
{
    if(strTree[0]=='#')
        cout<<"NULL";
    else
        PostOrder(Root);
    cout<<endl;
}
void BiTree::PostOrder(BiTreeNode *t)
{
    if(t)
    {
        PostOrder(t->LeftChild);
        PostOrder(t->RightChild);
        cout<<t->data<<' ';
    }
}
void BiTree::level_Order(BiTreeNode *t)
{
    if(strTree[0]=='#')
        cout<<"NULL";
    else
    {
        queue<BiTreeNode*> qt;
        BiTreeNode *p=t;
        qt.push(p);
        while(1)
        {
            p=qt.front();
            qt.pop();
            cout<<p->data<<' ';
            if(p->LeftChild)
                qt.push(p->LeftChild);
            if(p->RightChild)
                qt.push(p->RightChild);
            if(qt.empty())
                break;
        }
    }
    cout<<endl;
}
int main()
{
    int t;
    cin>>t;
    string s;
    while(t--)
    {
        cin>>s;
        BiTree t;
        t.CreateTree(s);
        t.exchange(t.Root);
        t.PreOrder();
        t.InOrder();
        t.PostOrder();
        t.level_Order(t.Root);
    }
}