二叉树详解及二叉树的遍历（递归与非递归C++算法实现）

最新推荐文章于 2023-06-10 12:09:02 发布
最新推荐文章于 2023-06-10 12:09:02 发布
阅读量1.6k 收藏 10
点赞数
分类专栏： 数据结构/算法（algorithm） 文章标签： 算法 c++ 数据结构 二叉树 遍历算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EngineerofAI/article/details/122350355
版权

二叉树详解及二叉树的遍历（递归与非递归C++算法实现）

二叉树简介

树（Tree）

是一种由多个节点组成的有限集合T，有且仅有一个节点称为根（root），其余结点分为m（大于等于0）个互不相交的有限集合T1，T2,T3…;每个集合本身又是棵树，被称为这个根的子树。

在树的定义中规定了树含有结点数必须大于0，这表明空集不可以称为树；他又规定结点可以为1，该结点就是根节点。

节点、根节点、父节点、子节点、兄弟节点
② 一棵树可以没有任何节点，成为空树
③ 一棵树可以只有1个节点，也就是只有根节点
④ 子树、左子树、右子树
⑤ 节点的度(degree)：子树的个数
⑥ 树的度：所有节点度中的最大值
⑦ 叶子节点(leaf): 度为0的节点
⑧ 非叶子节点：度不为0的节点

树的存储结构

  1. 结点异构型

根据结点的子树数设置相应的指针域，同时在结点的数据中再增加一个表示结点的度的域，以了解这个结点具有的指针域。

  1. 结点同构型

以这棵树的度作为结点的指针域数目，每个结点的长度一样，但是树中很多结点的度小于树的度，导致存储浪费。

二叉树(Binary Tree)

二叉树的特点

  • 每个节点的度最大为2(最多拥有2棵子树)
  • 左子树和右子树是有顺序的
  • 即使某节点只有一颗子树，也要区分左右子树。

二叉树具有五种基本形态：

  • 空二叉树。
  • 只有一个根节点
  • 根节点只有左子树
  • 根节点只有右子树
  • 根节点既有左子树又有右子树。

满二叉树

在一棵二叉树中。如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上，这样的二叉树称为满二叉树。
满二叉树的特点有：

  • 叶子只能出现在最下一层。出现在其它层就不可能达成平衡。
  • 非叶子结点的度一定是2。
  • 在同样深度的二叉树中，满二叉树的结点个数最多，叶子数最多

在这里插入图片描述

完全二叉树

对一颗具有n个结点的二叉树按层编号，如果编号为i(1<=i<=n)的结点与同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这棵二叉树称为完全二叉树。

在这里插入图片描述

二叉树的基本性质

  1. 二叉树的第i层至多有2^(n-1)个结点；

  2. 深度为k的二叉树至多有2^k - 1个结点

  3. 对任意一颗二叉树，若2度结点数为N2 ,则叶子数为 N0 = N2 + 1;

完全二叉树的重要性质：

  1. 在完全二叉树中，具有n个节点的完全二叉树的深度为[log2n]+1，其中[x]是向下取整。
  2. 若对含 n 个结点的完全二叉树从上到下且从左至右进行 1 至 n 的编号，则对完全二叉树中任意一个编号为 i 的结点有如下特性：
(1) 若 i=1，则该结点是二叉树的根，无双亲, 否则，编号为 [i/2] 的结点为其双亲结点;
(2) 若 2i>n，则该结点无左孩子， 否则，编号为 2i 的结点为其左孩子结点；
(3) 若 2i+1>n，则该结点无右孩子结点， 否则，编号为2i+1 的结点为其右孩子结点。

二叉树的遍历（递归与非递归C++算法实现）

先序遍历

先访问根结点A，然后访问左子树B，以左子树结点B为根结点，继续，先访问左子树根结点B，再访问B的左子树结点C，如果没有左子树，则访问右子树结点D,然后继续照此遍历树中所有结点。

遍历顺序：

  • 先访问根结点
  • 先序遍历左子树
  • 先序遍历右子树

在这里插入图片描述

在这里插入图片描述

/**
 * 非递归实现先序遍历
 * 先访问根结点，再访问左子树，再访问右子树
 * @param root 根结点
 */
void pre_traversal(BTreeNode* root) {
    stack<BTreeNode*> node_stack;       //用来暂存节点的栈
    while (root != nullptr || !node_stack.empty()) {
        if (root != nullptr) {                     //若当前的节点非空，
            cout << root->val << " ";         //则输出该节点的值
            node_stack.push(root);                 //该节点压入栈中。
            root = root->leftchild;                // 我们继续向左子树前进
        }
        else {
            root = node_stack.top();
            node_stack.pop();
            root = root->rightchild;
        }
    }
}


/**
 * 递归实现先序遍历
 * 先访问根结点，再访问左子树，再访问右子树
 * @param root 根结点
 */
void PreOrder(BTreeNode* root){
    if(root!=NULL){
        visit(root);
        PreOrder(root->leftchild);
        PreOrder(root->rightchild);
    }
}

中序遍历

同先序遍历类似，只不过这里先访问的左子树结点，在访问根结点

按照以下顺序进行遍历

  • 中序遍历左子树
  • 访问根结点
  • 中序遍历右子树

在这里插入图片描述

/**
 * 非递归实现中序遍历
 * 先访问左子树，再访问根结点，再访问右子树
 * 通过栈来存储二叉树结点
 * @param root 根结点
 */
void in_traversal(BTreeNode* root) {
    stack<BTreeNode*> stack_node;
    while (root != nullptr || !stack_node.empty()) {
        if (root != nullptr) {
            stack_node.push(root);
            root = root->leftchild;
        }
        else {
            root = stack_node.top();
            cout << root->val << " ";
            stack_node.pop();
            root = root->rightchild;
        }
    }
}

/**
 * 递归实现中序遍历
 * 先访问左子树，再访问根结点，再访问右子树
 * @param root 根结点
 */
void InOrder(BTreeNode* root){
    if(root!=NULL){
        InOrder(root->leftchild);
        visit(root);
        InOrder(root->rightchild);
    }
}

后序遍历

按照以下顺序进行遍历

  • 后序遍历左子树
  • 后序遍历右子树
  • 访问根节点

在这里插入图片描述

/**
 * 非递归实现后序遍历
 * 先访问左子树，再访问右子树，再访问根结点
 * 通过栈来存储二叉树结点
 * @param root 根结点
 */
void post_traversal(BTreeNode* root) {
    stack<BTreeNode*> stack_node;
    BTreeNode* lastvisit = root;
    while (root != nullptr || !stack_node.empty()) {
        if (root != nullptr) {
            stack_node.push(root);
            root = root->leftchild;
        }
        else {
            root = stack_node.top();
            if (root->rightchild == nullptr || root->rightchild == lastvisit) {

                cout << root->val << " ";
                stack_node.pop();
                lastvisit = root;
                root = nullptr;
            }
            else {
                root = root->rightchild;
            }
        }
    }
}

/**
 * 递归实现后序遍历
 * 先访问左子树，再访问右子树，再访问根结点
 * @param root 根结点
 */
void PostOrder(BTreeNode* root){
    if(root!=NULL){
        PostOrder(root->leftchild);
        PostOrder(root->rightchild);
        visit(root);
    }
}

层次遍历

从根节点开始，一层一层，从上到下，每层从左到右，依次遍历下去。

void LevelOrder(BTreeNode* root){
    BTreeNode* p; // 创建辅助队列
    queue<BTreeNode*> q;
    q.push(root); //根结点入队
    while(!q.empty()){
        p = q.front();
        visit(p);//访问结点
        q.pop(); //对头结点出队
        if(p->leftchild!=NULL){
            q.push(p->leftchild);
        }
        if(p->rightchild!=NULL){
            q.push(p->rightchild);
        }
    }
}

遍历总结：

结果：

通过二叉树遍历规律得出的结果如下图所示：

在这里插入图片描述

练习：

这里给出另外一个二叉树及其先中后序遍历及层次遍历的结果，可以试着自己遍历试试看，是否得到同样的结果。
在这里插入图片描述

代码实现

通过运行代码实现效果如下所示：

在这里插入图片描述

完整代码

//
// Created by caifl on 12/7/2021.
//
/**
 * 二叉树的先序、中序、后序、层序遍历思路及算法实现
 */

#include "iostream"
#include "vector"
#include "stack"
#include "queue"
using namespace std;

struct BTreeNode { //二叉树结点
    int val;
    BTreeNode* leftchild; //左子树结点
    BTreeNode* rightchild; //右子树结点
    // 二叉树结点结构体构造函数
    BTreeNode(char const& _val, BTreeNode* _leftchild=NULL, BTreeNode* _rightchild=NULL) :
            val(_val), leftchild(_leftchild), rightchild(_rightchild) {}
};

/**
 * 访问结点值
 * @param node 树结点
 */
void visit(BTreeNode* node){
    cout<<char(node->val)<<" ";
}

/**
 * 非递归实现先序遍历
 * 先访问根结点，再访问左子树，再访问右子树
 * @param root 根结点
 */
void pre_traversal(BTreeNode* root) {
    stack<BTreeNode*> node_stack;       //用来暂存节点的栈
    while (root != nullptr || !node_stack.empty()) {
        if (root != nullptr) {                     //若当前的节点非空，
            visit(root);      //则输出该节点的值
            node_stack.push(root);                 //该节点压入栈中。
            root = root->leftchild;                // 我们继续向左子树前进
        }
        else {
            root = node_stack.top();
            node_stack.pop();
            root = root->rightchild;
        }
    }
}

/**
 * 非递归实现中序遍历
 * 先访问左子树，再访问根结点，再访问右子树
 * 通过栈来存储二叉树结点
 * @param root 根结点
 */
void in_traversal(BTreeNode* root) {
    stack<BTreeNode*> stack_node;
    while (root != nullptr || !stack_node.empty()) {
        if (root != nullptr) {
            stack_node.push(root);
            root = root->leftchild;
        }
        else {
            root = stack_node.top();
            visit(root);
            stack_node.pop();
            root = root->rightchild;
        }
    }
}

/**
 * 非递归实现后序遍历
 * 先访问左子树，再访问右子树，再访问根结点
 * 通过栈来存储二叉树结点
 * @param root 根结点
 */
void post_traversal(BTreeNode* root) {
    stack<BTreeNode*> stack_node;
    BTreeNode* lastvisit = root;
    while (root != nullptr || !stack_node.empty()) {
        if (root != nullptr) {
            stack_node.push(root);
            root = root->leftchild;
        }
        else {
            root = stack_node.top();
            if (root->rightchild == nullptr || root->rightchild == lastvisit) {

                visit(root);
                stack_node.pop();
                lastvisit = root;
                root = nullptr;
            }
            else {
                root = root->rightchild;
            }
        }
    }
}



/**
 * 递归实现先序遍历
 * 先访问根结点，再访问左子树，再访问右子树
 * @param root 根结点
 */
void PreOrder(BTreeNode* root){
    if(root!=NULL){
        visit(root);
        PreOrder(root->leftchild);
        PreOrder(root->rightchild);
    }
}

/**
 * 递归实现中序遍历
 * 先访问左子树，再访问根结点，再访问右子树
 * @param root 根结点
 */
void InOrder(BTreeNode* root){
    if(root!=NULL){
        InOrder(root->leftchild);
        visit(root);
        InOrder(root->rightchild);
    }
}

/**
 * 递归实现后序遍历
 * 先访问左子树，再访问右子树，再访问根结点
 * @param root 根结点
 */
void PostOrder(BTreeNode* root){
    if(root!=NULL){
        PostOrder(root->leftchild);
        PostOrder(root->rightchild);
        visit(root);
    }
}

/**
 * 层次遍历二叉树
 */
void LevelOrder(BTreeNode* root){
    BTreeNode* p; // 创建辅助队列
    queue<BTreeNode*> q;
    q.push(root); //根结点入队
    while(!q.empty()){
        p = q.front();
        visit(p);//访问结点
        q.pop(); //对头结点出队
        if(p->leftchild!=NULL){
            q.push(p->leftchild);
        }
        if(p->rightchild!=NULL){
            q.push(p->rightchild);
        }
    }
}


/**
 * 测试方法
 */
void test(){
    //构建二叉树
    BTreeNode* A = new BTreeNode('A');
    BTreeNode* B = new BTreeNode('B');
    BTreeNode* C = new BTreeNode('C');
    BTreeNode* D = new BTreeNode('D');
    BTreeNode* E = new BTreeNode('E');
    BTreeNode* F = new BTreeNode('F');
    BTreeNode* G = new BTreeNode('G');
    BTreeNode* H = new BTreeNode('H');
    BTreeNode* I = new BTreeNode('I');
    BTreeNode* J = new BTreeNode('J');
    BTreeNode* K = new BTreeNode('K');
    A->leftchild=B;
    A->rightchild=C;
    B->leftchild=D;
    B->rightchild=E;
    C->leftchild=F;
    C->rightchild=G;
    D->leftchild=H;
    D->rightchild=I;
    E->rightchild=J;
    F->rightchild=K;

    /**
     * 非递归实现
     */
	cout<<"非递归实现："<<endl << "Pre order traversal:" << endl;
	pre_traversal(A); //先序遍历
	cout << endl<< "In order traversal:" << endl;
	in_traversal(A);  //中序遍历
	cout << endl << "Post order traversal:" << endl;
	post_traversal(A); //后序遍历

    /**
     * 递归实现
     */
    cout<<endl<<"递归实现"<<endl;
    cout<<"先序遍历："<<endl;
    PreOrder(A);
    cout<<endl<<"中序遍历："<<endl;
    InOrder(A);
    cout<<endl<<"后序遍历："<<endl;
    PostOrder(A);

    //层次遍历
    cout<<endl<<"层次遍历："<<endl;
    LevelOrder(A);

}

Reference

https://blog.csdn.net/chinesekobe/article/details/110874773

小枫学IT
关注
专栏目录
C++高级数据结构算法 | 二叉树的四种遍历算法详解（递归与非递归实现）
ZY-JIMMY
05-29 2177
二叉树遍历方法 、前序遍历算法 、中序遍历算法 、后序遍历算法 、层序遍历算法
C++ 二叉树的先序遍历、中序遍历和后序遍历非递归算法
08-25
用C++写的，包括二叉树的构建，二叉树的先序遍历、中序遍历和后序遍历非递归算法。
C++ 二叉树遍历（非递归版）
07-26
二叉树几种遍历方式的非递归版本 先序遍历 中序遍历 后序遍历 层次遍历
二叉树遍历非递归C++
qq_36711295的博客
07-29 820
二叉树遍历非递归C++题目链接二叉树的前序遍历思路分析代码实现二叉树的中序遍历思路分析代码实现二叉树的后序遍历思路分析代码实现一点点题外话 题目链接 二叉树的前序遍历 144. 二叉树的前序遍历 思路分析 既然要使用非递归的方式，那就必须要借助栈来进行处理，前序遍历的遍历顺序为中左右，因此我们从根节点开始遍历，将遇到的每一个节点入栈，并保存遇到的每一个节点，我们不断的去访问左子树，当访问到最后一个节点时，此时就该访问右子树，当栈不为空或当前节点不为空时，就继续进入循环 代码实现 /** * Defini
二叉树遍历的递归C++算法
06-10
以递归方式按先序序列建立二叉树的二叉链表结构，再分别输出先序、中序、后序的遍历结果。
二叉树的递归遍历(c++)
m0_52709408的博客
10-31 172
二叉树的递归遍历(c++) 图解（听网课截的图） ps：如果一开始看不懂的话可以先从最小的一棵树看起，然后再逐渐向上拓展，这样看懂基本上问题不大。 代码实现 这里实现主要还是利用递归和指针指向下一结点。 #include <iostream> using namespace std; struct binarynode { char ch; binarynode* Lchild;//左孩子 binarynode* Rchild;//右孩子 }; //递归遍历函数 vo
二叉树的非递归遍历 C++
qq_53174954的博客
05-08 1734
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、创建一棵二叉树二、具体步骤1.思路2.部分代码总结 前言 二叉树的遍历通常采用递归遍历的方式，而非递归遍历二叉树需要使用到栈，利用栈的先进后出的存储特性可实现对树的非递归遍历。 一、创建一棵二叉树 如图所示： 它的先序遍历为：ABCDEFGH 它的中序遍历为：BDCEAFHG 它的后序遍历为：DECBHGFA 二、具体步骤 1.思路 （1）新建一个结构体包含二叉树节点指针以及标志位flag。 struct Binar.
二叉树遍历算法详解：递归与非递归实现
"二叉树的遍历算法详解，包括先序遍历、中序遍历和后序遍历的递归与非递归实现。" 在计算机科学中，二叉树是一种重要的数据结构，其节点最多有两个子节点，通常分为左子节点和右子节点。遍历二叉树是指按照特定顺序...
C++二叉树递归与非递归遍历详解及实例
总结来说，这篇文档涵盖了二叉树的基本概念、节点结构、二叉树的创建以及重要的遍历算法，无论是递归还是非递归方式，都为C++开发者提供了一个实用的工具，以便理解和实现二叉树的操作。熟练掌握这些技术，可以有效...
C++二叉树递归与非递归遍历实例及代码详解
C++数据结构二叉树的核心是节点的定义和操作，特别是遍历算法的实现，这在数据结构和算法设计中具有重要意义。通过递归和非递归的方式，我们可以灵活地处理二叉树的各种操作，为实际编程问题提供了强大的工具。
二叉树的非递归遍历（c/c++）
Little_ant_的博客
02-09 2294
二叉树的非递归遍历分为三种：先序非递归遍历，中序非递归遍历和后续非递归遍历。这和递归遍历的结果是一样的，区别只是在于采用了循环结构。 先序非递归遍历 采用辅助数据结构栈来实现，先序遍历是按照先根，后左子树，再右子树的顺序进行递归访问的。由于栈是先入后出的，所以入栈顺序为先右孩子后左孩子。 非递归的算法是先将根结点入栈，栈不为空时：根结点出栈并访问，然后将右孩子入栈，再将左孩子入栈；左孩子出栈并访问...
二叉树非递归遍历C
09-18
C语言实现二叉树非递归遍历，前序、中序、后序、层序遍历的具体实现
二叉树各种遍历算法的C++实现
05-19
包括了二叉树的各种递归与非递归的遍历算法 还可对二叉树所有结点求和
二叉树的非递归遍历 C/C++
feel_myself_is_lowB的博客
06-28 343
前面用递归的方式实现了二叉树的遍历：https://blog.csdn.net/feel_myself_is_lowB/article/details/106897311 下面用非递归方式实现二叉树遍历：
二叉树的前序、中序、后序、层序遍历非递归写法C++
fannyoona的博客
05-17 280
struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 1、前序 vector<int> preorderTraversal(TreeNode* root) { stack<TreeNode*> stk; vector<int> re
二叉树三种遍历（递归与非递归）C++实现
fengwenpei的博客
07-18 2584
文章目录遍历类型递归实现非递归实现完整代码结果图 遍历类型 众所周知，二叉树的遍历有三种：前序遍历、中序遍历和后序遍历。三者不同之处是访问节点的先后次序。三种遍历的实现依靠递归或者非递归两种。 遍历类型遍历方式 前序遍历中左右 中序遍历左中右 后序遍历左右中 递归实现 非递归实现 完整代码 #include<iostream> #include<stack&g...
二叉树的遍历（超级全）C++实现
m0_58086930的博客
09-17 499
1.定义 struct Node { int data; Node* left; Node* right; }; 2.先序遍历(递归求解) void preOrderRecur(Node* head) { if (head == NULL) return; cout << head->data << " "; preOrderRecur(head->left); preOrderRecur(head->right); } 3.递归中序遍
C++数据结构：二叉树的前序、中序、后序遍历的非递归实现
weixin_43908419的博客
04-19 1377
本文对二叉树前序、中序和后序遍历的非递归实现方法进行了详解，并给出了实现代码。
C++实现二叉树的前序、中序、后序、层次遍历（递归&非递归版）
最新发布
qq_53527856的博客
06-10 1965
C++实现二叉树遍历（前序遍历、中序遍历、后续遍历、层次遍历），代码简洁易懂，注释详细。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小枫学IT

如果觉得有用的话，可以支持一下

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

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

打赏作者

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

抵扣说明：

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

余额充值