二叉树遍历算法详解（递归法+非递归法）

最新推荐文章于 2024-08-05 11:11:16 发布
最新推荐文章于 2024-08-05 11:11:16 发布
阅读量3k 收藏 22
点赞数 3
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36131611/article/details/112918977
版权

二叉树遍历算法详解

在上一篇C语言实现二叉树中有提到对于二叉树的遍历，包括前序，中序和后续遍历，以及层次遍历

大家已经熟悉了二叉树的前中后序遍历过程，大部分都采用了递归的思想来实现

在leetcode算法练习题中，有这样三道题：

  • 前序遍历

在leetcode中，最终将输出结果输出到数组中保存，上一篇博客提到的二叉树前中后遍历均打印输出，为了直观比较，先通过递归的形式实现

  • 前序遍历的递归实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

void BinaryTreePrevOrder(struct TreeNode* root,int* ret,int* index) 
{
	if (root == NULL)
	{
		return;
	}
	ret[(*index)++]=root->val;//索引创建为指针，递归回溯过程中可以及时更新
	BinaryTreePrevOrder(root->left,ret,index);
	BinaryTreePrevOrder(root->right,ret,index);
}
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* preorderTraversal(struct TreeNode* root, int* returnSize){
    int index=0;
    int* arr=(int*)malloc(sizeof(int)*100);
    memset(arr,0,sizeof(int)*100);
    BinaryTreePrevOrder(root,arr,&index);
    *returnSize=index;
    return arr;
}

通过代码分析发现：首先开辟存放节点数据的数组，数组大小此处给了固定大小100，可以根据二叉树节点个数进行设置

比如获取二叉树节点个数代码如下：

//获取节点个数
int getsize(struct TreeNode* root)
{
    if(root)
    {
        return getsize(root->left)+getsize(root->right)+1;
    }
    return 0;
}

同时，还需要注意一点，在遍历过程中，为了将访问的节点保存在数组中，必须创建索引来顺序存放

但由于采用了递归进行遍历，对此在回溯的过程中，为了索引能够及时更新，对此，需要将索引设置为全局变量或指针变量

  • 中序遍历的递归实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
void BinaryInOrder(struct TreeNode* root,int* arr,int* index)
{
    if(root==NULL)
        return;
    BinaryInOrder(root->left,arr,index);
    arr[(*index)++]=root->val;
    BinaryInOrder(root->right,arr,index);
}
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* inorderTraversal(struct TreeNode* root, int* returnSize){
    int indexsum=0;
    int* arr=(int*)malloc(sizeof(int)*100);
    memset(arr,0,sizeof(int)*100);
    BinaryInOrder(root,arr,&indexsum);
    *returnSize=indexsum;
    return arr;
}

中序遍历与前序遍历类似，不同之处在于，先遍历左子树，再访问根节点，保存数组中，再遍历右子树

  • 后序遍历的递归实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
void BinaryAfterOrder(struct TreeNode* root,int* arr,int* index)
{
    if(root==NULL)
        return;
    BinaryAfterOrder(root->left,arr,index);
    BinaryAfterOrder(root->right,arr,index);
    arr[(*index)++]=root->val;
}
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* postorderTraversal(struct TreeNode* root, int* returnSize){
    int index=0;
    int* ret=(int*)malloc(sizeof(int)*100);
    memset(ret,0,sizeof(int)*100);
    BinaryAfterOrder(root,ret,&index);
    *returnSize=index;
    return ret;
}

后序遍历的不同之处在于，先遍历左子树，再遍历右子树，最后访问根节点，保存在数组中返回

以上三种方法均基于递归思想实现，代码简洁，但递归回溯的过程有一定的理解难度

对此，本博客基于一种先进后出的数据结构“栈”实现遍历的非递归算法

其中，所用到的有关“栈”的接口定义以及接口具体实现可以参照C语言实现栈和队列这篇博客

  • 前序遍历的非递归实现

算法思想：

前序遍历中，对于每一个节点，最先访问的是以此节点开始的最左路径

前序遍历中，对于每一个树，最先访问的右子树是在访问左路径时最后遇到的右子树

左边的节点访问：自上向下

右边的节点访问：自下向上

算法步骤：

1.访问每一个节点开始的最左路径，访问到的每一个节点入栈
2.最左路径访问完成之后，获取栈顶元素，继续访问以栈顶元素的右子树为根的子结构，继续执行第1步
3.结束条件：栈为空&&右子树为空

算法图解：

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
 //非递归
#include<stdio.h>
#include<stdlib.h>
// 支持动态增长的栈
typedef struct TreeNode* STDataType;
typedef struct Stack
{
	STDataType* _data;
	int _size;
	int _capacity; // 容量
}Stack;
//检查容量
void checkCapcity(Stack* ps)
{
	if (ps->_size == ps->_capacity)
	{
		int newCap = ps->_capacity == 0 ? 1 : 2 * ps->_capacity;
		ps->_data = (STDataType*)realloc(ps->_data, sizeof(STDataType)*newCap);
		ps->_capacity = newCap;
	}
}
// 初始化栈
void StackInit(Stack* ps)
{
	if (ps == NULL)
		return;
	ps->_data = NULL;
	ps->_size = ps->_capacity = 0;
}
// 入栈
void StackPush(Stack* ps, STDataType data)
{
	if (ps == NULL)
		return;
	checkCapcity(ps);
	ps->_data[ps->_size++] = data;
}
// 出栈
void StackPop(Stack* ps)
{
	if (ps == NULL || ps->_size == 0)
		return;
	ps->_size--;

}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	return ps->_data[ps->_size - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	if (ps == NULL)
		return 0;
	return ps->_size;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
	if (ps == NULL||ps->_size==0)
		return 1;
	else
		return 0;
}
// 销毁栈
void StackDestroy(Stack* ps)
{
	free(ps->_data);
	ps->_size = 0;
	ps->_capacity = 0;
}

//获取节点个数
int getsize(struct TreeNode* root)
{
    if(root)
    {
        return getsize(root->left)+getsize(root->right)+1;
    }
    return 0;
}

int* preorderTraversal(struct TreeNode* root, int* returnSize)
{
    Stack st;
    StackInit(&st);
    int sz=getsize(root);
    int* arr=(int*)malloc(sizeof(int)*sz);
    int idx=0;
    while(root||!StackEmpty(&st))
    {
        //1访问最左路径
        while(root)
        {
            arr[idx++]=root->val;
            StackPush(&st,root);
            root=root->left;
        }
        //2获取栈顶元素，访问右子树
        root=StackTop(&st);
        StackPop(&st);
        root=root->right;
    }
    *returnSize=idx;
    return arr;
}

  • 中序遍历的非递归实现

算法步骤：

1，以节点开始，走最左路径，此路径上遇到的每一个节点首先入栈，但不能访问
2，获取栈顶元素，访问栈顶元素
3，获取栈顶元素的右子树，继续执行第一步
4，结束：栈为空&&右子树为空

算法图解：

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
 //非递归
#include<stdio.h>
#include<stdlib.h>
// 支持动态增长的栈
typedef struct TreeNode* STDataType;
typedef struct Stack
{
	STDataType* _data;
	int _size;
	int _capacity; // 容量
}Stack;
//检查容量
void checkCapcity(Stack* ps)
{
	if (ps->_size == ps->_capacity)
	{
		int newCap = ps->_capacity == 0 ? 1 : 2 * ps->_capacity;
		ps->_data = (STDataType*)realloc(ps->_data, sizeof(STDataType)*newCap);
		ps->_capacity = newCap;
	}
}
// 初始化栈
void StackInit(Stack* ps)
{
	if (ps == NULL)
		return;
	ps->_data = NULL;
	ps->_size = ps->_capacity = 0;
}
// 入栈
void StackPush(Stack* ps, STDataType data)
{
	if (ps == NULL)
		return;
	checkCapcity(ps);
	ps->_data[ps->_size++] = data;
}
// 出栈
void StackPop(Stack* ps)
{
	if (ps == NULL || ps->_size == 0)
		return;
	ps->_size--;

}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	return ps->_data[ps->_size - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	if (ps == NULL)
		return 0;
	return ps->_size;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
	if (ps == NULL||ps->_size==0)
		return 1;
	else
		return 0;
}
// 销毁栈
void StackDestroy(Stack* ps)
{
	free(ps->_data);
	ps->_size = 0;
	ps->_capacity = 0;
}

//获取节点个数
int getsize(struct TreeNode* root)
{
    if(root)
    {
        return getsize(root->left)+getsize(root->right)+1;
    }
    return 0;
}


int* inorderTraversal(struct TreeNode* root, int* returnSize)
{
    Stack st;
    StackInit(&st);
    int sz=getsize(root);
    int* arr=(int*)malloc(sizeof(int)*sz);
    int idx=0;
    while(root||!StackEmpty(&st))
    {
        //1最左路径
        while(root)
        {
            //arr[idx++]=root->val;
            StackPush(&st,root);
            root=root->left;
        }
        //2获取栈顶元素，访问栈顶元素 访问右子树
        root=StackTop(&st);
        arr[idx++]=root->val;
        StackPop(&st);
        root=root->right;
    }
    *returnSize=idx;
    return arr;
}

  • 后序遍历的非递归实现

算法步骤：

1，以节点开始，走最左路径，遇到每一个节点入栈，但不访问
2，获取栈顶元素：
    当前栈顶元素是否可以访问：
        a,没有右子树:可以访问 -->执行第一步
        b,右子树访问完成：可以访问 -->执行第一步
        c,有右子树，但没有访问：不能访问当前元素-->首先访问右子树-->执行第一步

算法图解：

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

//非递归
#include<stdio.h>
#include<stdlib.h>
// 支持动态增长的栈
typedef struct TreeNode* STDataType;
typedef struct Stack
{
	STDataType* _data;
	int _size;
	int _capacity; // 容量
}Stack;
//检查容量
void checkCapcity(Stack* ps)
{
	if (ps->_size == ps->_capacity)
	{
		int newCap = ps->_capacity == 0 ? 1 : 2 * ps->_capacity;
		ps->_data = (STDataType*)realloc(ps->_data, sizeof(STDataType)*newCap);
		ps->_capacity = newCap;
	}
}
// 初始化栈
void StackInit(Stack* ps)
{
	if (ps == NULL)
		return;
	ps->_data = NULL;
	ps->_size = ps->_capacity = 0;
}
// 入栈
void StackPush(Stack* ps, STDataType data)
{
	if (ps == NULL)
		return;
	checkCapcity(ps);
	ps->_data[ps->_size++] = data;
}
// 出栈
void StackPop(Stack* ps)
{
	if (ps == NULL || ps->_size == 0)
		return;
	ps->_size--;

}
// 获取栈顶元素
STDataType StackTop(Stack* ps)
{
	return ps->_data[ps->_size - 1];
}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	if (ps == NULL)
		return 0;
	return ps->_size;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
int StackEmpty(Stack* ps)
{
	if (ps == NULL||ps->_size==0)
		return 1;
	else
		return 0;
}
// 销毁栈
void StackDestroy(Stack* ps)
{
	free(ps->_data);
	ps->_size = 0;
	ps->_capacity = 0;
}

//获取节点个数
int getsize(struct TreeNode* root)
{
    if(root)
    {
        return getsize(root->left)+getsize(root->right)+1;
    }
    return 0;
}


int* postorderTraversal(struct TreeNode* root, int* returnSize)
{
    Stack st;
    StackInit(&st);
    int sz=getsize(root);
    int* arr=(int*)malloc(sizeof(int)*sz);
    int idx=0;
    
    struct TreeNode* prev=NULL;//指向上一次访问节点
    while(root||!StackEmpty(&st))
    {
        //1最左路径,不访问
        while(root)
        {
            //arr[idx++]=root->val;
            StackPush(&st,root);
            root=root->left;
        }
        //2通过指针获取栈顶元素
        struct TreeNode* top=StackTop(&st);//指向栈顶的指针
        //判断栈顶元素是否可以访问
        //可以访问，没有右子树，或右子树访问完成（上一次访问节点指向右子树根结点）
        if(top->right==NULL||top->right==prev)
        {
            //可以访问当前栈顶元素
            arr[idx++]=top->val;
            //出栈
            StackPop(&st);
            //更新prev
            prev=top;
        }
        else{
            //右子树存在，且没有访问完成
            root=top->right;
        }
    }
    *returnSize=idx;
    return arr;
}

  • 执行结果：

HT . WANG
关注
专栏目录
二叉树遍历之递归算法
__七把刀__
07-22 1万+
二叉树的遍历算法有多种，典型的有先序遍历、中序遍历、后序遍历以及层序遍历。而且这些遍历的递归算法较为简单，代码很少，容易实现，本文就是汇总二叉树遍历的递归算法，非递归算法将在下一篇文章中进行总结。本文中用到的二叉树实例如下： 3 / \ 9 20 / \ 15 7 二叉树定义和辅助函数如下： struct node {
二叉树的非递归（迭代）统一实现“前中后序遍历”详解
weixin_43744293的博客
06-22 357
目录 二叉树大家都非常熟悉，二叉树的遍历大家也不会陌生。用递归法来实现二叉树的“前中后序遍历”相对简洁，用几行代码就能实现，并且只需改变代码顺序就能实现3种遍历。与之相反，非递归（迭代）遍历方法实现“前中后序遍历”起来较为复杂，并且不太容易通过简单的交换代码的次序来实现3种遍历，当然，只是不太容易，并不是没有方法。下面就介绍统一的非递归（迭代）方法来是实现“前中后序遍历”。 这个过程要使用栈的数据结构，这点想来不用多解释。 树节点的定义如下： template<class T> class Tr
二叉树的递归遍历
dfssbqyrq96616258的博客
09-21 177
首先，二叉树递归遍历分为先序遍历、中序遍历和后序遍历。 先序遍历为：根节点+左子树+右子树 中序遍历为：左子树+根节点+右子树 后序遍历为：左子树+右子树+根节点 （只要记住根节点在哪里就是什么遍历，且都是先左再右） 举个例子，如二叉树： 这棵树的先序遍历为：1 2 3 4 5 中序遍历为：2 1 4 3 5 后序遍历为：2 4 5 4 1 以上类容比较好理解，然后...
二叉树的基本遍历方法总结（Java）
最新发布
[ta叫我小白]的专栏
08-05 555
二叉树的深度优先遍历（3种）的递归和迭代方法， 二叉树的广度优先遍历方法， 最大深度计算方法，最小深度计算方法。
二叉树的先序遍历（递归和非递归算法）
04-05 1345
前言 二叉树是常用的数据结构，二叉数的遍历主要分为三种，先序遍历是常用的遍历方式，主要分为递归方式和非递归方式。即广度优先和深度优先 下面先来看第一种：递归方式 public class Solution { public int[] preorderTraversal (TreeNode root) { if(root==null){ return new int[0]; } List<Integer> list
二叉树的结构及其遍历算法
少说多做
11-08 123
1.BinaryTree.java /** * 前序遍历二叉树。先根结点，再左结点， * 如无再右结点，如此递归至搜索完毕。 */ package com.binarytree; public class BinaryTree { int data; BinaryTree leftpoiter; BinaryTree rightpoiter; BinaryTree...
数据结构二叉树的递归遍历算法与非递归遍历算法
m0_65818274的博客
12-20 514
c/c++ 数据结构 二叉树 二叉树的递归遍历算法与非递归遍历
二叉树的遍历(深度优先/广度优先 递归/非递归 层序遍历)详解
bitkevin的博客
09-12 1499
目录 1.简介 2.二叉树的深度优先遍历 2.1 二叉树的前序遍历 2.2 二叉树的中序遍历 2.3 二叉树的后序遍历 3. 二叉树的广度优先搜索 3.1 二叉树广度优先搜索 3.2 二叉树的层序遍历 3.3 二叉树自底向上层序遍历 3.4 二叉树的锯齿形层序遍历 二叉树是一种很常用的基本数据结构，它可以看做一种特殊的图(一个节点只有一个入度和最多两个出度)，因此二叉树的的遍历要比图简单很多，学好二叉树也能较容易掌握图的遍历。 1.简介 我们...
二叉树中的递归思想
m0_62908071的博客
01-17 2156
按我的理解，递归的过程就是一个上楼梯加上下楼梯的过程（每一层台阶都是相同的，但是一级比一级高），在设计递归程序时，除了“台阶”之外，还要设计一个边界条件，在到达这个边界条件时，递归程序内部不会再向下递归（套娃），而是直接返回一个返回值，这个返回值又会成为其上一层递归的初始条件，这样就相当于开始一级一级的下楼梯。 1，前、中、后序遍历 以前序遍历为例，先访问根节点，然后是左节点，然后是右节点，并依此类推，访问全部的节点。由于在整个访问过程中的每一步，都遵循着上述的逻辑，因此这里就非常适合用递归思想来解决。
【二叉树】详解 树的遍历 (前序/中序/后序/层序) (递归+迭代)
闻韶
07-29 4075
LeetCode - 探索卡片 - 二叉树 - 一 - 树的遍历
实现二叉树的各种遍历算法实验报告.docx
11-12
《二叉树遍历算法实现详解》 二叉树作为一种重要的数据结构，广泛应用于计算机科学的各个领域，如编译器、操作系统、图形处理等。本文主要探讨的是如何实现二叉树的三种基本遍历算法：先序遍历、中序遍历和后序遍历...
二叉树遍历算法总结（递归+非递归）
Destiny_shine的博客
09-02 301
二叉树的前序中序后序层序遍历总结（C++版）   1、前序遍历（根左右） 递归：没什么好说的 void preOrder(TreeNode* root) { if (!root) return; cout << root->val << " "; preOrder(root->left); preOrder(root->right); }   非递归：借助栈 前序遍历根左右，先将当前节点打印，并将其进栈，节点指向
【数据结构】二叉树的递归遍历
haonanren2bu2的专栏
03-07 859
#include #include typedef char ElemType; typedef struct BiTree { ElemType Elem; BiTree * LChild; BiTree * RChild; }BiTree,*PBiTree; /*建立二叉树*/ PBiTree CreateBiTree(); /*先序遍历二叉树*/ v
【数据结构】：二叉树的递归遍历
衡的博客
03-27 1034
二叉树的遍历（递归） 二叉树的遍历：是指沿着某条搜索路线，依次对树中每个节点做一次且仅做一次访问。 N：代表根结点 L：代表根结点的左子树 R：代表根结点的右子树 正在上传…重新上传取消 NLR：先序遍历，又称作前序遍历，访问顺序为：根结点-->根的左子树-->根的右子树 转存失败重新上传取消 LNR：中序遍历，访问顺序为：根的左子树-->根结点-->根的右子树 转存失败重新上传取消 LRN：后序遍历，访问顺序为：根的左子树-->根的右子树-->根结点
二叉树遍历之递归遍历
mrbone9的博客
02-19 958
前文二叉树的实现简单讲解了基本概念，创建一颗树的过程 遍历整棵树最常用的还是递归遍历，代码实现容易 遍历顺序： 谈及遍历，通常为操作该节点，比如打印节点值；而经过并不是遍历的意思 前序遍历：根，左，右 中序遍历：左，根，右 后序遍历：左，右，根 实现原理： 以前序遍历为例，顺序为：根，左，右 1. 根节点入栈 2. 开启循环，每次出栈一元素，打印其值；...
二叉树的递归遍历（先序、中序、后序）
KangRoger的专栏
08-06 1748
二叉树是常用的数据结构，一个变形就是二叉查找树。二叉树有点像堆，如果二叉树是满二叉树，可以像堆一样用数组表示，否则就很浪费内存。二叉树常用链式表示
二叉树遍历之递归
smniubi的博客
10-29 240
前序遍历：根结点->左子树->右子树（DLR） 中序遍历：左子树->根结点->右子树（LDR） 后序遍历：左子树->右子树->根结点（LRD） 对于前序遍历，先访问根结点，再按前序遍历访问左子树，最后按前序遍历访问右子树。其他同理。
二叉树-二叉树的递归遍历
jsdoulaoula的博客
03-25 904
递归 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 确定终止条件：操作系统是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 确定单层递归的逻辑。 前序遍历 1. 确定递归函数的参数和返回值 把树和用于存放前序的list作为参数。递归函数不需要返回值，因为我们把要求的都放入list里面，由主函数输出。 2. 终止条件 当前遍历的节点是空了，那么本层递归就要要结束了，所以
二叉树递归遍历
aj64994979的博客
07-27 122
#include<iostream> using namespace std; struct Ertree { char name; Ertree *left; Ertree *right; }; void traverse(Ertree *tree, int n); void CreatTree(); void main() { CreatTree(); } vo...
二叉树遍历方法详解：递归与非递归、层次遍历实现
总结来说，这份报告深入探讨了二叉树遍历的各种实现方式，通过实例演示了如何在递归和非递归环境中正确地遍历二叉树，同时强调了理论知识与实际操作的结合，是学习和巩固二叉树遍历算法的重要参考资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HT . WANG

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值