Trees on the level HDU - 1622（二叉树）

Problem Description

Trees are fundamental in many branches of computer science. Current state-of-the art parallel computers such as Thinking Machines’ CM-5 are based on fat trees. Quad- and octal-trees are fundamental to many algorithms in computer graphics. This problem involves building and traversing binary trees. Given a sequence of binary trees, you are to write a program that prints a level-order traversal of each tree. In this problem each node of a binary tree contains a positive integer and all binary trees have have fewer than $256$ nodes. In a level-order traversal of a tree, the data in all nodes at a given level are printed in left-to-right order and all nodes at level k are printed before all nodes at level $k+1$.
For example, a level order traversal of the tree

is: $5,4,8,11,13,4,7,2,1$.

In this problem a binary tree is specified by a sequence of pairs $(n,s)$ where n is the value at the node whose path from the root is given by the string $s$. A path is given be a sequence of L’s and R’s where L indicates a left branch and R indicates a right branch. In the tree diagrammed above, the node containing $13$ is specified by $(13,RL)$, and the node containing $2$ is specified by $(2,LLR)$. The root node is specified by $(5,)$ where the empty string indicates the path from the root to itself. A binary tree is considered to be completely specified if every node on all root-to-node paths in the tree is given a value exactly once.

Input

The input is a sequence of binary trees specified as described above. Each tree in a sequence consists of several pairs $(n,s)$ as described above separated by whitespace. The last entry in each tree is $()$. No whitespace appears between left and right parentheses.

All nodes contain a positive integer. Every tree in the input will consist of at least one node and no more than $256$ nodes. Input is terminated by end-of-file.

Output

For each completely specified binary tree in the input file, the level order traversal of that tree should be printed. If a tree is not completely specified, i.e., some node in the tree is NOT given a value or a node is given a value more than once, then the string $‘‘notcomplet{e}^{\prime \prime }$ should be printed

Sample Input

(11,LL) (7,LLL) (8,R)
(5,) (4,L) (13,RL) (2,LLR) (1,RRR) (4,RR) ()
(3,L) (4,R) ()

Sample Output

5 4 8 11 13 4 7 2 1
not complete

$题意$：
输入一棵二叉树，你的任务是按从上到下、从左到右的顺序输出各个结点的值。每个结点都按照从根结点到它的移动序列给出（L表示左，R表示右）。在输入中，每个结点的左括号和右括号之间没有空格，相邻结点之间用一个空格隔开。每棵树的输入用一对空括号“()”结束（这对括号本身不代表一个结点）；

$思路$：
先将字符串按照逗号右边的长短，大小排序，之后去构造二叉树，如果能构造成功，就按照从浅到深，从左至右输出树的值。

$ps$：输入输出复杂，这里用到了$sscanf$。输出时：是按层遍历，用到了队列,进行了搜索；

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
int ans[10100],k,v;
char b[1010],flag,flot;
struct node
{
    int s;
    bool b;
    node *l,*r;
    node():b(false),l(NULL),r(NULL) {}
}*head;
void buil(int v,char *b)
{
    node *chr=head;
    for(int i=0; b[i]; i++)
    {
        if(b[i]=='L')
        {
            if(chr->l==NULL)
                chr->l=new node;
            chr=chr->l;
        }
        if(b[i]=='R')
        {
            if(chr->r==NULL)
                chr->r=new node;
            chr=chr->r;
        }
    }
    if(chr->b) flag=1;
    chr->s=v;
    chr->b=1;
}
void prin()
{
    queue<node *>q;
    node *chr=head;
    q.push(head);
    while(!q.empty())
    {
        chr=q.front();
        q.pop();
        if(!chr->b)flot=0;
        if(!flot)break;
        ans[k++]=chr->s;
        if(chr->l!=NULL)q.push(chr->l);
        if(chr->r!=NULL)q.push(chr->r);
    }
    if(!flag&&flot)
    {
        for(int i=0; i<k; i++)
        {
            if(i)
                printf(" ");
            cout<<ans[i];
        }
    }
    else
        printf("not complete");
   printf("\n");
}
void freenode(node *chr)
{
    if(chr==NULL)
        return ;
    freenode(chr->l);
    freenode(chr->r);
    free(chr);
}
int main()
{
    head=new node;
    while(~scanf("%s",b))
    {
        if(strcmp(b,"()")==0)
        {
            flot=1;
            k=0;
            prin();
            freenode(head);
            head=new node;
            flag=0;
            continue;
        }
        sscanf(&b[1],"%d",&v);
        buil(v,strchr(b,',')+1);
    }
    return 0;
}

实践是检验真理的唯一标准