二叉树基本操作（三）（非递归实现前中后序遍历）

最新推荐文章于 2024-07-28 17:42:24 发布
最新推荐文章于 2024-07-28 17:42:24 发布
阅读量582 收藏 5
点赞数 3
分类专栏： c语言 数据结构 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40927789/article/details/80211318
版权

非递归实现前序遍历思路：非递归的前序遍历就比较简单，借助一个栈，将根节点入栈，然后通过循环，取栈顶元素，出栈就可访问当前栈顶元素（也就是当前树的根节点（前序遍历的顺序是VLR）），有先序遍历的顺序规则，在将其右子树入栈，在将其左子树入栈，只需要注意一点，左右子树的入栈顺序一定是先入栈右子树在入栈左子树。（因为我们先序遍历是访问了根节点之后就访问左子树在访问右子树，而栈的特点是后进先出，因此我们要想左子树的节点先于右子树的节点被访问到，左子树必须要在右子树入栈之后再入栈。）

//非递归前序遍历二叉树
void TreePreOrderByLoop(TreeNode *root)
{
    if(root == NULL)
    {
        //空树
        return;
    }
    Stack stack;
    StackInit(&stack);
    //根节点入栈
    StackPush(&stack,root);
    TreeNode *cur = NULL;
    //循环的去栈顶元素对其操作，栈为空时结束循环
    while(StackGetTop(&stack,&cur))
    {
        //出栈
        StackPop(&stack);
        //访问当前栈顶元素
        printf("%c ",cur->data);
        //将当前元素的右子树入栈
        if(cur->rchild != NULL)
        {
            StackPush(&stack,cur->rchild);
        }
        //再将当前元素的左子树入栈（一定是先右在左）
        if(cur->lchild != NULL)
        {
            StackPush(&stack,cur->lchild);
        }
    }
    return;
}

非递归实现中序遍历思路：
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

//非递归中序遍历二叉树
void TreeInOrderByLoop(TreeNode *root)
{
    if(root == NULL)
    {
        //空树
        return;
    }
    Stack stack;
    StackInit(&stack);
    TreeNode *cur = root;
    while(1)
    {
        //该循环结束cur就到了一个空节点处
        //他的前一个指向的节点就是当前树的最左的节点
        while(cur != NULL)
        {
            StackPush(&stack,cur);
            cur = cur->lchild;
        }
        //此时cur为空
        //取栈顶元素
        TreeNode *tmp = NULL;
        int ret = StackGetTop(&stack,&tmp);
        if(ret == 0)
        {
            //取栈顶元素失败，说明栈空了
            //也就说明遍历完成
            return;
        }
        //访问
        printf("%c ",tmp->data);
        //出栈
        StackPop(&stack);
        if(tmp->rchild != NULL)
        {
            cur = tmp->rchild;
        }
    }
    return; 
}

非递归实现后序遍历思路：后序遍历我们都知道是LRV的顺序，所以我们在找到当前树的最左的节点之后，并不能立即进行访问，还要找到右节点，并且找到以后需要判断，该有节点是否被访问过或者是否为空，如果为空或者当前有节点被访问过，满足任意一个条件才能访问其根节点。因此我们还需要一个变量来保存我们最后访问的一个元素用于判断。

//非递归后序遍历二叉树
void TreePostOrderByLoop(TreeNode *root)
{
    if(root == NULL)
    {
        //空树
        return;
    }
    //定义一个栈并且初始化
    Stack stack;
    StackInit(&stack);
    //定义cur指针指向根节点
    TreeNode *cur = root;
    //定义一个指针保存我们最新访问过的最后一个元素
    TreeNode *pre = NULL；
    while(1)
    {
        //该循环结束cur就到了一个空节点处
        //他的前一个指向的节点就是当前树的最左的节点
        while(cur != NULL)
        {
            StackPush(&stack,cur);
            cur = cur->lchild;
        }
        //此时cur为空
        //取栈顶元素
        TreeNode *tmp = NULL;
        int ret = StackGetTop(&stack,&tmp);
        if(ret == 0)
        {
            //取栈顶元素失败，说明栈空了
            //也就说明遍历完成
            return;
        }
        //对当前栈顶元素进行判定
        //1、如果当前栈顶元素的右子树为空
        //2、或者右子树已经访问过（和访问的上一个元素是同一个元素）
        //此时才能够对该栈顶元素进行访问，然后出栈
        if(tmp->rchild == NULL || tmp->rchild == pre)
        {
            printf("%c ",tmp->data);
            StackPop(&stack);
            //更新pre的指向，用于下一次的栈顶元素的判断
            pre = tmp;
        }
        //如果都不满足，则就让cur指向该栈顶元素的右子树
        //重复之前的动作
        else
        {
            cur = tmp->rchild;
        } 
    }
}
//以下为3个非递归遍历函数的测试函数
void TestTraverse()
{
    Test_Header;
    TreeNode *a = CreateNode('a');
    TreeNode *b = CreateNode('b');
    TreeNode *c = CreateNode('c');
    TreeNode *d = CreateNode('d');
    TreeNode *e = CreateNode('e');
    TreeNode *f = CreateNode('f');
    TreeNode *g = CreateNode('g');
    a->lchild = b;
    a->rchild = c;
    c->rchild = f;
    b->lchild = d;
    b->rchild = e;
    e->lchild = g;
    printf("递归先序遍历结果：");
    TreePreOrder(a);
    printf("非递归先序遍历结果：");
    TreePreOrderByLoop(a);
    printf("\n");
    printf("递归中序遍历结果：");
    TreeInOrder(a);
    printf("非递归中序遍历结果：");
    TreeInOrderByLoop(a);
    printf("\n");
    printf("递归后序遍历结果：");
    TreePostOrder(a);
    printf("非递归后序遍历结果：");
    TreePostOrderByLoop(a);
    printf("\n");
}

测试结果：
这里写图片描述
递归与非递归求二叉树的镜像其实就像我们日常生活中照镜子一样，我们看到的镜子里面的自己总是和现实的自己的左右手颠倒的。
这里写图片描述

//交换左右子树的辅助函数
void swap(TreeNode **a,TreeNode **b)
{
    if(a == NULL || b == NULL)
    {
        return;
    }
    TreeNode *tmp = *a;
    *a = *b;
    *b = tmp;
    return;
}
//求二叉树的镜像(递归)
void TreeMirror(TreeNode *root)
{
    if(root == NULL)
    {
        //空树
        return;
    }
    //以先序的顺序，只是这里的访问动作是交换节点的左右子树
    swap(&root->lchild,&root->rchild);
    //调用函数本身，递归的实现每一个节点的左右子树的交换（不重不漏）
    TreeMirror(root->lchild);
    TreeMirror(root->rchild);
}
//求二叉树的镜像(非递归，借助队列层序遍历)
void TreeMirror2(TreeNode *root)
{
    if(root == NULL)
    {
        //空树
        return;
    }
    //定义一个队列并且初始化
    Queue queue;
    QueueInit(&queue);
    //将根节点入队列
    QueuePush(&queue,root);
    TreeNode *top = NULL;
    //循环的取队首元素
    while(QueueGetTop(&queue,&top))
    {
        //访问动作是交换左右子树
        swap(&top->lchild,&top->rchild);
        //将当前栈顶元素出栈
        QueuePop(&queue);
        //将当前栈顶元素的左子树入队列
        if(top->lchild != NULL)
        {
            QueuePush(&queue,top->lchild);
        }
         //将当前栈顶元素的右子树入队列
        if(top->rchild != NULL)
        {
            QueuePush(&queue,top->rchild);
        }
    }
    return;
}
//测试函数
void TestTraverse()
{
    Test_Header;
    TreeNode *a = CreateNode('a');
    TreeNode *b = CreateNode('b');
    TreeNode *c = CreateNode('c');
    TreeNode *d = CreateNode('d');
    TreeNode *e = CreateNode('e');
    TreeNode *f = CreateNode('f');
    TreeNode *g = CreateNode('g');
    a->lchild = b;
    a->rchild = c;
    c->rchild = f;
    b->lchild = d;
    b->rchild = e;
    e->lchild = g;
    TreeMirror(a);
    //TreeMirror2(a);
    printf("先序遍历结果：");
    TreePreOrder(a);
    printf("非递归先序遍历结果：");
    TreePreOrderByLoop(a);
    printf("\n");
    printf("中序遍历结果：");
    TreeInOrder(a);
    printf("非递归中序遍历结果：");
    TreeInOrderByLoop(a);
    printf("\n");
    printf("后序遍历结果：");
    TreePostOrder(a);
    printf("非递归后序遍历结果：");
    TreePostOrderByLoop(a);
    printf("\n"); 
}

测试结果：
这里写图片描述
判断一棵二叉树是否为一个完全二叉树思路：首先我们需要借助队列层序的遍历该二叉树的每一个元素，对每一个元素做相应的判断。

1、将根节点入队列
2、循环的取队首元素进行判断
（2.1）如果当前栈顶元素的左右子树都存在，则将其左右子树入栈进入下一个元素的判断。
（2.2）如果当前栈顶元素只有右子树，则该二叉树一定不是二叉树
（2.3）如果当前栈顶元素只有左子树，则需要进入第二个阶段进行更深层次的判断。并且将其左子树入队列。
（2.4）如果当前栈顶元素的左右子树都没有，则也需要进入第二个阶段进行判断。
3、进入第二阶段的判断，判断每一个元素是否都没有左右子树
（3.1）若每一个元素都没有左右子树，说明是完全二叉树
（3.2）若不满足该情况，说明不是完全二叉树

//判断是否为完全二叉树
int IsCompleteTree(TreeNode *root)
{
    if(root == NULL)
    {
        //空树
        return 0;
    }
    //定义一个队列并且初始化
    Queue queue;
    QueueInit(&queue);
    //将根节点初始化
    QueuePush(&queue,root);
    //定义一个变量用来表示是否进入第二阶段
    int Is_start_step_two = 0;
    TreeNode *top = NULL;
    //循环取队首元素
    while(QueueGetTop(&queue,&top))
    {
        //将当前队首元素出栈
        QueuePop(&queue);
        //第一阶段的判定
        if(Is_start_step_two == 0)
        {
            if(top->lchild != NULL && top->rchild != NULL)
            {
                QueuePush(&queue,top->lchild);
                QueuePush(&queue,top->rchild);
            }
            else if(top->lchild == NULL && top->rchild != NULL)
            {
                //此时没有左子树，只有右子树，那么一定不是完全二叉树
                return 0;
            }
            else if(top->lchild != NULL && top->rchild == NULL)
            {
                //此时只有左子树没有右子树，就需要进入下一个阶段再进行判断
                Is_start_step_two = 1;
                QueuePush(&queue,top->lchild);
            }
            else
            {
                //此时左右子树都没有，需要进入下一阶段在进行判断
                Is_start_step_two = 1;
            }
        }
        //第二阶段的判定
        else
        {
            //节点没有子树
            if(top->lchild == NULL && top->rchild == NULL)
            {
                ;
            }
            else
            {
                //节点有任意一棵子树，或者两棵子树都有，一定不是完全二叉树
                return 0;
            }
        }
    }//此处循环结束
    //所有的节点都遍历完了，而又没有return 0从而走到这一步
    //说明该树一定是完全二叉树
    return 1;
}
//测试函数
 void TestIsCompleteTree()                
 {                                  
     Test_Header;                   
     TreeNode *a = CreateNode('a'); 
     TreeNode *b = CreateNode('b'); 
     TreeNode *c = CreateNode('c'); 
     TreeNode *d = CreateNode('d'); 
     TreeNode *e = CreateNode('e'); 
     TreeNode *f = CreateNode('f'); 
     TreeNode *g = CreateNode('g'); 
     a->lchild = b;                 
     a->rchild = c;                 
     c->rchild = f;                 
     b->lchild = d;                 
     b->rchild = e;                 
     e->lchild = g;                
     //对一棵非完全二叉树进行判断测试
     int ret = IsCompleteTree(a);   
     printf("expected ret = 0,actual ret = %d\n",ret);
     //将树修改为完全二叉树再次测试
     c->rchild = NULL;
     e->lchild = NULL;
     ret = IsCompleteTree(a);
     printf("expected ret = 1,actual ret = %d\n",ret);

 }

测试结果：
这里写图片描述
由先序和中序遍历结果创建一棵二叉树

//由前序和中序结果创建树
//辅助查找终于结果中当前根节点的左右子树区间的函数
int Find(TreeDataType to_find,TreeDataType in_order[],int left,\
         int right)
{
    int i = left;
    for(;i < right;i++)
    {
        if(to_find == in_order[i])
        {
            return i;
        }
    }
    return -1;
}

TreeNode *_TreeRebuild(TreeDataType pre_order[],\
           int *pre_order_index,int size,TreeDataType in_order[],\
           int left,int right)
{
    if(left >= right)
    {
        //区间无效，说明为一棵空树
        return NULL;
    }
    if(pre_order_index == NULL)
    {
        //非法输入
        return NULL;
    }
    if(*pre_order_index >= size)
    {
        //遍历结束
        return NULL;
    }
    //以先序结果取当前值构建一个新节点
    //相当于当前子树的根节点
    TreeNode *new_node = CreateNode(pre_order[*pre_order_index]);
    //找到当前节点在中序遍历结果中的位置
    int cur_root_in_order_index = Find(new_node->data,in_order,\
                                       left,right);
    assert(cur_root_in_order_index != -1);
    //更新index值，指向下一个即将被创建为节点的值
    ++(*pre_order_index);
    //左子树区间[left,cur_root_in_order_index)
    //递归的创建当前根节点的左子树
    new_node->lchild =  _TreeRebuild(pre_order,pre_order_index,\
                     size,in_order,left,cur_root_in_order_index);
    //右子树区间[cur_root_in_order_index+1,right)
    //递归的创建当前根节点的右子树
    new_node->rchild =  _TreeRebuild(pre_order,pre_order_index,\
                   size,in_order,cur_root_in_order_index+1,right);
    return new_node;
}
//辅助创建二叉树的函数
TreeNode *TreeRebuild(TreeDataType pre_order[],\
            TreeDataType in_order[],int size)
{
    int pre_order_index = 0;
    int in_order_left = 0;
    int in_order_right = size;
    return _TreeRebuild(pre_order,&pre_order_index,\
             size,in_order,in_order_left,in_order_right);
}
//由前序和中序结果创建树的函数测试
void TestRebuild()
{
    Test_Header;
    //先序结果
    TreeDataType pre_order[] = "abdegcf";
    //中序结果
    TreeDataType in_order[] = "dbgeacf";
    //调用创建函数
    TreeNode *new_node = TreeRebuild(pre_order,in_order,7);
    printf("递归先序遍历结果：");
    TreePreOrder(new_node);
    printf("非递归先序遍历结果：");
    TreePreOrderByLoop(new_node);
    printf("\n");
    printf("递归中序遍历结果：");
    TreeInOrder(new_node);
    printf("非递归中序遍历结果：");
    TreeInOrderByLoop(new_node);
    printf("\n");
    printf("递归后序遍历结果：");
    TreePostOrder(new_node);
    printf("非递归后序遍历结果：");
    TreePostOrderByLoop(new_node);
    printf("\n");
}

测试结果：观察遍历结果均正确，说明创建成功
这里写图片描述

小心眼儿猫
关注
专栏目录
二叉树的前序、中序、后序、层序遍历，递归和迭代两大类解题思路，每类细分不同解法【完整版】附PDF文档
CV前沿
04-03 5487
一、二叉树的前序遍历 二叉树的前序遍历的记忆法则是“根左右"，即先遍历根节点，再遍历左子树节点，再遍历右子树节点。 以上图为例，前序遍历的结果是【A, B, D, E, C, F, G】 1.1 解题思路：递归 递归是我们实现前中后序遍历最常用的方法。 什么问题可以采用递归求解呢？ 需要满足三个条件： 一个问题的解可以分解为若干个子问题的解； 这个问题与分解的子问题，除了数据规模不同外，求解思路相同 存在递归终止条件。 那么在知道一个问题可以采用递归实现之后，如何写出递归代码呢？ 关键在于能写出递归
C++：二叉树后序遍历的非递归
kimsaul的白给岁月
07-11 1128
后序遍历的非递归操作：出栈代表此根所在的子树已经访问完毕，不需要再入栈；因此需要判断当前栈顶根的右子树是不是上一个栈顶根元素。
二叉树遍历非递归实现
程序猿的挨踢人生
03-24 2346
遍历是二叉树各种操作的基础，上一节给出的遍历算法是递归实现的，本节给出二叉树遍历的非递归实现，非递归实现需要使用前面讲到的数据结构——栈、队列来作为辅助空间
二叉树的遍历（先序、中序、后序、层次）
最新发布
kusunoki的博客
07-28 7526
参照王道数据结构辅导书以及哔哩哔哩大学的部分视频，对二叉树遍历的重要知识点进行归纳，并总结做题技巧。
二叉树的后序遍历
weixin_43919570的博客
04-17 1042
需要注意的点： 后序遍历与中序遍历的区别是，当访问某个节点是，可以确定其左孩子已经被访问过了，但是右孩子是否被访问过了还无法确定，因此需要使用一个prev变量，记录一下前一个被访问过的节点，如果右孩子是这个已经被访问过的节点，或者右孩子为空时，此时才能访问当前节点。（访问过该节点的含义是，将该节点放入了res数组，对于后序遍历，其必要条件是，该节点的左孩子和右孩子都被访问过了） /** * Definition for a binary tree node. * struct TreeNode { *
二叉树后序遍历
lq
06-29 2368
二叉树后序遍历 后序遍历 顺序为：左子树->右子树->跟节点 边遍历左子树，然后遍历右子树，最后遍历跟节点，以此轮推，直到遍历所有节点 6 ------------- 4 8 -------- ------- 2 5 7 9
PHP基于非递归算法实现先序、中序及后序遍历二叉树操作示例
12-20
上述代码中的三个函数都是基于栈实现的非递归遍历，它们能够有效地处理任意大小的二叉树，而不会受到递归深度限制的影响。 在实际应用中，二叉树遍历可以用来进行多种操作，如查找、复制、排序等。比如，在编译器中...
二叉树的非递归后序遍历算法实例详解
09-04
本文将详细解析非递归后序遍历的算法实例，帮助理解其实现过程。 后序遍历的基本顺序是：左子树 -> 右子树 -> 根节点，但在非递归实现中，由于不能直接利用函数调用的返回来控制顺序，我们需要借助数据结构（如栈）...
数据结构试验报告用先序中序建立二叉树后序遍历非递归.pdf
09-27
后序遍历非递归算法的实现相对复杂，需要利用栈的操作来实现。 4. 结构体的定义和使用：在C语言的实现中，结构体（struct）被用来定义树节点，其中包含了数据域（如字符型的data域）和指针域（lchild和rchild分别...
JavaScript实现二叉树前中后序遍历（递归和非递归分别实现）
Yolanda_NuoNuo的专栏
07-23 1467
JavaScript实现二叉树的前中后序遍历（递归和非递归） 一、来一棵绿绿的二叉树 1、binary-tree.js const binaryTree = { val: 'a', left: { val: 'b', left: { val: 'd', left: null, right: null }, right: { val:
中序非递归遍历二叉树
晴天的专栏
06-28 1245
中序遍历二叉树，即是先遍历左子树，再访问根节点，最后遍历右子树，这个顺序对于每棵子树都是一样的，是访问子树的共性，故可依次顺序设置循环，逐一访问每个结点。对于每一个树的子树，均要完成此操作。故在开始遍历之时，应先找到最左边的结点，遍历应从此开始。访问完此结点，应逐一访问此结点的根结点和右子树。    有点难度的第一是找最左节点。方法是从树的根结点顺lchild而下直到NULL为止。二是访问完根节
144. 二叉树的前序遍历
WhiteGray的博客
10-27 489
给定一个二叉树，返回它的 前序 遍历。 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,2,3] 进阶: 递归算法很简单，你可以通过迭代算法完成吗？ 解答 递归： /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * Tre
二叉树非递归后序遍历（非递归遍历中最麻烦的一个）
liupeng900605的专栏
12-13 1079
前序、中序、后序的非递归遍历中，要数后序最为麻烦，如果只在栈中保留指向结点的指针，那是不够的，必须有一些额外的信息存放在栈中。 方法有很多，这里只举一种，先定义栈结点的数据结构 typedef struct{Node * p; int rvisited;}SNode //Node 是二叉树的结点结构，rvisited==1代表p所指向的结点的右结点已被访问过。 lastOrderTraver
“非递归” 实现二叉树的“前序、中序、后序、层序”遍历
CYK_byte的博客
03-15 2618
相信学过或是了解过二叉树的朋友都知道，他的前序、中序、后序遍历使用递归法实现非常简单，那么如果使用非递归的方式来解，也就是使用迭代来解，你还能将他拿下么？实际上一点都不难，往下看~
非递归、仅用一个栈、不加标记数组实现二叉树的后序遍历算法
weixin_34128237的博客
08-20 136
作者：finallyly 出处：博客园（转载请注明作者和出处） 题记：最近在复习数据结构和算法。由于之前在数据结构和算法方面没有受过密集的训练。所以刚入门，有点吃力。最主要的一个问题是：看别人的，好像一看就全懂了，但是自己写又写不出来；给定一个具体的题目，即便是看懂了别人的算法，但是过些日子回过头来自己写，还是写不出来。和我一样出现上述状况的同学要注意啦，需要改变学习方式，否则则会一直在津津有味...
二叉树前中后序遍历【非递归】
smf12138的博客
08-27 877
本篇文章会对二叉搜索树的非递归版本的前中后序遍历做讲解，并对代码进行实现.
二叉树的前中后序遍历（非递归）
AwwzJ_0821的博客
02-05 476
要实现前序遍历的非递归方式的思路：先循环遍历左子树，再遍历右子树。具体实现方法：第一次经过结点时就进行输出，但需要进行回溯，所以将经过的结点元素进行入栈。先遍历左子树，当最后一个结点的左孩子都为空时，判断最后一个结点的右子树。在代码中表示就为：遍历左子树时，若当前结点不为空则继续循环，若为空就说明需要判断当前结点的父母结点的右子树了，即需要进行回溯到上一个结点。回溯完成后，继续判断右子树的情况，即从右孩子继续判断：遍历右孩子的左子树，再按照相同方法遍历右孩子的右子树。所以需要两个变量，一个变量。
C语言非递归实现后序遍历二叉树算法
"这篇资源是关于使用C语言非递归方式实现后序遍历二叉树的教程。通过实例代码详细介绍了如何运用栈结构来完成这一操作，主要方法是利用两个...通过实际编写和运行代码，你可以更深入地掌握非递归后序遍历二叉树的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值