UVa 122 (二叉树的层次遍历) Trees on the level

题意：

输入一颗二叉树，按照(左右左右, 节点的值)的格式。然后从上到下从左到右依次输出各个节点的值，如果一个节点没有赋值或者多次赋值，则输出“not complete”

一、指针方式实现二叉树

首先定义一个结构体，然后定义一个结构体指针root，作为整棵树的根节点。如果需要用到左右节点则申请一个空间，也就是用不到的就不申请，以节省空间。

遍历方式是广度优先遍历(BFS)，从根节点依次拓展子节点，如果有子节点就入队，然后根节点出队。继续拓展，直到队列为空，即遍历完整棵树。

因为指针丢失以后会造成内存泄露，所以在每次读取二叉树之前都要释放掉上一棵树申请的内存，二叉树的删除也是递归删除的。

 #define LOCAL
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <vector>
 #include <queue>

 const int maxn = ;
 char s[maxn];
 bool failed;
 std::vector<int> ans;

 struct Node
 {
     bool have_value;    //是否赋值过
     int v;
     Node *left, *right;
     Node():have_value(false), left(NULL), right(NULL) {}    //构造函数
 };
 Node* root;

 Node* newnode()    { return new Node(); }    //调用构造函数

 void addnode(int v, char* s)
 {
     int n = strlen(s);
     Node* u = root;
     for(int i = ; 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 = true;    //如果一个节点有多次赋值，做标记
     u->v = v;
     u->have_value = true;
 }

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

 bool read_input(void)
 {
     failed = false;
     remove_tree(root);
     root = newnode();

     for(;;)
     {
         if(scanf("%s", s) != ) return false;
         if(!strcmp(s, "()"))    break;
         int v;
         sscanf(&s[], "%d", &v);
         addnode(v, strchr(s, ',') + );
     }
     return true;
 }

 bool BFS(std::vector<int>& ans)
 {
     std::queue<Node*> q;
     ans.clear();
     q.push(root);
     while(!q.empty())
     {
         Node* u = q.front();
         q.pop();
         if(!u->have_value)    return false;    //该节点没有赋值过
         ans.push_back(u->v);
         if(u->left != NULL)    q.push(u->left);
         if(u->right != NULL)    q.push(u->right);
     }
     return true;
 }

 int main(void)
 {
     #ifdef LOCAL
         freopen("122in.txt", "r", stdin);
     #endif

     while(read_input())
     {
         if(failed || !BFS(ans))    printf("not complete\n");
         else
         {
             printf("%d", ans[]);
             for(int i = ; i < ans.size(); ++i)
                 printf(" %d", ans[i]);
             puts("");
         }
     }

     return ;
 }

代码君一

二、数组方式实现

每新建一个节点计数器cnt就自增1，而不是像完全二叉树那样，左右子节点是父节点的二倍和二倍加1.

 //#define LOCAL
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <vector>

 const int maxn = ;
 const int root = ;
 char s[maxn];
 bool have_value[maxn], failed;
 int left[maxn], right[maxn], val[maxn], cnt;
 std::vector<int> ans;

 void newtree(void)
 {
     left[root] = right[root] = ;
     have_value[root] = false;
     cnt = root;
 }

 int newnode(void)
 {
     int u = ++cnt;
     left[u] = right[u] = ;
     have_value[u] = false;
     return u;
 }

 void addnode(int v, char* s)
 {
     int n = strlen(s);
     int u = root;
     for(int i = ; i < n; ++i)
     {
         if(s[i] == 'L')
         {
             if(left[u] == )    left[u] = newnode();
             u = left[u];
         }
         else if(s[i] == 'R')
         {
             if(right[u] == )    right[u] = newnode();
             u = right[u];
         }
     }
     if(have_value[u])    failed = true;    //如果一个节点有多次赋值，做标记
     val[u] = v;
     have_value[u] = true;
 }

 bool read_input(void)
 {
     failed = false;
     newtree();

     for(;;)
     {
         if(scanf("%s", s) != ) return false;
         if(!strcmp(s, "()"))    break;
         int v;
         sscanf(&s[], "%d", &v);
         addnode(v, strchr(s, ',') + );
     }
     return true;
 }

 bool BFS(std::vector<int>& ans)
 {
     std::queue<int> q;
     ans.clear();
     q.push(root);
     while(!q.empty())
     {
         int u = q.front();
         q.pop();
         if(!have_value[u])    return false;
         ans.push_back(val[u]);
         if(left[u] != )    q.push(left[u]);
         if(right[u] != )    q.push(right[u]);
     }
     return true;
 }

 int main(void)
 {
     #ifdef LOCAL
         freopen("122in.txt", "r", stdin);
     #endif

     while(read_input())
     {
         if(failed || !BFS(ans))    puts("not complete");
         else
         {
             printf("%d", ans[]);
             for(int i = ; i < ans.size(); ++i)
                 printf(" %d", ans[i]);
             puts("");
         }
     }

     return ;
 }

代码君二

三、内存池的方法

静态申请一个Node数组配合一个空闲列表实现一个简单的内存池。

 //#define LOCAL
 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <vector>
 #include <queue>

 const int maxn = ;
 char s[maxn];
 bool failed;
 std::vector<int> ans;

 struct Node
 {
     bool have_value;    //是否赋值过
     int v;
     Node *left, *right;
     Node():have_value(false), left(NULL), right(NULL) {}    //构造函数
 }node[maxn];
 Node* root;
 std::queue<Node*> freenodes;

 void Init()
 {
     for(int i = ; i < maxn; ++i)
         freenodes.push(&node[i]);    //初始化内存池
 }

 Node* newnode()
 {
     Node* u = freenodes.front();
     u->left = u->right = NULL;
     u->have_value = false;
     freenodes.pop();
     return u;
 }

 void deletenode(Node* u) { freenodes.push(u); }

 void addnode(int v, char* s)
 {
     int n = strlen(s);
     Node* u = root;
     for(int i = ; 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 = true;    //如果一个节点有多次赋值，做标记
     u->v = v;
     u->have_value = true;
 }

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

 bool read_input(void)
 {
     failed = false;
     remove_tree(root);
     Init();
     root = newnode();
     for(;;)
     {
         if(scanf("%s", s) != ) return false;
         if(!strcmp(s, "()"))    break;
         int v;
         sscanf(&s[], "%d", &v);
         addnode(v, strchr(s, ',') + );
     }
     return true;
 }

 bool BFS(std::vector<int>& ans)
 {
     std::queue<Node*> q;
     ans.clear();
     q.push(root);
     while(!q.empty())
     {
         Node* u = q.front();
         q.pop();
         if(!u->have_value)    return false;    //该节点没有赋值过
         ans.push_back(u->v);
         if(u->left != NULL)    q.push(u->left);
         if(u->right != NULL)    q.push(u->right);
     }
     return true;
 }

 int main(void)
 {
     #ifdef LOCAL
         freopen("122in.txt", "r", stdin);
     #endif

     while(read_input())
     {
         if(failed || !BFS(ans))    printf("not complete\n");
         else
         {
             printf("%d", ans[]);
             for(int i = ; i < ans.size(); ++i)
                 printf(" %d", ans[i]);
             puts("");
         }
     }

     return ;
 }

代码君三