DS森林叶子编码

题解

1. 这里的一共有树节点类和二叉树节点类两种，其中树节点类中的孩子指针是以容量为B的孩子指针数组定义的。而森林类中私有成员有树根节点数组和二叉树根节点数组。
2. 思路：先将森林中的各颗树通过先序构建起来（树的构建其实和二叉树的构建一样），然后再将各棵树转化成二叉树，最后再将各棵树转化成的二叉树合并成一颗二叉树（这里的构建树和构建二叉树都是递归函数，私有函数都要记得传引用）。
3. 这里对叶子进行编码直接遍历二叉树就好了，至于是哪种遍历方式就没有影响，因为每种遍历方式都是左在右前的，所以一定是左叶子先编码。

题目

问题 L: DS森林叶子编码
时间限制: 1 Sec  内存限制: 128 MB
提交: 97  解决: 71
[提交][状态][讨论版]
题目描述
给定一组森林，编写程序生成对应的二叉树，输出这颗二叉树叶结点对应的二进制编码.规定二叉树的左边由0表示，二叉树的右边由1表示。

输入
输入：

N B  表示N个树，每结点最多B个分支

第2行至第N+1行，每个树的先序遍历

输出
每行表示一个叶结点对应的二进制编码.

样例输入
3 3
A B 0 0 0 C 0 0 0 D 0 0 0
E F 0 0 0 0 0
G H 0 0 0 I J 0 0 0 0 0 0
样例输出
0 1 1
1 0
1 1 0 1 0

代码块

#include <iostream>
using namespace std;

int N, B;

class TNode
{
    char data;
    TNode **child;
public:
    TNode();
    ~TNode();
    friend class Forest;
};

class BiTNode
{
    char data;
    BiTNode *lchild, *rchild;
    friend class Forest;
};

class Forest
{
    TNode **root1;
    BiTNode **root2;
    void PreOrderTraverse(TNode *&p);
    void TreeIntoBiTree(TNode *p, BiTNode *&q, int i);
    void PostOrderTraverse(BiTNode *p, string a);
public:
    Forest();
    ~Forest();
    void PreOrder();
    void ForestIntoBiTree();
    void PostOrder();
};

TNode::TNode()
{
    child = new TNode*[B];
}

TNode::~TNode()
{
    delete []child;
}

Forest::Forest()
{
    root1 = new TNode*[N];
    root2 = new BiTNode*[N];
}

 Forest::~Forest()
{
    delete []root1;
    delete []root2;
}

void Forest::PreOrder()
{
    for(int i=0; i<N; i++)
        PreOrderTraverse(root1[i]);
}

void Forest::PreOrderTraverse(TNode *&p)
{
    char ch;
    cin>>ch;
    if(ch!='0')
    {
        p = new TNode;
        p->data = ch;
        for(int i=0; i<B; i++)
            PreOrderTraverse(p->child[i]);
    }
    else//输入0字符则对应结点为空
        p = NULL;
}

void Forest::ForestIntoBiTree()
{
    int i;
    for(i=0; i<N; i++)
    {
        root2[i] = new BiTNode;
        root2[i]->data = root1[i]->data;
        TreeIntoBiTree(root1[i], root2[i]->lchild, 0);
    }
    for(i=0; i<N-1; i++)
        root2[i]->rchild = root2[i+1];
}

void Forest::TreeIntoBiTree(TNode *p, BiTNode *&q, int i)
{
    if(i<B && p->child[i])
    {
        q = new BiTNode;
        q->data = p->child[i]->data;
        TreeIntoBiTree(p, q->rchild, i+1);
        TreeIntoBiTree(p->child[i], q->lchild, 0);
    }
    else
        q = NULL;
}

void Forest::PostOrder()
{
    string a;
    PostOrderTraverse(root2[0], a);
}

void Forest::PostOrderTraverse(BiTNode *p, string a)
{//遍历的过程中值传递一个串来对应每个结点的编码情况，如果结点是叶子，就将该串输出就好了。
    if(p)
    {
        PostOrderTraverse(p->lchild, a+'0');
        PostOrderTraverse(p->rchild, a+'1');
        if(!p->lchild && !p->rchild)
        {
            int len = a.length();
            for(int i=0; i<len; i++)
            {
                if(i!=len-1)
                    cout<<a[i]<<' ';
                else
                    cout<<a[i]<<endl;
            }
        }
    }
}

int main(void)
{
    cin>>N>>B;
    Forest myForest;
    myForest.PreOrder();
    myForest.ForestIntoBiTree();
    myForest.PostOrder();
    return 0;
}