详解二叉树的遍历问题（前序、后序、中序、层序遍历的递归算法及非递归算法及其详细图示）

最新推荐文章于 2022-11-19 09:40:20 发布
最新推荐文章于 2022-11-19 09:40:20 发布
阅读量1.3k 收藏 27
点赞数 6
分类专栏： 经典编程题——二叉树与树 经典编程问题 文章标签： 二叉树 数据结构 栈 队列 二叉树遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44162361/article/details/116984005
版权

文章目录

二叉树的遍历

 所谓二叉树的遍历，是指按照某条搜索路径访问树中的每个结点，使得每个结点均被访问一次，且仅被访问一次。
 由二叉树的递归定义可知，遍历一棵二叉树便要决定对根结点N、左子树L和右子树R的访问顺序。按照先遍历左子树再遍历右子树的原则，常见的遍历次序有先序（NLR）、中序（LNR）和后序（LRN）三种遍历算法，其中“序”指的是根结点在何时被访问。

 二叉树的结点类型描述如下：

typedef struct BNode{
    char data;
    struct BNode *lchild;
    struct BNode *rchild;
}BNode;

 在给出具体算法之前，先给出算法中的实例，以供参考。
 需要遍历的二叉树：
在这里插入图片描述

 前序遍历：ABDECFG
 中序遍历：DBEAFCG
 后序遍历：DEBFGCA
 层序遍历：ABCDEFG

先序遍历（前序遍历）

先序遍历（PreOrder）的操作过程如下：
若二叉树为空，则什么也不做，否则：
1）访问根结点；
2）先序遍历左子树；
3）先序遍历右子树；

先序遍历的递归算法
void PreOrder(BNode *root){
    if(root != NULL){
        printf("%c ",root->data); //访问根结点
        PreOrder(root->lchild); //递归遍历左子树
        PreOrder(root->rchild); //递归遍历右子树
    }
}
先序遍历的非递归算法

 将二叉树的先序遍历的递归算法转换成非递归算法时，需要借助栈。
 声明一个遍历指针p，初始指向根结点。
 如果p指向的结点不为空，则访问该结点，输出结点值，并将该根结点的地址入栈，然后将p指向根结点的左子树。
 如果p指向的结点为空，那么用top记录栈顶元素，将栈顶结点出栈，然后再往栈顶结点的右子树走。

 在先序遍历中，栈中的元素都是自己本身和自己的左孩子都访问过了，而右孩子还没有访问到的结点。

 实现代码：

void PreOrder2(BNode *root){
    stack<BNode *> treenode; //申请一个栈，栈中保存的是结点地址
    BNode *p = root; //p是遍历指针
    BNode *top; //指向当前的栈顶元素
    while(p != NULL || !treenode.empty()){//p不空或者栈不空时循环
        if(p != NULL){
            printf("%c ",p->data); //访问当前根结点
            treenode.push(p); //结点进栈
            p = p->lchild; //指向当前结点的左子树
        }else{
            top = treenode.top(); //栈顶结点
            treenode.pop(); //出栈
            p = top->rchild; //再往右子树走
        }
    }
}
先序遍历的非递归算法图示

 首先给出需要遍历的二叉树：
在这里插入图片描述

1）创建一个空栈，初始化遍历指针p，其初始值指向根结点*root，并声明一个指针top，用于以后存储栈顶元素。

  注意：为了便于理解，在以下的图中栈中的内容为该结点的结点值，而在具体实现代码中，栈中存放的则是该结点地址。
在这里插入图片描述

2）p不空或栈不空时循环。

2.1）若p不为空，则访问当前根结点A，然后将该结点进栈，最后将p指向该根结点的左子树B。
在这里插入图片描述

2.2）若p不为空，则访问当前根结点B，然后将该结点进栈，最后将p指向该根结点的左子树D。
在这里插入图片描述

2.3）若p不为空，则访问当前根结点D，然后将该结点进栈，最后将p指向该根结点的左子树。
在这里插入图片描述

2.4）若p为空，则将top指向栈顶的结点D，然后将结点D出栈，最后将遍历指针p指向该栈顶结点D的右子树。
在这里插入图片描述

2.5）若p为空，则将top指向栈顶结点B，然后将栈顶结点B出栈，最后将遍历指针p指向栈顶结点B的右子树E。
在这里插入图片描述

2.6）若p不为空，则访问当前根结点E，然后将该结点进栈，最后将p指向该结点的左子树。
在这里插入图片描述

2.7）若p为空，则将top指向栈顶结点E，然后将栈顶结点E出栈，最后将遍历指针p指向该栈顶结点E的右子树。
在这里插入图片描述

2.8）若p为空，则将top指向当前栈顶结点A，然后将栈顶结点A出栈，最后将遍历指针p指向该栈顶结点A的右子树C。
在这里插入图片描述

2.9）若p不为空，则访问当前根结点C，并将该结点入栈，最后将p指向该根结点C的左子树F。
在这里插入图片描述

2.10）若p不为空，则访问当前根结点F，并将该结点入栈，最后将p指向该根结点F的左子树。
在这里插入图片描述

2.11）若p为空，则将top指向栈顶结点F，然后将栈顶结点F出栈，最后将遍历指针p指向该栈顶结点F的右子树。
在这里插入图片描述

2.12）若p为空，则将top指向栈顶结点C，然后将该栈顶结点C出栈，最后将遍历指针p指向该栈顶结点C的右子树G。
在这里插入图片描述

2.13）若p不为空，则访问当前根结点G，并将该结点入栈，最后将p指向该根结点G的左子树。
在这里插入图片描述

2.14）若p为空，则将top指向栈顶结点G，然后将栈顶结点G出栈，最后将遍历指针p指向该栈顶结点G的右子树。
在这里插入图片描述

3）当p为空且栈为空时，结束循环，遍历完成。
在这里插入图片描述

 所以当前树的前序遍历为ABDECFG。

 显然非递归算法的执行效率要高于递归算法。

中序遍历

中序遍历（InOrder）的操作过程如下：
若二叉树为空，则什么也不做，否则：
1）中序遍历左子树；
2）访问根结点；
3）中序遍历右子树。

中序遍历的递归算法
void InOrder(BNode *root){
    if(root != NULL){
        InOrder(root->lchild); //递归遍历左子树
        printf("%c ",root->data); //访问根结点
        InOrder(root->rchild); //递归遍历右子树
    }
}
中序遍历的非递归算法

 对于中序遍历的递归算法，将其转换为非递归算法，需要借助栈。

 先扫描（并不是访问）根结点的所有左子树并将它们一一进栈，然后出栈一个结点*p（显然结点*p没有左孩子结点或左孩子结点均已访问过），访问结点*p。
 然后扫描该结点的右孩子结点，将其进栈，再扫描该右孩子结点的所有左结点并一一进栈，如此继续，直到栈空为止。

 中序遍历与前序遍历不同的是，前序遍历时，栈中保存的元素是右子树还没有被访问到的结点地址，而中序遍历时，栈中保存的元素是结点自身和它的右子树中没有被访问到的结点地址。

 实现代码：

void InOrder2(BNode *root){
    stack<BNode *> treenode; //申请一个栈
    BNode *p = root; //p是遍历指针
    while(p != NULL || !treenode.empty()){ //栈不空或p不空时循环
        if(p != NULL){ //根指针进栈，遍历左子树
            treenode.push(p); //每次遇到非空二叉树先向左走
            p = p->lchild;
        }else{ //根指针退栈，访问根结点，遍历右子树
            p = treenode.top(); //p指向栈顶元素
            treenode.pop(); //退栈
            printf("%c ",p->data); //访问当前根结点
            p = p->rchild; //再向右子树走
        }
    }
}

 细心的读者可能注意到，中序遍历时没有重新声明一个指针top记录栈顶元素，而是直接用p来记录，这两种方法都是可以的（最终p都会指向栈顶结点的右孩子）。

中序遍历非递归算法的图示

 首先给出需要遍历的二叉树：
在这里插入图片描述

1）创建一个空栈，并初始化遍历指针p，初始值指向根结点*root。

  注意：为了便于理解，在以下的图中栈中的内容为该结点的结点值，而在具体实现代码中，栈中存放的则是该结点地址。
在这里插入图片描述

2）p不空或栈不空时循环。

2.1）如果p不空，则根指针进栈，p指向该根结点A的左子树B。
在这里插入图片描述

2.2）如果p不空，则当前根指针进栈，p指向该根结点B的左子树D。
在这里插入图片描述

2.3）如果p不空，则当前根结点D进栈，p指向该根结点D的左子树。
在这里插入图片描述

2.4）如果p为空，则当前栈顶根结点D退栈，访问当前根结点D，再向右子树走。
在这里插入图片描述

2.5）如果p为空，则栈顶根结点B退栈，访问该根结点B，然后再向右子树E走。
在这里插入图片描述

2.6）如果p不空，则将当前根结点E入栈，p指向该根结点E的左子树。
在这里插入图片描述

2.7）如果p为空，则当前栈顶的根结点E退栈，访问该根结点E，然后再往右子树走。
在这里插入图片描述

2.8）如果p为空，则当前栈顶的根结点A退栈，访问该根结点A，然后再往右子树C走。
在这里插入图片描述

2.9）如果p不空，则将根结点F入栈，然后将p指向该根结点C的左子树F。
在这里插入图片描述

2.10）如果p不空，则将该根结点F入栈，将p指向该根结点F的左子树。
在这里插入图片描述

2.11）如果p为空，则将当前栈顶的根结点F退栈，访问该根结点F，然后再往右子树走。
在这里插入图片描述

2.12）如果p为空，则当前栈顶的根结点C退栈，访问该根结点C，然后再往右子树G走。
在这里插入图片描述

2.13）如果p不空，则将该根结点G入栈，然后将p指向该结点G的左子树。
在这里插入图片描述

2.14）如果p为空，则将当前栈顶的根结点G出栈，访问该根结点G，然后再往右子树走。
在这里插入图片描述

3）如果p为空且栈也为空，则退出循环，遍历完成。
在这里插入图片描述

 所以当前树的中序遍历为DBEAFCG。

 显然非递归算法的执行效率要高于递归算法。

后序遍历

后序遍历（PostOrder）的操作过程如下：
若二叉树为空，则什么也不做，否则：
1）后序遍历左子树；
2）后序遍历右子树；
3）访问根结点。

后序遍历的递归算法
void PostOrder(BNode *root){
    if(root != NULL){
        PostOrder(root->lchild); //递归遍历左子树
        PostOrder(root->rchild); //递归遍历右子树
        printf("%c ",root->data); //访问根结点
    }
}
后序遍历的非递归算法

 后序遍历的递归算法转换为非递归算法时，也是需要借助栈来保存元素。
 从根结点开始，沿着左子树一直往下走，直到左子树为空。
 然后再用top指针记录栈顶元素：
 如果top指针指向的结点右子树为空或者last指向的结点，则说明top的右子树不存在或者已经遍历过了，那么弹出栈顶元素，访问top指向的结点，输出该结点值。
 否则，说明是从左子树返回当前根结点的，那么就将遍历指针p指向top的右子树，去遍历右子树。

 栈中保存的是它的右子树和自身都没有被遍历到的结点，与中序遍历不同地方的是，先访问右子树，在访问完右子树后再输出根结点的值。这就需要多一个last指针来指向上一次访问到的结点，用来确认是从根结点的左子树还是右子树返回的。

 【tips】访问一个结点*p时，栈中结点恰好是*p结点的所有祖先。从栈底到栈顶结点再加上*p结点，刚好构成从根结点到*p结点的一条路径。在很多题目中都运用了这一特性求解，如根结点到某结点的路径、求两个结点的最近公共祖先等，都可以利用这个思路求解。

 实现代码：

void PostOrder2(BNode *root){
    stack<BNode *> treenode;
    BNode *p = root; //p是遍历指针
    BNode *top,*last = NULL; 
    while(p != NULL || !treenode.empty()){ //p不空或者栈不空时循环
        if(p != NULL){ //走到最左边的结点
            treenode.push(p); //当前根指针入栈
            p = p->lchild; //向左子树走
        }else{ //向右
            top = treenode.top(); //top栈顶指针
            if(top->rchild == NULL || top->rchild == last){ //右子树为空或者已经被遍历过
                treenode.pop(); //栈顶指针出栈
                printf("%c ",top->data); //输出该结点值
                last = top; //last指针指向当前top指针指向的结点
                p = NULL; //重置p指针
            }else{ //右子树存在且未被访问过
                p = top->rchild; //p指向当前top指针指向的结点的右子树
                //下面这两句可以不用写，与第一个if是对应的，主要就是找到右子树的最左结点;但加上可以减少一次循环
                //treenode.push(p); //压入栈
                //p = p->lchild; //再走向最左
            }
        }
    }
}
后序遍历非递归算法的图示

 首先给出需要遍历的二叉树：
在这里插入图片描述

1）创建一个空栈，初始化遍历指针p，其初始值指向根结点*root，并声明一个指针top，用于以后存储栈顶元素。声明一个last指针，初始值为空。

  注意：为了便于理解，在以下的图中栈中的内容为该结点的结点值，而在具体实现代码中，栈中存放的则是该结点地址。

在这里插入图片描述

2）当p不空或栈不空时循环。

2.1）若p不为空，则当前根结点A进栈，p指向当前根结点A的左子树B。
在这里插入图片描述

2.2）若p不为空，则将当前根结点B入栈，并将p指向当前根结点B的左子树D。
在这里插入图片描述

2.3）若p不为空，则将当前根结点D入栈，并将p指向当前根结点D的左子树。
在这里插入图片描述

2.4）若p为空，则top等于当前栈顶元素，指向结点D（注意此时结点D还未出栈）。
 如果top指向的结点D的右子树为空或者为last指针指向的结点，说明top的右子树不存在或者是已经遍历过，则栈顶结点D出栈，访问该结点。last指针指向当前top指向的结点。
在这里插入图片描述

2.5）若p为空，则top等于当前栈顶元素，指向结点B。
 如果top指向的结点B的右子树既不空也不是last指针指向的结点，那么p就指向当前top指向的结点B的右子树E。
在这里插入图片描述

2.6）若p不为空，则将当前根结点E入栈，p指向当前根结点E的左子树。
在这里插入图片描述

2.7）若p为空，则top等于当前栈顶元素，指向结点E。
 如果top指向结点的的右子树为空或者为last指针指向的结点，说明top的右子树不存在或者是已经遍历过，则栈顶结点E出栈，访问该结点。last指针指向当前top指向的结点。
在这里插入图片描述

2.8）如果p为空，则top等于当前栈顶元素，指向结点B。
 如果top指向的结点的右孩子为空或者为last指向的结点，说明top的右子树不存在或者已经遍历过，则栈顶结点B出栈，访问该结点B。last指针指向当前top指向的结点。
在这里插入图片描述

2.9）如果p为空，则top等于栈顶元素，指向结点A。
 如果top指向的结点A的右子树不为空且不是last指针指向的结点，则p指向当前top指向的结点的右子树C。
在这里插入图片描述

2.10）若p不为空，则将当前根结点C入栈，将p指向当前根结点C的左子树F。
在这里插入图片描述

2.11）若p不为空，则将当前根结点F入栈，将p指向当前根结点F的左子树。
在这里插入图片描述

2.12）若p为空，则top等于当前栈顶元素，指向结点F。
 如果top指向的结点F的右子树为空或者为last指向的结点，则栈顶结点F出栈，访问该结点F。last指针指向当前top指向的结点。
在这里插入图片描述

2.13）若p为空，则top等于当前栈顶元素，指向结点C。
 如果top指向的结点C的右子树不为空且不为last指向的结点，则p指向当前top指向的结点的右子树G。
在这里插入图片描述

2.14）若p不为空，则将当前根结点G入栈，将p指向当前根结点G的左子树。
在这里插入图片描述

2.15）若p为空，则top等于当前栈顶元素，指向结点G。
 如果top指向的结点的右子树为空或者为last指向的结点，则说明top指向的结点的右子树不存在或者已经遍历过，则栈顶结点G出栈，访问该结点G，将last指针指向当前top指向的结点。
在这里插入图片描述

2.16）若p为空，则top等于当前栈顶元素，指向结点C。
 如果top指向的结点C的右子树为空或者等于last指向的结点，则栈顶结点C出栈，访问该结点C，将last指针指向top指向的结点。
在这里插入图片描述

2.17）若p为空，则top等于当前栈顶元素，指向结点A。
 如果top指向的结点A的右子树为空或者为last指针指向的结点，则将栈顶结点A出栈，访问该结点A，最后将last指针指向top指向的结点A。
在这里插入图片描述

3）当p为空且栈为空时，结束循环，遍历完成。
在这里插入图片描述

 所以当前树的后序遍历为DEBFGCA。

 显然非递归算法的执行效率要高于递归算法。

层序遍历

 如下图所示即为二叉树的层序遍历，即按照从上到下、从左到右的顺序依次访问每一层，直至每个结点被访问且仅被访问一次。

在这里插入图片描述

 要进行层序遍历，需要借助一个队列。
 先将二叉树的根结点入队，然后出队，访问该结点；若它有左子树，则将左子树根结点入队；若它有右子树，则将右子树根结点入队。然后出队，对出队结点进行访问，如此反复，直到队列为空。

void LevelOrder(BNode *root){
    queue<BNode *> treenode; //队列存储结点
    if(root != NULL)
        treenode.push(root); //根结点入队
    while(!treenode.empty()){
        BNode *p = treenode.front(); 
        treenode.pop(); //根结点出队
        printf("%c ",p->data); //输出队首元素，即当前访问的结点值
        if(p->lchild != NULL){
            treenode.push(p->lchild);//如果有左子树，则将左子树的根结点入队
        }
        if(p->rchild != NULL){
            treenode.push(p->rchild);//如果有右子树，则将右子树的根结点入队
        }
    }
}

 层序遍历的算法图示：

 首先给出需要遍历的二叉树：
在这里插入图片描述

1）声明一个空队列用来存储结点指针。当根结点不为空时，根结点入队。
 为了便于理解，以下队列中的元素均为该结点值.
在这里插入图片描述

2）当队列不空时循环。
2.1）声明一个指针p，p指向当前队首元素所指向的结点。将当前根结点出队，并访问该根结点A。
 如果该根结点有左子树，将左子树的根结点B入队。
 如果该根结点有右子树，将右子树的根结点C入队。
在这里插入图片描述

2.2）p指向队首元素所指向的结点B。将队首根结点出队，并访问该结点B。
 如果该根结点有左子树，将左子树的根结点D入队。
 如果该根结点有右子树，将右子树的根结点E入队。
在这里插入图片描述

2.3）p指向队首元素所指向的结点C。将队首根结点出队，并访问该结点C。
 如果该根结点有左子树，将左子树的根结点F入队。
 如果该根结点有右子树，将右子树的根结点G入队。
在这里插入图片描述

2.4）p指向队首元素所指向的结点D。将队首根结点出队，并访问该结点D。
 由于该根结点没有左子树，也没有右子树，故if中的语句不执行。
在这里插入图片描述

2.5）p指向队首元素所指向的结点E。将队首根结点出队，并访问该结点E。
 由于该根结点没有左子树，也没有右子树，故if中的语句不执行。
在这里插入图片描述

2.6）p指向队首元素所指向的结点F。将队首根结点出队，并访问该结点F。
 由于该根结点没有左子树，也没有右子树，故if中的语句不执行。
在这里插入图片描述

2.7）p指向队首元素所指向的结点G。将队首根结点出队，并访问该结点G。
 由于该根结点没有左子树，也没有右子树，故if中的语句不执行。
在这里插入图片描述

3）队列为空时，结束循环，遍历完成。
在这里插入图片描述

 故该二叉树的层序遍历为ABCDEFG。

二叉树的建立

二叉树的前序遍历存储在字符数组str中，根据这个字符序列建立一个二叉树，其中’#'表示空结点。

//建立二叉树
int i; //标记当前处理的字符位置
char str[100]; //读取的字符串
BNode *BuildTree(){
    if(str[i] == '#'){ //空结点
        i++; //准备处理下一个字符
        return NULL;
    }else{
        //新建一个结点
        BNode *p = (BNode *)malloc(sizeof(BNode));
        p->lchild = NULL;
        p->rchild = NULL;
        p->data = str[i];
        i++;
        p->lchild = BuildTree(); //创建左子树
        p->rchild = BuildTree(); //创建右子树
        return p; //最后返回根结点指针
    }
    return NULL;
}

 如果对建树的过程有所疑问，可以参考文章二叉树遍历应用之根据前序遍历建树

完整代码及实例

完整代码：

#include<bits/stdc++.h>
using namespace std;

typedef struct BNode{
    int data;
    struct BNode *lchild;
    struct BNode *rchild;
}BNode;

//建立二叉树
const int N = 100;
char str[N]; //读取的字符串
int i; //标记当前处理的字符位置
BNode *BuildTree(){
    if(str[i] == '#'){ //空结点
        i++; //准备处理下一个字符
        return NULL;
    }else{
        //新建一个结点
        BNode *p = (BNode *)malloc(sizeof(BNode));
        p->lchild = NULL;
        p->rchild = NULL;
        p->data = str[i];
        i++;
        p->lchild = BuildTree(); //创建左子树
        p->rchild = BuildTree(); //创建右子树
        return p; //最后返回根结点指针
    }
    return NULL;
}


//前序遍历
void PreOrder(BNode *root){
    if(root != NULL){
        printf("%c ",root->data);
        PreOrder(root->lchild);
        PreOrder(root->rchild);
    }
}

//前序遍历的非递归算法
void PreOrder2(BNode *root){
    stack<BNode *> treenode; //申请一个栈
    BNode *p = root; //p是遍历指针
    BNode *top; //指向当前的栈顶结点
    while(p != NULL || !treenode.empty()){//p不空或者栈不空时循环
        if(p != NULL){
            printf("%c ",p->data); //访问当前根结点
            treenode.push(p); //根结点进栈
            p = p->lchild; //指向当前结点的左子树
        }else{
            top = treenode.top(); //栈顶结点
            treenode.pop(); //出栈
            p = top->rchild; //再往右子树走
        }
    }
}

//中序遍历
void InOrder(BNode *root){
    if(root != NULL){
        InOrder(root->lchild);
        printf("%c ",root->data);
        InOrder(root->rchild);
    }
}
//中序遍历非递归
void InOrder2(BNode *root){
    stack<BNode *> treenode; //申请一个栈
    BNode *p = root; //p是遍历指针
    while(p || !treenode.empty()){ //栈不空或p不空时循环
        if(p != NULL){ //根指针进栈，遍历左子树
            treenode.push(p); //每次遇到非空二叉树先向左走
            p = p->lchild;
        }else{ //根指针退栈，访问（当前）根结点，遍历右子树
            p = treenode.top(); //p指向栈顶元素
            treenode.pop(); //退栈
            printf("%c ",p->data); //访问当前根结点
            p = p->rchild; //再向右子树走
        }
    }
}

//后序遍历
void PostOrder(BNode *root){
    if(root != NULL){
        PostOrder(root->lchild);
        PostOrder(root->rchild);
        printf("%c ",root->data);
    }
}
//后序遍历的非递归算法
void PostOrder2(BNode *root){
    stack<BNode *> treenode;
    BNode *p = root; //p是遍历指针
    BNode *top,*last = NULL; 
    while(p != NULL || !treenode.empty()){ //p不空或者栈不空时循环
        if(p != NULL){
            treenode.push(p); //当前根指针入栈
            p = p->lchild; //向左子树走
        }else{
            top = treenode.top(); //top栈顶指针
            if(top->rchild == NULL || top->rchild == last){
                treenode.pop(); //栈顶指针出栈
                printf("%c ",top->data); //输出该结点值
                last = top; //last指针指向当前top指针指向的结点
                p = NULL;
            }else{ //右子树存在且未被访问过
                p = top->rchild; //p指向当前top指针指向的结点的右子树
            }
        }
    }
}

//层序遍历
void LevelOrder(BNode *root){
    queue<BNode *> treenode; //队列存储结点
    if(root != NULL)
        treenode.push(root); //根结点入队
    while(!treenode.empty()){
        BNode *p = treenode.front(); 
        treenode.pop(); //根结点出队
        printf("%c ",p->data); //输出队首元素，即当前访问的结点值
        if(p->lchild != NULL){
            treenode.push(p->lchild);//如果有左子树，则将左子树的根结点入队
        }
        if(p->rchild != NULL){
            treenode.push(p->rchild);//如果有右子树，则将右子树的根结点入队
        }
    }
}

int main(){
    while(scanf("%s",str) != EOF){
        i = 0;
        BNode *root = BuildTree();
        printf("递归前序遍历结果： ");
        PreOrder(root);
        printf("\n");
        printf("非递归前序遍历结果：");
        PreOrder2(root);
        printf("\n");
        printf("递归中序遍历结果： ");
        InOrder(root);
        printf("\n");
        printf("非递归中序遍历结果：");
        InOrder2(root);
        printf("\n");
        printf("递归后序遍历结果： ");
        PostOrder(root);
        printf("\n");
        printf("非递归后序遍历结果：");
        PostOrder2(root);
        printf("\n");
        printf("层序遍历结果： ");
        LevelOrder(root);
    }
    return 0;
}

运行结果：
在这里插入图片描述

说明

 由于文章篇幅较大，所以只给出了非递归遍历的完整过程图示，如果想要了解递归遍历算法的完整过程，请在评论区留言，届时再更新递归算法的完整图示。

薛定谔的猫ovo
关注
  • 6
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
非递归前序,中序,后序遍历二叉树(优化算法).rar_nooneyh_二叉树 非递归_前序 中序 后序_树遍历算法_遍历二叉树
09-14
非递归前序,中序,后序遍历二叉树(优化算法)
前中后序遍历（递归法和迭代法）
qq_56762247的博客
02-23 1221
1：确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 2：确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 3：确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。 ...
数据结构——树的遍历（包含递归算法和非递归算法，先序遍历、中序遍历、后序遍历、层次遍历）
x20020402的博客
08-05 1541
数据结构——树的遍历（包含递归算法和非递归算法，先序遍历、中序遍历、后序遍历、层次遍历）
二叉树先序遍历（递归+迭代）——java
weixin_50616848的博客
05-14 1428
1、递归实现讲解： （1）确定递归放回值以及参数：根据题目需要返回遍历的节点，所以需要List集合存储节点的值，同时需要将二叉树头节点传入； ​ （2）确定递归终止条件：遍历二叉树节点为空，表明已经无节点，直接return （3）确定递归逻辑：递归顺序为中，左，右，递归开始时，先将根节点添加List集合，然后遍历左子树，最后遍历右子树。 ​...
二叉树先序遍历递归算法（图解）
雨化于画
12-25 8522
前言 二叉树的遍历 是树结构插入、删除、修改、查找和排序运算的前提， 是二叉树一切运算的基础和核心。 二叉树的遍历分为先序、中序、后序遍历， 通过递归实现时， 三者的区别不大， 连代码都不需要修改， 只需要改动打印行 （cout<data） 的位置即可。 想必由许多人会对先序遍历的递归算法感到不解， 往深层说就是对递归的不理解。 在这里博主分享二叉树先序遍历的递归算法的图解 若有错误还请各...
详细图解二叉树中序遍历（非递归C++）LeetCode94
m0_55864612的博客
09-27 2321
详细图解二叉树中序遍历（非递归）二叉树中序递归含义LeetCode题目94详细图解源代码运行结果 二叉树中序递归含义 中序遍历首先遍历左子树，然后访问根结点，最后遍历右子树。若二叉树为空则结束返回，否则： （1）中序遍历左子树 （2）访问根结点 （3）中序遍历右子树 如图1所示二叉树，中序遍历结果：DBEAFC LeetCode题目94 给定一个二叉树的根节点 root ，返回它的 中序 遍历。 输入：root = [1,null,2,3] 输出：[1,3,2] 输入：root = [1,2] 输出：
二叉树遍历问题-前序， 中序， 后序
最新发布
08-12
二叉树遍历问题 二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序， 中序， 后序二叉树遍历问题-前序...
完全二叉树 满二叉树 二叉树遍历（前序、中序、后序）.pdf
03-12
满二叉树的前序遍历 1.概念 在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。二叉树的...
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历）
12-31
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历） 二叉树的性质： 二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。 例： 实例代码： #include #include #include ...
二叉树先序遍历、中序遍历和后序遍历非递归算法 C++源码
08-25
用C++写的二叉树先序遍历、中序遍历和后序遍历非递归算法
图解二叉树非递归版的中序遍历算法
相信相信的力量
10-26 4616
你会学到什么 讨论的问题是什么 这个问题相关的概念和理论 非递归版中序遍历算法 代码思考 算法技巧 实现代码 快照 评价算法 总结 欢迎关注算法思考与应用公众号 你会学到什么？树的递归遍历算法很容易理解，代码也很精简，但是如果想要从本质上理解二叉树常用的三种遍历方法，还得要思考树的非递归遍历算法。读完后的收获： 您将学到二叉树的中序遍历的非递归版本 明白栈这种数据结构该怎么使用 讨论的问题是什么？主
二叉树的先序遍历（递归）
muyu_muyu的博客
12-13 4050
先序遍历二叉树的过程如下： 1.访问根节点 2.先序遍历左子树 3.先序遍历右子树 二叉树的存储结构定义： typedef struct node{ int data; struct node * lchild; //指向左孩子的结点 struct node * rchild; //指向右孩子的结点 }BTNode; 思路； 1.先判断该树是否为空，不为空则继续 2.访问根节点 3.调用本函数遍历左子树 3.调用本函数遍历右子树 C代码实现： void P
二叉树前序遍历--递归
he_xin2009的专栏
04-14 1968
二叉树遍历、前序遍历、递归、入栈、出栈
二叉树的中序遍历非递归算法
热门推荐
Billy1900的博客
01-10 4万+
*非递归算法思想：    （1）设置一个栈S存放所经过的根结点（指针）信息；初始化S；   （2）第一次访问到根结点并不访问，而是入栈；    （3）中序遍历它的左子树，左子树遍历结束后，第二次遇到根结点，就将根结点（指针）退栈，并且访问根结点；然后中序遍历它的右子树。   （4） 当需要退栈时，如果栈为空则结束。           代码实现： void ...
数据结构二叉树前序遍历递归和非递归算法
m0_63142359的博客
11-19 1970
数据结构二叉树前序遍历递归和非递归算法。
二叉树的先序递归遍历算法
weixin_52634719的博客
10-13 4345
怎样遍历一棵二叉树呢？把它看成三个部分： 根结点，左子树，右子树，所以要遍历一棵二叉树，就要分别遍历这三个部分 访问完毕左子树 访问完毕右子树 序列： 如何实现算法？首先考虑存储结构：二叉链表，链式存储结构。 怎样获得一棵树呢？由指向这棵树的根结点的一个指针 递归算法： 首先给我一颗树BiTree T,T就是指向根结点的指针T，判断T是否为空，若为空，当前为空二叉树，返回 这一块和这一块一模一样，用同样的方式去访问左子树，函数的递归调用 左子.
二叉树遍历之中序遍历算法（非递归、递归）入门详解
sunnyoldboy博客
07-22 2万+
中序遍历的原理很简单，也就是把树根的访问放在中间。访问结点的次序是：“左—>根—>右”，也就是首先访问左子树，之后访问树根，最后访问右子树。对于左、右子树而言，其访问的次序依然是“左—>根—>右”。 不要小看这里的次序发生的改变，其实具体的实现方式比先序遍历也要麻烦了。 二叉树的中序遍历与先序遍历一样，都可以通过递归算法实现，也可以通过非递归算法实现。......
二叉树前序、中序、后序遍历的递归和非递归算法以及层次遍历算法
Medlen
02-26 2606
1、前序遍历 //递归算法 public static void preOrder(TreeNode head){ if(head==null) return ; System.out.println(head.val); preOrder(head.left); preOrder(head.right); } //非递归算法 p...
二叉树的前序遍历（递归）
makabaka12138的博客
04-06 2047
遍历的作用： 它是树结构插入，删除，修改，查找和排序运算的前提，是二叉树一切运算的基础和核心。 遍历二叉树——从根结点触发，按照某种次序依次访问二叉树中所有结点，使得每个结点均被访问一次且仅被访问一次。 前序遍历： 若二叉树为空，则空操作； 若不为空：则 先访问根结点 前序遍历左子树 前序遍历右子树 前序遍历的结果： A B D E C F G 过程解释：先访问根结点A，然后前序遍历左子树，访问A的左结点即B，然后访问B的左节点D，然后
c语言建立一颗二叉树并遍历输出前序后序中序，并交换左右子树统计叶子节点个数
05-30
好的，您的问题是如何使用 C 语言建立一棵二叉树并遍历输出前序、后序、中序，并交换左右子树以及统计叶子节点个数。 以下是实现该功能的示例代码： ```c #include <stdio.h> #include <stdlib.h> // 定义二叉树节点结构体 struct Node { int value; struct Node* left; struct Node* right; }; // 创建一个新节点 struct Node* createNode(int value) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->value = value; newNode->left = NULL; newNode->right = NULL; return newNode; } // 插入一个新节点 struct Node* insertNode(struct Node* root, int value) { if (root == NULL) { return createNode(value); } if (value < root->value) { root->left = insertNode(root->left, value); } else { root->right = insertNode(root->right, value); } return root; } // 前序遍历 void preOrderTraversal(struct Node* root) { if (root != NULL) { printf("%d ", root->value); preOrderTraversal(root->left); preOrderTraversal(root->right); } } // 中序遍历 void inOrderTraversal(struct Node* root) { if (root != NULL) { inOrderTraversal(root->left); printf("%d ", root->value); inOrderTraversal(root->right); } } // 后序遍历 void postOrderTraversal(struct Node* root) { if (root != NULL) { postOrderTraversal(root->left); postOrderTraversal(root->right); printf("%d ", root->value); } } // 交换左右子树 void swapLeftAndRight(struct Node* root) { if (root != NULL) { struct Node* tempNode = root->left; root->left = root->right; root->right = tempNode; swapLeftAndRight(root->left); swapLeftAndRight(root->right); } } // 统计叶子节点个数 int countLeaves(struct Node* root) { if (root == NULL) { return 0; } if (root->left == NULL && root->right == NULL) { return 1; } else { return countLeaves(root->left) + countLeaves(root->right); } } int main() { // 创建二叉树 struct Node* root = NULL; root = insertNode(root, 4); insertNode(root, 2); insertNode(root, 6); insertNode(root, 1); insertNode(root, 3); insertNode(root, 5); insertNode(root, 7); // 输出遍历结果 printf("前序遍历："); preOrderTraversal(root); printf("\n"); printf("中序遍历："); inOrderTraversal(root); printf("\n"); printf("后序遍历："); postOrderTraversal(root); printf("\n"); // 交换左右子树 swapLeftAndRight(root); // 输出交换后的遍历结果 printf("交换左右子树后的前序遍历："); preOrderTraversal(root); printf("\n"); // 统计叶子节点个数 int leaves = countLeaves(root); printf("叶子节点个数：%d\n", leaves); return 0; } ``` 这里我们创建了一个二叉树，并实现了前序、中序、后序遍历以及交换左右子树和统计叶子节点个数的功能。您可以根据您的需要修改该示例代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值