第4章第1节练习题2 二叉树的基本操作（非递归实现）

最新推荐文章于 2018-07-11 21:47:27 发布
最新推荐文章于 2018-07-11 21:47:27 发布
阅读量2.8k 收藏 6
点赞数 3
分类专栏： Data Structure 数据结构与算法 文章标签： 数据结构 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013595419/article/details/51531461
版权

二叉树的非递归遍历

上一节二叉树的递归遍历中简单介绍了二叉树的递归遍历的实现方式，本节主要介绍二叉树的非递归遍历实现，继续引用上节的例子来说明下。

Order

一.先序遍历

二叉树先序遍历的访问顺序为：根结点->左孩子->右孩子。简单的说，对于任意一个结点，均可以看作是根结点，直接对其访问，如果访问完成后，左孩子不为空，则可以将该左孩子再次看成一个新的根结点，那么就又回到开始，访问根结点，访问左孩子，如果左孩子为空时，访问它的右孩子。对于一般程序而言，递归程序转为非递归程序需要引入栈这个数据结构，可以参考第2章第1节 栈的基本定义以及实现方式，其处理过程可以简单分为三步：

对于任一结点T：

  1. 访问结点T，并将结点T入栈;
  2. 判断结点T的左孩子是否为空，若不为空，则将结点T的左孩子入栈；再判断T的右孩子是否为空，若不为空，则将结点T的右孩子入栈；若为左孩子或右孩子为空，则出栈访问。这里应该注意到栈的先进后出的特性，因此需要先将右孩子入栈，再将左孩子入栈；
  3. 最后直到栈为空便结束访问。

算法描述如下：

void PreOrder(BiTNode* T){
    SqStack S;
    InitStack(&S);

    BiTNode* p=T;
    Push(&S,p);
    while(IsEmptyStack(&S)!=0){
        p=Pop(&S);
        printf("%c",p->data);
        if(p->rchild!=NULL){
            Push(&S,p->rchild);
        }
        if(p->lchild!=NULL){
            Push(&S,p->lchild);
        }
    }
}

二.中序遍历

二叉树中序遍历的访问顺序为左孩子->根结点->右孩子。简单来说就是：先扫描（不访问）根结点的所有左孩子并将它们一一入栈，然后出栈一个结点*p并且访问它，然后扫描该结点*p的右孩子，并将其入栈，再扫描以该结点*p的右孩子为根结点的所有左孩子，并将其一一入栈，如此继续，直到栈为空为止。其处理过程可以简单分为三步：

对于任一结点T：

  1. 首先判断结点T是否为空，若不为空，则将其入栈，然后让指针p指向结点T的左孩子；接着继续重复该步骤，直到结点T为空为止；
  2. 经过第一步可以保证栈顶元素一定是该二叉树最左的孩子结点，然后出栈访问该结点，接着判断其右孩子是否为空，若不为空，接着扫描右孩子的左孩子结点，重复第1步；
  3. 最后直到栈为空时便结束访问。

算法描述如下：

void InOrder(BiTNode* T){
    SqStack S;
    InitStack(&S);

    BiTNode* p=T;

    while(p||IsEmptyStack(&S)!=0){
        if(p!=NULL){
            Push(&S,p);
            p=p->lchild;
        }else{
            p=Pop(&S);
            printf("%c",p->data);
            p=p->rchild;
        }
    }
}

三. 后序遍历

二叉树中序遍历的访问顺序为左孩子->右孩子->根结点。因为后序非递归遍历二叉树的顺序是先访问左孩子，再访问右孩子，最后访问根结点。所以当用栈来存储结点时，必须分清返回根结点时是从左孩子返回的还是从右孩子返回的，需要设置一个辅助指针r，让其指向最近访问过的结点。其处理过程可以简单分为三步：

对于任一结点T：

  1. 首先判断根结点是否为空，若不为空，则不断的入栈直到最左边的左孩子结点为止；
  2. 接着取出栈顶结点，判断其右孩子是否为空，而且其右孩子没有被访问过，接着对其右孩子入栈，再重复第1，2步；
  3. 但是若右孩子为空，则出栈访问，并对该结点标记。

算法描述如下：

void PostOrder(BiTNode* T){
    SqStack S;
    InitStack(&S);

    BiTNode *p=T;
    BiTNode *r=NULL;

    while(p||IsEmptyStack(&S)!=0){
        if(p!=NULL){
            Push(&S,p);
            p=p->lchild;
        }else{
            p=GetTop(&S);
            if(p->rchild!=NULL&&p->rchild!=r){
                p=p->rchild;
                Push(&S,p);
                p=p->lchild;
            }else{
                p=Pop(&S);
                printf("%c",p->data);
                r=p;
                p=NULL;
            }
        }
    }
}

四.层次遍历

一般的二叉树层次遍历是自上而下，自左向右。简单来说就是先访问根结点，然后访问其左孩子，右孩子，可以借助队列的特性先进先出来实现层次遍历，可以参考第2章第2节 队列的基本定义以及实现方式，其处理过程可以简单分为三步：

对于任一结点T：

  1. 访问结点T，然后将结点T入队；
  2. 出队访问该结点，然后判断其左孩子和右孩子是否为空，如果不为空，则分别将其入队；
  3. 若为空，出队访问便可；
void PostOrder(BiTNode* T){
    SqStack S;
    InitStack(&S);

    BiTNode *p=T;
    BiTNode *r=NULL;

    while(p||IsEmptyStack(&S)!=0){
        if(p!=NULL){
            Push(&S,p);
            p=p->lchild;
        }else{
            p=GetTop(&S);
            if(p->rchild!=NULL&&p->rchild!=r){
                p=p->rchild;
                Push(&S,p);
                p=p->lchild;
            }else{
                p=Pop(&S);
                printf("%c",p->data);
                r=p;
                p=NULL;
            }
        }
    }
}

具体代码见附件

附件

//AB#DF###C#E##
#include<stdio.h>
#include<stdlib.h>

#define MaxSize 100
typedef char ElemType;

/*-----------------------------------------*/

typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

BiTNode* CreateBiTree(BiTNode*);
void PreOrder(BiTNode*);
void InOrder(BiTNode*);
void PostOrder(BiTNode*);
void LevelOrder(BiTNode*);

/*-----------------------------------------*/

typedef struct SqStack{
    BiTNode* data[MaxSize];
    int top;
}SqStack;

void InitStack(SqStack*);
void Push(SqStack*,BiTNode*);
BiTNode* Pop(SqStack*);
BiTNode* GetTop(SqStack*);
int IsEmptyStack(SqStack*);

typedef struct SqQueue{
    BiTNode* data[MaxSize];
    int front, rear;
}SqQueue;

void InitQueue(SqQueue*);
void EnQueue(SqQueue*, BiTNode*);
BiTNode* DeQueue(SqQueue*);
int IsEmptyQueue(SqQueue*);

/*-----------------------------------------*/

int main(int argc, char* argv[]){
    BiTNode *T=(BiTNode*)malloc(sizeof(BiTNode));
    T=CreateBiTree(T);
    PreOrder(T);printf("\n");
    InOrder(T);printf("\n");
    PostOrder(T);printf("\n");
    LevelOrder(T);printf("\n");
    return 0;
}

//创建二叉树
BiTree CreateBiTree(BiTNode* T){
    ElemType x;
    scanf("%c",&x);
    if(x=='#'){
        return T;
    }else{
        T=(BiTNode*)malloc(sizeof(BiTNode));
        T->data=x;
        T->lchild=CreateBiTree(T->lchild);
        T->rchild=CreateBiTree(T->rchild);
    }
    return T;
}

//先序遍历
void PreOrder(BiTNode* T){
    SqStack S;
    InitStack(&S);

    BiTNode* p=T;
    Push(&S,p);
    while(IsEmptyStack(&S)!=0){
        p=Pop(&S);
        printf("%c",p->data);
        if(p->rchild!=NULL){
            Push(&S,p->rchild);
        }
        if(p->lchild!=NULL){
            Push(&S,p->lchild);
        }
    }
}

//中序遍历
void InOrder(BiTNode* T){
    SqStack S;
    InitStack(&S);

    BiTNode* p=T;

    while(p||IsEmptyStack(&S)!=0){
        if(p!=NULL){
            Push(&S,p);
            p=p->lchild;
        }else{
            p=Pop(&S);
            printf("%c",p->data);
            p=p->rchild;
        }
    }
}

//后序遍历
void PostOrder(BiTNode* T){
    SqStack S;
    InitStack(&S);

    BiTNode *p=T;
    BiTNode *r=NULL;

    while(p||IsEmptyStack(&S)!=0){
        if(p!=NULL){
            Push(&S,p);
            p=p->lchild;
        }else{
            p=GetTop(&S);
            if(p->rchild!=NULL&&p->rchild!=r){
                p=p->rchild;
                Push(&S,p);
                p=p->lchild;
            }else{
                p=Pop(&S);
                printf("%c",p->data);
                r=p;
                p=NULL;
            }
        }
    }
}

//层次遍历
void LevelOrder(BiTNode* T){
    SqQueue Q;
    InitQueue(&Q);

    BiTNode *p=T;
    EnQueue(&Q,p);

    while(IsEmptyQueue(&Q)!=0){
        p=DeQueue(&Q);
        printf("%c",p->data);
        if(p->lchild!=NULL){
            EnQueue(&Q,p->lchild);
        }
        if(p->rchild!=NULL){
            EnQueue(&Q,p->rchild);
        }
    }
}

/*-----------------------------------------*/

void InitStack(SqStack* S){
    S->top=-1;
}

void Push(SqStack* S, BiTNode* T){
    if(S->top==MaxSize-1){
        return;
    }
    S->data[++S->top]=T;
}

BiTNode* Pop(SqStack* S){
    if(S->top==-1){
        return NULL;
    }
    return S->data[S->top--];

}

BiTNode* GetTop(SqStack* S){
    if(S->top==-1){
        return NULL;
    }
    return S->data[S->top];
}

int IsEmptyStack(SqStack* S){
    if(S->top==-1){
        return 0;
    }
    return -1;
}

/*-----------------------------------------*/

void InitQueue(SqQueue* Q){
    Q->front=0;
    Q->rear=0;
}

void EnQueue(SqQueue* Q, BiTNode* T){
    if((Q->rear+1)%MaxSize==Q->front){
        return;
    }
    Q->data[Q->rear++]=T;
}

BiTNode* DeQueue(SqQueue* Q){
    if(Q->front==Q->rear){
        return NULL;
    }
    return Q->data[Q->front++];
}

int IsEmptyQueue(SqQueue* Q){
    if(Q->front==Q->rear){
        return 0;
    }
    return -1;
}
法海你懂不
关注
专栏目录
非递归遍历二叉树
重剑无锋
09-05 5万+
1.先序遍历从递归说起void preOrder(TNode* root){    if (root != NULL)    {        Visit(root);        preOrder(root->left);        preOrder(root->right);    }}递归算法非常的简单。先访问跟节点，然后访问左节点，
第四章-树与二叉树 ----习题
热门推荐
u011587070的专栏
09-08 1万+
1.给定二叉树如图 A-1 所示。设 N 代表二叉树的根， L 代表根结点的左子树， R 代表根结点的右子树。若遍历后的结点序列是 3 ， 1 ， 7 ， 5 ， 6 ， 2 ， 4 ，则其遍历方式是 D                               LRN NRL RLN RNL 前序遍历：根结点 -&gt; 左子树 -&gt; ...
递归非递归实现树的遍历
cxh342968816的专栏
08-05 856
1.先序遍历 从递归说起 void preOrder(TNode* root){    if (root != NULL)    {        Visit(root);        preOrder(root->left);        preOrder(ro
数据结构第6章二叉树练习题.doc
12-29
数据结构第六章二叉树练习题 本资源是一个关于数据结构的练习题，专门针对二叉树的知识点。该资源包含了多个问题，涵盖了二叉树的定义、性质、遍历方法、存储结构等方面的知识点。 1. 二叉树的定义：二叉树是一种...
Java程序设计与数据结构第九章习题答案
12-11
第九章的习题可能会涉及创建、初始化、遍历和操作数组，以及解决基于数组的问题，如查找、排序等。 2. **链表**：链表与数组不同，它的元素在内存中不是连续存储的。链表由节点组成，每个节点包含数据和指向下一个...
Java程序设计与数据结构第五章习题答案
11-05
第五章通常会深入探讨这个主题，涵盖数组、链表、栈、队列、树等基本数据结构以及它们在实际编程中的应用。下面将详细阐述这部分内容的知识点。 1. **数组**：数组是Java中最基本的数据结构，它允许存储同类型的...
二叉树习题
01-16
此外，还要能够解决具体问题，如求二叉树的结点平均值、交换子树、构造二叉树、找到后根遍历的第一个结点、非递归后根遍历、确定结点层次，以及构建哈夫曼树和生成哈夫曼编码。完成这些任务有助于深化对二叉树的理解...
二叉树非递归遍历
10-23
数据结构的代码实现，非递归算法，。
【刷题】二叉树非递归遍历
weixin_34185364的博客
10-16 135
原题链接： binary-tree-preorder-traversal binary-tree-inorder-traversal binary-tree-postorder-traversal 整体思路 三道题的解决思路可统一，模板也极其相似，比九章提供的更漂亮。 将二叉树分为“左”（包括一路向左，经过的所有实际左+根）、“右”（包括实际的右）两种节点 使用同样的顺序将“左”节点入栈 ...
二叉树的非递归遍历
我的梦
07-11 3031
本文全部参考自：https://blog.csdn.net/gogogo_sky/article/details/70145550 特别感谢，大家一起学习吧。 在我们了解了最简单的递归遍历以后，现在来说说用栈辅助，非递归实现二叉树的前序，中序，后序遍历打印 一、非递归实现前序遍历打印 前序遍历，访问的顺序为根-&gt;左-&gt;右； 前序遍历的思想： （1）首先定义...
二叉树理论与习题解析
"数据结构 第6章二叉树" 二叉树是数据结构中的一个重要概念，它是一种特殊的树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。本章主要探讨了二叉树的相关性质、形态以及操作。 在二叉树的自我...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值