uva122 二叉树的实现和层次遍历(bfs)

Posted -ifrush

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了uva122 二叉树的实现和层次遍历(bfs)相关的知识,希望对你有一定的参考价值。

题目见紫书

6.3.2 二叉树的层次遍历

1.二叉树的实现:

a.用指针实现:用结构体记录结点,利用指针访问结点

其中变量left,right的值 new的返回值都是地址

/*二叉树的结点定义和操作*/
//结点类型
struct Node{
    bool have_value;                       //是否被赋值过
    int v;                                 //结点值
    Node *left,*right;
    Node():v(-1),have_value(false),left(NULL),right(NULL){}//构造函数 
}; 
Node* newnode(){return new Node()};        //申请新结点的函数 

 

b.用数组实现:

  计数器cnt为已存在的节点数(编号最大值),用编号代替地址访问结点,用数组 [编号]来访问节点,其中left[u],right[u]都是记录的编号,结构体中的成员变量成了全局数组。

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

 

其中指针是利用动态内存实现,需要一直申请新内存(new),为防止内存泄漏,需要释放内存

Node* newnode(){return new Node()};        //申请新结点的函数 

而数组是静态内存实现,编程简单,容易调试,不需释放动态内存,只要重置结点计数器和根结点的左有子树就行了.

可以用静态数组配合空闲列表实现一个简单的内存池,防止内存溢出(不太懂,先不学,以后再看,紫书154页)

 

二叉树的bfs要用队列来实现

//二叉树的bfs
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;                           //输入正确 
}

 

其他:

· 可以用new运算符申请空间并执行构造函数。如果返回值为NULL,说明空间不足,申请失败。

·  strchr

strchr是计算机编程语言的一个函数,原型为extern char *strchr(const char *s,char c),可以查找字符串s中首次出现字符c的位置。

 

 

指针实现如下:

注: u->v 其中u是结构指针;

         任何指针都不能为空指针!包括结构指针 Node * root; 若无root=newnode(); root就是空指针,错都不知道错到哪了;

       if(!strcmp(s,"()"))break;字符串比较就这样比较

//二叉树的动态实现与层次遍历
//new和delete是运算符,没有头文件 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int maxn=256+10;

bool failed;
struct Node{
    bool have_valued;
    int v;
    Node* left,*right;
    Node():have_valued(false),left(NULL),right(NULL){};
};
Node* root;                                           // 此时root为空指针 
Node* newnode(){return new Node;}
bool addnode(int v,char* s){
    Node* u=root;
    int n=strlen(s);
    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_valued)failed=true;
    else u->v=v;
    u->have_valued=true;
    return true;
}
void remove(Node* u){
    if(u==NULL)return;
    if(u->right!=NULL)remove(u->right);
    if(u->left!=NULL)remove(u->left);
    delete u;
}
char s[maxn];
bool input_read(){
    failed = false;
    root = newnode();
    int v;
    for(;;){
    if(scanf("%s",s)!=1)return false;
    if(!strcmp(s,"()"))break;
    sscanf(&s[1],"%d",&v);
    addnode(v,strchr(s,,)+1);
    }
    return true;
}

bool bfs(vector<int>& ans){
    ans.clear();
    queue <Node* > q;
    Node* u=root;
    q.push(u);
    while(!q.empty()){
        if(u->have_valued)
        ans.push_back(u->v);
        else return false;
        q.pop();
        if(u->left!=NULL)q.push(u->left);
        if(u->right!=NULL)q.push(u->right);
        u=q.front();
    } 
    return true;
}


int main(){
    vector <int> ans;
    while(input_read()){
    if(!bfs(ans))failed=true;
    if(failed)printf("not complete
");
    else {for(int i=0;i<ans.size();i++){
            if(i!=0)printf(" ");
            printf("%d",ans[i]);
         }printf("
");
    }
    }
    return 0;
}

数组实现也差不多,用left【】right【】储存指针域,跟链表似的:

//二叉树的静态(数组)实现与层次遍历
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int maxn=256+10;
const int root=1; 

bool failed;
int cnt=1;
int left[maxn];
int right[maxn];
int value[maxn];
bool have_value[maxn];
int newnode(){int u=++cnt;left[u]=0;
    right[u]=0;have_value[u]=false;
    return u;}
bool addnode(int v,char* s){
    int n=strlen(s),t=root;
    for(int i=0;i<n;i++){
        if(s[i]==L){
        if(left[t]==0)left[t]=newnode();
        t=left[t];
        }
        if(s[i]==R){
        if(right[t]==0)right[t]=newnode();
        t=right[t];
        }
    }
   // printf("have value[%d]=%d
",t,have_value[t]);
    if(have_value[t]==true)failed=true;
    else have_value[t]=true;
    value[t]=v;
    return true;
}

void newtree(){             //相当于动态里newnode结构体拆开,因为是静态数组,无需申请内存 
    cnt=root;
    right[root]=0;
    left[root]=0;
    have_value[root]=false;
}
char s[maxn];
bool input_read(){
    failed = false;
    newtree();
    int v;
    for(;;){
    if(scanf("%s",s)!=1)return false;
    if(!strcmp(s,"()"))break;
    sscanf(&s[1],"%d",&v);
    //printf("%s
",strchr(s,‘,‘)+1);
    addnode(v,strchr(s,,)+1);
    }
    return true;
}

bool bfs(vector<int>& ans){
    ans.clear();
    queue <int> qcnt;
    int u=1;
    qcnt.push(u);
    while(!qcnt.empty()){
        u=qcnt.front();//printf("bfs-%d
",u);
        if(have_value[u]==false){return false;}
        qcnt.pop();
        ans.push_back(value[u]);
        if(left[u]!=0)qcnt.push(left[u]);
        if(right[u]!=0)qcnt.push(right[u]);
    }
    return true;
}


int main(){
    memset(have_value,false,sizeof(have_value));
    memset(left,0,sizeof(left));
    memset(right,0,sizeof(right));
    vector <int> ans;
    while(input_read()){
    if(!bfs(ans))failed=true;
    if(failed)printf("not complete
");
    else {for(int i=0;i<ans.size();i++){
            if(i!=0)printf(" ");
            printf("%d",ans[i]);
         }printf("
");
    }
    }
    return 0;
}

 

以上是关于uva122 二叉树的实现和层次遍历(bfs)的主要内容,如果未能解决你的问题,请参考以下文章

UVA122 二叉树的层次遍历

Uva 122 树的层次遍历 Trees on the level lrj白书 p149

UVa 122 Trees on the level(链式二叉树的建立和层次遍历)

6-7 树的层次遍历 uva122

紫书例题6-7 树的层次遍历

二叉树的层次遍历(BFS)