UVa122 二叉树的层次遍历

主要是将两种内存存储方式写一写，还有使用队列实现的广度优先遍历BFS

动态分配内存分配

缺点：容易引起内存泄漏

Node* newNode(){ return new Node(); }//使用new的时候就会调用构造函数，给新创建的节点初始化值

内存池（队列实现）

queue<Node*> freenodes;
Node node[maxn];

void memory_pool_init()
{
for (int i = 0; i < maxn; i++)
{
freenodes.push(&node[i]);
}
}

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

void deleteNode(Node*u)
{
freenodes.push(u);//将节点还回去就是释放了节点
}

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

首先在全局数据区声明一个Node型数组，然后将数组中的每一个结构体类型的头指针进行入队操作，当要使用的时候，进行出队操作，得到结构体的头指针。

释放内存也很简单，就是将内存重新入队操作，添加到队列中。

在释放整个树的内存的时候使用了递归的思想

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <queue>

using namespace std;
const int maxn = 256 + 10;

struct Node
{
bool have_value;
int v;
struct Node* left;
struct Node* right;
Node() :have_value(false), left(NULL), right(NULL){}
};

Node root_node = Node();
Node* root = &root_node;//根节点

/*
*使用内存池方式分配二叉树节点内存
*/
queue<Node*> freenodes;
Node node[maxn];

void memory_pool_init()
{
for (int i = 0; i < maxn; i++)
{
freenodes.push(&node[i]);
}
}

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

void deleteNode(Node*u)
{
freenodes.push(u);//将节点还回去就是释放了节点
}

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

/*
*使用动态内存分配的方式分配二叉树所使用的内存
*/
Node* newNode(){ return new Node(); }//使用new的时候就会调用构造函数，给新创建的节点初始化值

//使用递归的方法释放树节点
void remove_tree(Node* u)
{
if (u == NULL) return;
remove_tree(u->left);
remove_tree(u->right);
delete u;
}

bool failed;

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_static(); }//节点不存在创建新的节点
u = u->left;//向左移动一下
}
else if (s[i] == 'R')
{
if (u->right == NULL) { u->right = newNode_static(); }
u = u->right;
}
}
if (u->have_value) failed = true;//判断节点是否已经赋过值，如果已经赋过值表明结果有误
u->v = v;
u->have_value = true;
}

char s[maxn];

bool read_input()
{
failed = false;
while (1)
{
if (scanf("%s", &s) != 1) return false;
if (!strcmp(s, "()")) break; //读到“()”结束，退出循环
int v;
sscanf(&s[1], "%d", &v);
addnode(v, strchr(s, ',') + 1);
}
return true;
}

bool BFS(vector<int>& ans)
{
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()
{
memory_pool_init();
vector<int> ans;
while (read_input())
{
if (!BFS(ans)) failed = true;
if (failed) printf("not complete\n");
else for (auto i : ans) cout << i << " ";
cout << endl;
}

remove_tree_static(root);

return 0;

}