#include <iostream>

using namespace std;

class TreeNode

{

friend class BinaryTree;

private:

        char data;

        TreeNode *LChild;

        TreeNode *RChild;

public:

        TreeNode(char d);

};

TreeNode::TreeNode(char d)

{

        data = d;

        LChild = RChild = NULL;

}

//-----------------------------------------------//

//             general tree class                //

//-----------------------------------------------//

class GTree

{

friend class BinaryTree;

public:

        GTree& makeNode(char d, int num);

private:

        char DATA;

        int childN;

        GTree *sib;

};      

GTree& GTree::makeNode(char d, int num)

{

        GTree *temp;

        temp = new GTree();

        temp -> DATA = d;

        temp -> childN = num;

        temp -> sib = NULL;

        return *temp;

}

//-----------------------------------------------//

//          \'for binaryTree\' class               //

//-----------------------------------------------//

class BinaryTree

{

public:

        void changeToBT(GTree a[]);

        void PreOrder(TreeNode *ptr);

        void InOrder(TreeNode *ptr);

        void PostOrder(TreeNode *ptr);

        TreeNode& operator=(const GTree p[]);

        void show();

private:

        TreeNode *root;

};

void BinaryTree::changeToBT(GTree a[])

{

        root = a[0];

        TreeNode *Atemp;

        Atemp = root->LChild;

        for (int i=1; i<13; i++)

        {

                while (a[i]->sib != NULL)

                {

                        GTree Btemp;

                        Btemp = a[i];

                        if (a[a[i]->childN] != NULL)

                                Atemp->LChild = a[a[i]->childN];

                        if ((a[a[i]->childN]] == NULL) && (Btemp->sib != NULL))

                        {                               

                                Atemp = a[i];

                                Atemp = Atemp->RChild;

                        }                               

                        Btemp = Btemp->sib;

                }

        }

}

void BinaryTree::PreOrder(TreeNode *ptr)

{

        if (ptr != NULL)

        {

                cout << ptr->data << " ";

                PreOrder(ptr->LChild);

                PreOrder(ptr->RChild);

        }

}

void BinaryTree::InOrder(TreeNode *ptr)

{

        if (ptr != NULL)

        {

                InOrder(ptr->LChild);

                cout << ptr->data << " ";

                InOrder(ptr->RChild);

        }

}

void BinaryTree::PostOrder(TreeNode *ptr)

{

        if (ptr != NULL)

        {

                PostOrder(ptr->LChild);

                PostOrder(ptr->RChild);

                cout << ptr->data << " ";

        }

}

TreeNode& BinaryTree::operator=(const GTree p[])