第十周项目一层次遍历算法

来源：互联网发布：伏尼契手稿知乎编辑：程序博客网时间：2024/06/09 13:58
烟台大学计算机学院  
  
作者:王雪行
  
问题描述：层次遍历算法的验证 
  
输入描述：无 
  
输出描述：层次遍历树的结果 
  
*/   
  
  
//btree2.h  
  
#include <stdio.h>  
#define MaxSize 100  
typedef char ElemType;  
  
typedef struct node  
{  
    ElemType data;  
  
    struct node *lchild;  
  
    struct node *rchild;  
}BTNode;  
  
typedef struct  
{  
    BTNode *data[MaxSize];  
  
    int front,rear;  
  
}SqQueue;  
  
void CreateBTNode(BTNode *&b,char *str);        //由str串创建二叉链  
BTNode *FindNode(BTNode *b,ElemType x);     //返回data域为x的节点指针  
BTNode *LchildNode(BTNode *p);      //返回*p节点的左孩子节点指针  
BTNode *RchildNode(BTNode *p);      //返回*p节点的右孩子节点指针  
int BTNodeDepth(BTNode *b);     //求二叉树b的深度  
void DispBTNode(BTNode *b);     //以括号表示法输出二叉树  
void DestroyBTNode(BTNode *&b);     //销毁二叉树  
void LevelOrder(BTNode *b);//层次遍历  
  
  
//btree2.cpp  
  
#include <malloc.h>  
#include <stdio.h>  
#include "btree2.h"  
void CreateBTNode(BTNode *&b,char *str)  
{  
    BTNode *St[MaxSize],*p;  
  
    int top=-1,k,j=0;  
  
    char ch;  
  
    b=NULL;  //建立的二叉树初始时为空  
  
  
    ch=str[j];  
  
    while(ch!='\0') //扫描字符串  
    {  
        switch(ch)//遇到字母。左右括号，逗号的操作  
        {  
            case '(':top++;  
            St[top]=p;  
            k=1;  
            break;  
            case ')':  
                top--;  
                break;  
                case ',':  
                    k=2;  
                break;  
                default:p=(BTNode*)malloc(sizeof(BTNode));  
                p->data=ch;  
                p->lchild=p->rchild=NULL;  
                if(b==NULL)  
                {  
                    b=p;  
                }  
                else  
                    {  
                        switch(k)  
                        {  
                            case 1:  
                            St[top]->lchild=p;  
                            break;  
                            case 2:  
                                St[top]->rchild=p;  
                                break;  
                        }  
                    }  
         }  
         j++;  
         ch=str[j];  
  
    }  
}  
  
void DestroyBTNode(BTNode *&b)  
{  
    if(b!=NULL)  
    {  
        DestroyBTNode(b->lchild);//销毁左子树  
        DestroyBTNode(b->rchild);//销毁右子树  
        free(b);//销毁根结点  
  
    }  
}  
  
BTNode *FindNode(BTNode *b,ElemType x)  
{  
    BTNode *p;  
    if(b==NULL)  
    {  
        return NULL;  
    }  
    else if(b->data==x)  
        return b;  
    else  
        {  
            p=FindNode(b->lchild,x);//递归查找该结点  
            if(p!=NULL)  
            {  
                return p;  
            }  
            else  
                return FindNode(b->rchild,x);  
        }  
}  
  
BTNode *LchildNode(BTNode *p)//求左子树  
{  
    return p->lchild;  
}  
BTNode *RchildNode(BTNode *p)//求右子树  
{  
    return p->rchild;  
}  
  
int BTNodeDepth(BTNode *b)  
{  
    int lchildh;  
  
    int rchildh;  
  
    if(b==NULL)  
        return 0;//空树  
    else  
    {  
        lchildh=BTNodeDepth(b->lchild);//递归求根结点左子树  
        rchildh=BTNodeDepth(b->rchild);//递归求根结点右子树  
        {  
            if(lchildh>rchildh)  
            {  
                return lchildh+1;  
            }  
            else  
                {  
                    return rchildh+1;  
                }  
        }  
  
  
    }  
}  
  
void DispBTNode(BTNode *b)//以括号表示法输出二叉树  
{  
    if(b!=NULL)  
    {  
        printf("%c",b->data);  
        if(b->lchild!=NULL || b->rchild!=NULL)  
        {  
            printf("(");  
            DispBTNode(b->lchild);  
            if(b->rchild!=NULL)  
            {  
                printf(",");  
                DispBTNode(b->rchild);  
            }  
            printf(")");  
  
        }  
    }  
}  
  
  
void LevelOrder(BTNode *b)  
{  
    BTNode *p;  
  
    BTNode *qu[MaxSize];  
  
    int front,rear;  
  
    front=rear=-1;  
  
    rear++;  
  
    qu[rear]=b;  
  
    while(front!=rear)//层次遍历循环队列  
    {  
        front=(front+1)%MaxSize;  
        p=qu[front];  
        printf("%c",p->data);  
        if(p->lchild!=NULL)  
        {  
            rear=(rear+1)%MaxSize;  
            qu[rear]=p->lchild;  
        }  
        if(p->rchild!=NULL)  
        {  
            rear=(rear+1)%MaxSize;  
            qu[rear]=p->rchild;  
        }  
    }  
}  
//main:  
  
#include <stdio.h>  
#include <malloc.h>  
#include "btree2.h"  
  
int main()  
{  
    BTNode *p;  
    CreateBTNode(p,"A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))");//创建二叉树  
    printf("输出二叉树\n");  
    DispBTNode(p);//输出二叉树  
  
    printf("层次遍历,输出结果\n");  
  
    LevelOrder(p);//层次遍历  
  
    DestroyBTNode(p);//销毁  
  
    return 0;  
  
}  
运行结果：
阅读全文
0 0
第十周项目一 层次遍历算法

第十周项目一层次遍历算法
