【数据结构】非递归实现二叉树的前 + 中 + 后 + 层序遍历(听说面试会考？)

已于 2024-04-06 09:35:55 修改
阅读量373 收藏 1
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 面试 职场和发展 c语言 visualstudio c++
于 2023-11-13 22:07:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Weraphael/article/details/134257029
版权

在这里插入图片描述

👦个人主页：@Weraphael
✍🏻作者简介：目前学习C++和算法
✈️专栏：数据结构
🐋 希望大家多多支持，咱一起进步！😁
如果文章对你有帮助的话
欢迎 评论💬 点赞👍🏻 收藏 📂 加关注✨

目录

一、需要使用到的代码

1.1 二叉树的基本实现

二叉树的基本实现在以往博客已经详细讨论过了，这里直接给出本篇博客的所需用到的源代码。【数据结构】二叉树的链式结构（笔记总结）

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef int DataType;

typedef struct BinaryTree
{
    DataType _data;
    struct BinaryTree *_left;
    struct BinaryTree *_right;
} BinaryTree;

// 创建结点
BinaryTree *CreateNode(DataType x)
{
    BinaryTree *newnode = (BinaryTree *)malloc(sizeof(BinaryTree));
    if (newnode == NULL)
    {
        printf("CreateNode failed\n");
        return NULL;
    }
    newnode->_left = NULL;
    newnode->_right = NULL;
    newnode->_data = x;

    return newnode;
}

// 建树
BinaryTree *CreateTree()
{
    // 假定树的模型如下所示
    //    1
    //  2   3
    // 4  5    6
    BinaryTree *node1 = CreateNode(1);
    BinaryTree *node2 = CreateNode(2);
    BinaryTree *node3 = CreateNode(3);
    BinaryTree *node4 = CreateNode(4);
    BinaryTree *node5 = CreateNode(5);
    BinaryTree *node6 = CreateNode(6);

    node1->_left = node2;
    node1->_right = node3;
    node2->_left = node4;
    node2->_right = node5;
    node3->_right = node6;

    return node1;
}

// 递归实现前序遍历
void PreOrder(BinaryTree *root)
{
    if (root == NULL)
        return;

    printf("%d ", root->_data);
    PreOrder(root->_left);
    PreOrder(root->_right);
}

// 递归实现中序遍历
void InOrder(BinaryTree *root)
{
    if (root == NULL)
        return;

    InOrder(root->_left);
    printf("%d ", root->_data);
    InOrder(root->_right);
}

// 递归实现后序遍历
void PostOrder(BinaryTree *root)
{
    if (root == NULL)
        return;

    PostOrder(root->_left);
    PostOrder(root->_right);
    printf("%d ", root->_data);
}

在以上源代码中，我另外给出了递归实现遍历的版本，目的是为了和非递归(迭代)版进行对比。

1.2 栈

// 需要存储的数据类型是二叉树结构体的指针！
typedef BinaryTree *DataType1;

typedef struct stack
{
    DataType1 *_a;
    int size;
    int capacity;
} stack;

void StackInit(stack *st)
{
    st->_a = (DataType1 *)malloc(sizeof(DataType1) * 4); // 假设默认大小为4
    if (st->_a == NULL)
    {
        printf("st->_a malloc failed\n");
        return;
    }
    st->capacity = 4;
    st->size = 0;
}

// 入栈
void PushStack(stack *st, DataType1 val)
{
    if (st->capacity == st->size)
    {
    	// 每次扩大两倍
        DataType1 *newcapacity = (DataType1 *)realloc(st->_a, sizeof(DataType1) * 4 * 2); 
        if (newcapacity == NULL)
        {
            printf("st->_a realloc failed\n");
            return;
        }
        st->_a = newcapacity;
        st->capacity *= 2;
    }

    st->_a[st->size] = val;
    st->size++;
}

// 判断栈是否为空
bool StackEmpty(stack *st)
{
    return st->size == 0;
}

// 出栈
void PopStack(stack *st)
{
    if (StackEmpty(st))
    {
        printf("stack is empty\n");
        return;
    }
    st->size--;
}

// 访问栈顶元素
DataType1 StackTop(stack *st)
{
     return st->_a[st->size - 1];
}

栈是后面前、中、后序遍历所需要的。但是需要注意的是：栈需要存储的数据类型是二叉树结构体的指针。为什么？在后面会详细说明。

1.3 队列

// 需要存储的数据类型是二叉树结构体的指针
typedef BinaryTree *QueueType;
typedef struct QueueNode
{
    QueueType _val;
    struct QueueNode *_next;
} QueueNode;

typedef struct Queue
{
    QueueNode *tail;
    QueueNode *head;
} Queue;

// 初始化队列
void InitQueue(Queue *q)
{
    q->tail = q->head = NULL;
}

// 插入元素
void PushQueue(Queue *q, QueueType x)
{
    QueueNode *newnode = (QueueNode *)malloc(sizeof(QueueNode));
    if (newnode == NULL)
    {
        printf("newnode create failed\n");
        return;
    }
    newnode->_next = NULL;
    newnode->_val = x;

    if (q->head == NULL)
    {
        if (q->tail != NULL)
            return;
        q->head = q->tail = newnode;
    }
    else
    {
        q->tail->_next = newnode;
        q->tail = newnode;
    }
}

// 判断队列是否为空
bool QueueEmpty(Queue *q)
{
    return (q->head == NULL) && (q->tail == NULL);
}

// 队头元素
QueueType FrontQueue(Queue *q)
{
    return q->head->_val;
}

// 出队列
void PopQueue(Queue *q)
{
    if (QueueEmpty(q))
    {
        printf("Queue is empty\n");
        return;
    }

    if (q->head->_next == NULL)
    {
        free(q->head);
        q->head = q->tail = NULL;
    }
    else
    {
        QueueNode *next = q->head->_next;
        free(q->head);
        q->head = next;
    }
}

队列是为层序遍历所准备的。同理地，队列存储的数据类型同样也要是二叉树结构体指针。

为了快速实现二叉树的遍历，以上栈和队列的细节代码并不完整。详细的可以参考往期博客：点击跳转

话不多说，现在进入正题！

二、非递归实现二叉树的前序遍历

2.1 思路

  • 使用一个栈，充分发挥其性质：先进先出。由于左孩子要比右孩子先遍历。因此，结点出栈时，先带入其右孩子，再带入左孩子。

在这里插入图片描述

最后回过头来讲讲为什么栈的存储的类型要是二叉树结构体的指针？

通过上图，我们总结了：结点出栈，需要带入其左右孩子。因此，如果不是其结构体指针，那么也就无法将root的左右孩子入栈了。注意：也不能存结构体。因为一个结构体太大了，而指针的大小只有4/8字节

2.2 代码实现

// 非递归实现前序遍历
void PreOrder_nonR(BinaryTree *root)
{
	// 1. 需要一个栈
    stack st;
    StackInit(&st);
	
	// 2. 如果根结点不为空入栈
    if (root != NULL)
    {
        PushStack(&st, root);
    }
    
    while (!StackEmpty(&st))
    {
    	// 记录栈顶元素
        BinaryTree *top = StackTop(&st);
		// 3. 出栈后带入其左右孩子
        PopStack(&st);
        printf("%d ", top->_data);
        // ！要注意顺序：先带右孩子，再带左孩子 
        if (top->_right)
            PushStack(&st, top->_right);

        if (top->_left)
            PushStack(&st, top->_left);
    }
}

2.3 代码实现 - STL版

vector<int> preorderTraversal(TreeNode* root) 
{
    vector<int> ans;
    stack<TreeNode*> st;
    // 如果一开始root不为空则入栈
    if (root != nullptr)
    {
        st.push(root);
    }

    while (!st.empty())
    {	
    	// 出栈后先带入右孩子，再带入左孩子
        TreeNode* top = st.top();
        st.pop();
        ans.push_back(top->val);

        if (top->right) st.push(top->right);
        if (top->left) st.push(top->left);
    }
    return ans;
}

三、非递归实现二叉树的前序遍历

3.1 思路

  • 如果一开始root不为空，则将左孩子全部入栈（注意是全部）。
  • 然后再依次出栈。出栈时如果存在右孩子，则右孩子要入栈。然后还要特殊判断这个右孩子有没有左孩子，因为我们要保证 先左 再根 后右

在这里插入图片描述

3.2 代码实现

void InOrder_nonR(BinaryTree *root)
{
	// 1. 需要一个辅助栈
    stack st;
    StackInit(&st);
    
    // 如果一开始根结点为NULL
    // 直接返回
    if (root == 0)
        return;

    // 2.遍历左孩子，将其全部入栈
    BinaryTree *cur = root;
    while (cur)
    {
        PushStack(&st, cur);
        cur = cur->_left;
    }

    while (!StackEmpty(&st))
    {
    	// 出栈打印
        BinaryTree *top = StackTop(&st);
        PopStack(&st);
        printf("%d ", top->_data);

        // 特判:出栈结点存在右孩子
        if (top->_right)
        {
        	// 将其入栈
            PushStack(&st, top->_right);
            // 然后还要特殊判断这个右孩子有没有左孩子
            // 因为我们要保证 先左 再根 再右
            BinaryTree *cur2 = top->_right;
            while (cur2->_left)
            {
                PushStack(&st, cur2->_left);
                cur2 = cur2->_left;
            }
        }
    }
}

3.3 代码实现 - STL版

vector<int> inorderTraversal(TreeNode* root) 
{
    vector<int> ans;
    stack<TreeNode*> st;

    TreeNode* cur = root;
    while (cur)
    {
        st.push(cur);
        cur = cur->left;
    }

    while (!st.empty())
    {
        TreeNode* top = st.top();
        st.pop();

        ans.push_back(top->val);

        if (top->right)
        {
            // 如果存在右孩子，入栈
            st.push(top->right);
          
            // 然后还要特殊判断这个右孩子有没有左孩子
            TreeNode* cur = top->right;
            while (cur->left)
            {
                st.push(cur->left);
                cur = cur->left;
            }
        }
    }

    return ans;
}

四、后序遍历

4.1 思路

后序遍历我就不画图了，本人一开始写非递归后序遍历写了好久，都失败了(太菜了)。直到我看到一个视频，才知道原来后序遍历这么简单！

首先可以参考前序遍历(根左右)。因此，我们只要将前序遍历的代码逻辑的遍历顺序左和右对调一下，就变成根右左，最后再对其逆序，就是左右根，也就是后序遍历的结果了

4.2 代码实现

void PostOrder_nonR(BinaryTree *root)
{
    int res[6]; // 为了逆序
    int i = 0; // 用于遍历res数组
    memset(res, 0, sizeof(int));

    stack st;
    StackInit(&st);

    if (root != NULL)
    {
        PushStack(&st, root);
    }
    while (!StackEmpty(&st))
    {
        BinaryTree *top = StackTop(&st);
        PopStack(&st);
        res[i++] = top->_data;
		
		// 将前序遍历的代码逻辑的遍历顺序对调
        if (top->_left)
            PushStack(&st, top->_left);
        if (top->_right)
            PushStack(&st, top->_right);
    }
	// 最后逆序输出即可
    for (int k = i - 1; k >= 0; k--)
    {
        printf("%d ", res[k]);
    }
    printf("\n");
}

4.3 代码实现 - STL版

vector<int> postorderTraversal(TreeNode* root) 
{
    vector<int> ans;
    stack<TreeNode*> st;
    if (root != nullptr)
    {
        st.push(root);
    }

    while (!st.empty())
    {
        TreeNode* top = st.top();
        st.pop();
        ans.push_back(top->val);

        // 将前序遍历的代码逻辑的遍历顺序对调
        // 先让左孩子入栈，再让右孩子入栈
        if (top->left) st.push(top->left);
        if (top->right) st.push(top->right);
    }
    // 最后翻转答案即可
    reverse(ans.begin(), ans.end());
    return ans;
}

五、层序遍历

5.1 思路

层序遍历顾名思义就是一层一层遍历，那么就不能使用栈，得使用队列。

步骤：使用一个队列，出一个结点，带入它的孩子结点

  • 如果树不为空，就先让根结点入队列
    在这里插入图片描述

  • 然后出队列（打印1），再把1的左孩子和右孩子带入队列
    在这里插入图片描述

  • 接着让2出队列，再把2的孩子入队列
    在这里插入图片描述

  • 同理，再让4出队列，把它的孩子入队列
    在这里插入图片描述

  • 最后如果队列为空，即完成层序遍历
    在这里插入图片描述

5.2 代码实现

void LevelOrder(BinaryTree *root)
{
	// 1. 需要辅助队列
    Queue q;
    InitQueue(&q);
	
	// 如果一开始根结点root不为空
	// 则入队列
    if (root != NULL)
        PushQueue(&q, root);
	
	// 然后出双亲结点，带入子结点
    while (!QueueEmpty(&q))
    {
        BinaryTree *front = FrontQueue(&q);
        PopQueue(&q);

        printf("%d ", front->_data);
		
		// 带入子结点
        if (front->_left)
            PushQueue(&q, front->_left);

        if (front->_right)
            PushQueue(&q, front->_right);
    }
}

5.3

vector<vector<int>> levelOrder(TreeNode* root) 
{
     queue<TreeNode*> q;
	
	// 如果一开始根结点root不为空
	// 则入队列
     if (root != nullptr)
     {
         q.push(root);
     }
     int level = 1;
     vector<vector<int>> vv;
     while (!q.empty())
     {
         vector<int> v;
         for (int i = 0; i < level; i++)
         {
             TreeNode* front = q.front();
             q.pop();
             v.push_back(front->val);

             if (front->left) q.push(front->left);
             if (front->right) q.push(front->right);
         }
         vv.push_back(v);
         level = q.size();
     }
     return vv;
}
没有难学的知识~
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】二叉树的递归与非递归创建和遍历
pointer_y的博客
10-05 471
下面代码所用到的测试用例画成树的样子长这样： 创建树时给的是数组，用‘#’代表非法值，即该结点为空。 二叉树的递归实现： #pragma once #include #include using namespace std; template struct BinaryTreeNode { BinaryTreeNode(T value=0) :_value(value), _l
【C】二叉树--顺序结构（详解堆的实现，topK排序、堆排）、和链式结构（链式结构的遍历、链式结构常见递归操作以及练习题）
ZZZCCC的博客
11-29 1327
【C】二叉树--顺序结构（详解堆的实现，topK排序、堆排）、和链式结构（链式结构的遍历、链式结构常见递归操作以及练习题）
【习题】几道二叉树题目，进来看看你会不？
You don't have the guts to be what you wanna be.
08-03 172
十道有点强度的二叉树题目，各位进来挑战挑战？
前端笔试常考设计模式，操作系统，数据结构，ACM模板，经典算法，正则表达式，常用方法
luemeon的博客
03-29 5582
考试时允许使用草稿纸，请提前准备纸笔。考试过程中允许上厕所等短暂离开，但请控制离开时间笔试得分60%一般通过，面试答对80%才能通过。
Java实现的二叉树常用操作【前序建树，前中后递归非递归遍历及层序遍历】
08-28
Java实现的二叉树常用操作是指使用Java语言来实现二叉树的各种操作，包括前序建树、前中后递归非递归遍历、层序遍历等。下面我们将详细介绍这些操作的实现方法。 一、前序建树 前序建树是指从一个数组中构建一个...
C语言数据结构之二叉树的非递归后序遍历算法
08-29
主要介绍了C语言数据结构之二叉树的非递归后序遍历算法的相关资料,希望通过本文能帮助到大家，让大家实现这样的功能，需要的朋友可以参考下
数据结构-非递归遍历二叉树
11-16
非递归遍历二叉树是一种不依赖递归函数来访问树的所有节点的方法，它通常通过栈或队列等数据结构来实现。下面我们将详细探讨非递归遍历二叉树的先序、中序和后序策略。 先序遍历是二叉树遍历的一种方法，其顺序为：...
数据结构-二叉树递归-非递归实现
04-26
数据结构实验二叉树用递归实现先序遍历、中序遍历和后序遍历，用几种不同非递归方法实现了中序遍历，代码附有详细注释
数据结构非递归遍历二叉树
07-06
综上所述，非递归遍历二叉树是数据结构领域的一个重要话题，它涉及到二叉树的基本概念、遍历策略以及C++的内存管理和容器使用。通过理解和掌握这些知识，可以更好地设计和实现高效的算法，处理各种数据结构问题。
【初阶数据结构篇】单链表的实现（赋源码）
2301_79849925的博客
07-25 1518
​ 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表主要有两个部分：当前结点要保存的数据和保存下⼀个结点的地址（指针变量）。本篇主要介绍单链表的实现方法。
数据结构：栈
2301_79601095的博客
07-23 1228
主要介绍了栈的基本概念和结构，然后再详细描述了栈的顺序存储实现和链式存储实现的方法和实现代码，最后再对比栈的顺序存储和链式存储的区别。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 436
对于二分搜索的理论与实现的知识点学习。
数据结构（2）
m0_62881487的博客
07-23 1157
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
2024.7.24 作业
qq_64434282的博客
07-24 2082
【代码】2024.7.24 作业。
《数据结构1800题》基础回合总结——第1章 绪论
前端，算法，MATLAB，统计学爱好者，目前主攻Web全栈+考研内容
07-23 462
前言：《数据结构1800》这本书相信大家或多或少都有所耳闻，收录了诸多不同档次学校的考研真题，因为和汤老师的1800撞名所以备受调侃。这1800道题目里面有选择有填空，也有简答和一些编程题，总的来说质量良莠不齐——亦或说没什么性价比。因此无论考研还是备战期末或者面试的同学，当学有余力的时候，再去看本题集的内容~注：基础阶段，强烈建议不要学算法题，这玩意对于大部分人的水平来说非常耽误效率——ACM佬不在此行列。因此本次刷题相当于基础阶段，只针对除了算法设计的一切基础题~答案如下：答案如下：答案如下： 这一部分
数据结构和算法入门
weixin_67852890的博客
07-25 1592
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
2024年C++面试题汇总及答案解析
soaring_casia的专栏
07-25 598
唯一的指针，不允许其他指针与他共享指向的对象。比如指针指向的内存被释放了，但是指针没有置nullptr. 多个指针指向同一个内存，当free掉一个指针之后，其他指针就变成了野指针。C++这些年虽然难度大，但是热度仍然不减，在编程排行榜基本上都是前几位，得益于它良好的薪资待遇。SPI协议是一种采用主从模式的串行，全双工，同步通信总线，包括时钟，输入，输出，片选四个信号线，片选信号用于选择slave设备，输入输出的每个bit都需要和时钟沿同步。区别：指针指向一块儿内存，他的内容是所指内存的地址。
追问试面试系列：类加载
最新发布
田维常
07-27 81
");运行结果：错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:否则 JavaFX 应用程序类必须扩展javafx.application.Application面试回答：可以定义，但是当我们定义一个java.lang.String类和rt.jar包中的String一模一样时，是不能运行的。因为JVM在类加载过程中，会先去加载rt.jar包中的String类，而不会加载我们自定义的String类。
递归实现二叉树的层序遍历
12-19
以下是使用递归实现二叉树的层序遍历的Python代码示例： ```python class TreeNode: def __init__(self, value=0, left=None, right=None): self.value = value self.left = left self.right = right def ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值