二叉树的层次遍历！！！

好久没有写这个东西了，不是我这几天颓废了，是这几天英语作业把我给整的，人生没有了理想了，

痛苦的英语作业。。。。。。

层次遍历 ：

问题描述  ：

输入一颗二叉树，你的任务就是从上到下，从左到右的顺序输出各个节点的数值，（简单的说就是使用宽度优先搜索）

每个节点都按照从根节点到他的移动序列给出（L表示左，R表示右），在输入中，每个节点的左括号和右括号之间没有空格，相邻节点之间用一个空格隔开，每颗树的输入用一对空括号（）结束，（这个括号不代表一个节点）

注意，如果从根节点到某个叶节点的路径上有的节点没有在输入中给出，或者是给出了超过了一次，应当输出-1，节点数不超过256.

样例输入 ：

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

(3,L)(4,R)()

样例输出：

5 4 8 11 13 4 7 2 1

-1

题目分析：

这样的题目一开始我还是要准备使用一个数组来做的，但是你有没有想过，这个一个256个节点的树，如果，这些节点都在一个方向，这个树将会十分的长，数组是放不下的，所以我想到了，链表。

树的建立就使用链表的方式。

访问就使用队列的方式。

/*
 *
 *层次遍历
 *using queue and BFS
 * is so hard
 * but i like
 *
 **/
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<queue>
using namespace std;
typedef struct Tree{
    int num;
    int display;
    struct Tree *p_front;
    struct Tree *p_left,*p_right;
}TreeNode;
TreeNode *p_pre = NULL,*p_now = NULL;

TreeNode *createNode(int num,TreeNode *p_front){
    TreeNode *p_node = (TreeNode *) malloc (sizeof(TreeNode));
    p_node->num = num;
    p_node->display = 0;
    p_node->p_front = p_front;
    p_node->p_left = NULL;
    p_node->p_right= NULL;
    return p_node;
}



void createTree(int num,char *p_buf){
    int i = 0;
    while(*(p_buf+i) != ','){
        i++;
    }
    p_now = p_pre;
    while(*(p_buf+i) != ')'){
        //printf("i = %d\n",i);
        if(!p_pre){
            p_pre = createNode(num,NULL);
            p_now = p_pre;
        }
        if(!p_now->p_left && *(p_buf+i) == 'L' && *(p_buf +i+1) != ')'){
            TreeNode *p_node = createNode(0,p_now);
            p_now->p_left = p_node;
            p_now = p_node;
            //continue;
        }
        else if(p_now->p_left && *(p_buf+i) == 'L' && *(p_buf +i+1) != ')'){
            p_now = p_now->p_left;
            //continue;
        }
        if(!p_now->p_right && *(p_buf+i) == 'R' && *(p_buf +i+1) != ')'){
            TreeNode *p_node = createNode(0,p_now);
            p_now->p_right = p_node;
            p_now = p_node;
            //continue;
        }
        else if(p_now->p_right && *(p_buf+i) == 'R' && *(p_buf +i+1) != ')'){
            p_now = p_now->p_right;
            //continue;
        }
        if(!p_now->p_left && *(p_buf+i) == 'L' && *(p_buf +i+1) == ')'){
            TreeNode *p_node = createNode(num,p_now);
            p_now->p_left = p_node;
            p_now = p_node;
            p_now->display = 1;
            //continue;
        }
        else if(p_now->p_left && *(p_buf+i) == 'L' && *(p_buf +i+1) == ')'){
            p_now = p_now->p_left;
            p_now->num = num;
            p_now->display = 1;
            //continue;
        }
        if(!p_now->p_right && *(p_buf+i) == 'R' && *(p_buf +i+1) == ')'){
            TreeNode *p_node = createNode(num,p_now);
            p_now->p_right = p_node;
            p_now = p_node;
            p_now->display = 1;
            //continue;
        }
        else if(p_now->p_right && *(p_buf+i) == 'R' && *(p_buf +i+1) == ')'){
            p_now = p_now->p_right;
            p_now->num = num;
            p_now->display = 1;
            //continue;
        }
        if(p_now && *(p_buf+i+1) == ')' && *(p_buf+i) == ','){
            p_now->display = 1;
            //printf("jkl\n");
            p_now->num = num;
        }
        i++;
    }
}

int BFS(TreeNode *p_pre,int *p_arr,int *count){
    queue<TreeNode *>s;
    s.push(p_pre);
    TreeNode *p_node = NULL;
    while(!s.empty()){
    p_node = s.front();
    s.pop();
    if(p_node->display == 0){
        return -1;
    }
    else {
        *(p_arr+(*count)) = p_node->num;
        (*count)++;
        if(p_node->p_left){
            s.push(p_node->p_left);
        }
        /*else if( p_node->p_left->p_left || p_node->p_left->p_right){
            return -1;
        }*/
        if(p_node->p_right){
            s.push(p_node->p_right);
        }
        /*else if(p_node->p_right->p_left || p_node->p_right->p_right){
            return -1;
        }*/

        }
    }
    return 0;
}


void LookArr(int arr[],int *p_count){
    int i = 0;
    for(i = 0;i < *p_count;i++){
        printf("%d",arr[i]);
        i != (*p_count-1) && printf(" ");
    }
    printf("\n");
}



int main( void ){
    int count = 0;
    char buffer[1000] = {};
    int arr[1000] = {};
    while(scanf("%s",buffer) && strcmp(buffer,"()")){
        int num = 0;
        sscanf(&buffer[1],"%d",&num);
        createTree(num,buffer);
    }
    if(BFS(p_pre,arr,&count) == -1){
    LookArr(arr,&count);
        printf("-1\n");
        return 0;
    }
    LookArr(arr,&count);
    return 0;
}

我虽然这样写了。链表，但是在这个代码中我并没有释放链表。造成内存泄露

/*
 *
 * using BFS and queue
 *
 **/
#include<stdio.h>
#include<stdlib.h>
#include<queue>
#include<string.h>
using namespace std;

typedef struct Tnode{
    int have_value;
    int v;
    struct Tnode *left,*right;
}Node;

Node* root;



Node* newnode(){
    Node* u = (Node*) malloc (sizeof(Node));
    if(u != NULL){
        u->have_value = 0;
        u-left = u->right = NULL;
    }
    return 0;
}

void addnode(int v,char* s){
    int n = strlen(s);
    Node* u = root;
    for(int i = 0;i < n;i++)
        if(s[i] == 'L'){
            if(u->left == NULL) u->left = newnode();
            u = u->left;
        }
        else if(s[i] == 'R'){
            if(u->right == NULL) u->right = newnode();
            u = u->right;
        }
    if(u->have_value) failed = 1;
    u->v = v;
    u->have_value = 1;
}

int n = 0;
int ans[MAXN];
int bfs(){
    int front = 0;
    int rear = 1;
    Node *q[MAXN];
    q[0] = root;
    while(front < rear){
        Node *u = q[front++];
        if(!u->have_value) return 0;
        ans[n++] = u->v;
        if(u->left != NULL)q[rear++] = u->left;
        if(u->right != NULL) q[rear++] = u->right;
    }
    return 1;
}

void remove_tree(Node *u){
    if(u == NULL) return ;
    remove_tree(u->left);
    remove_tree(u->right);
    free(u);
}





char s[MAXN+10];
int read_input(){
    failed = 0;
    root = newnode();
    for(;;){
        if(scanf("%s",s) != 1) return 0;
        if(!strcmp(s,"()")) break;
        int v;
        sscanf(&s[1],"%d",&v);
        addnode(v,strchr(s,',')+1);
    }
    return 1;
}



int main( void ){
    return 0;
}

这是改进的方法，但是都是不完全的代码。