数据结构与算法--二叉树之线索二叉树（前序、中序、后序）思路以及代码实现。

最新推荐文章于 2024-04-29 19:53:30 发布
最新推荐文章于 2024-04-29 19:53:30 发布
阅读量4.3k 收藏 49
点赞数 11
分类专栏： 考研 文章标签： c++ 二叉树 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45137584/article/details/117227422
版权

线索二叉树

1.先序线索二叉树

在这里插入图片描述
思路：
沿类似于上图中的先序遍历路径行走，如果发现左孩子结点或右孩子结点为空（也就是度为1或者0的结点），把它们的左空孩子结点指向它的前驱结点，把它们的右空孩子结点指向它的后继结点。当没有前驱或者后继结点时不用指。

关于如何找到它们的前驱或后继结点？
如下图：
我们可以通过图中（+）加号的看出路径，可以得到先序遍历的顺序为：
1 2 4 5 3 6 8 7

我们以图中结点4为例子：
4为叶子结点，所以它的左右孩子结点都为空结点，我们可以从先序遍历的顺序看出，4的前驱结点为2，4的后继结点为5，其他同理可得，所以得到如图的连线。
在这里插入图片描述

我们把上图用代码表示出来，我们使用链式存储结构，让上图可视化：

在这里插入图片描述
由五个域组成
lichild:用来存储左孩子所在的链结点存储地址。
lTag:当ITag为0表示左孩子结点不空;为1表示空。

rchild:用来存储右孩子所在的链结点存储地址。
rTag:当rTag为1表示右孩子结点不空;为1表示空。

data:用来存储数据。

在这里插入图片描述
和我们使用的是先序遍历的递归很像。顺序为：
根结点->左子树->右子树
代码如下：

void _preThread(BTNode<T> *p,BTNode<T> *&pre)
{
    if(p!=NULL)
    {
    	//当遇到左结点为NULL时，把左孩子结点指向前驱结点；把lTag设为1，表示左孩子结点为空
        if(p->lchild==NULL)
        {
            p->lchild=pre;
            p->lTag=1;
        }
        //当遇到结点不为空且右孩子结点为NULL时，把右孩子结点指向后继结点；把rTag设为1，表示右孩子结点为空
        if(pre!=NULL&&pre->rchild==NULL)
        {
            pre->rchild=p;
            pre->rTag=1;
        }
        //根结点
        pre=p;
        //左子树
        if(p->lTag==0)
            _preThread(p->lchild,pre);
        //右子树
        if(p->rTag==0)
            _preThread(p->rchild,pre);
    }
}

虽然我们实现了先序线索二叉树 ，但是要使用它来遍历打印出数据。
思路：
首先指向根结点，然后根结点的，左子结点，左子结点的左子结点…不为空的话，就沿路打印出所到结点；然后当左结点为空时，指向它的右子结点（部分右子结点是他的后继结点）；然后继续判断左结点是否为空，这样循环就可以打印出我们想要的数据了。

打印路径：如图红色线条
因为我们没有用前驱结点，我就把它删掉了。后面的后序遍历我们就只使用前驱结点，没使用后继结点。
在这里插入图片描述

代码表示：

 //线索二叉树前序遍历
 void preThread()
 {
     BTNode<T> *p=NULL;
     BTNode<T> *root=_root;
     _preThread(root,p);
     while(root!=NULL)
     {
         while(!root->lTag)
         {
             cout<<root->data<<"  ";
             root=root->lchild;
         }
         cout<<root->data<<"  ";
         root=root->rchild;
     }
     cout<<endl;
 }

整体代码：

#include<iostream>
using namespace std;
#define maxSize 10

template<class T>
struct BTNode
{
    T data;
    T lTag;
    T rTag;
    BTNode<T>* lchild;
    BTNode<T>* rchild;

    BTNode(const T& x)
        :data(x)
        ,lTag(0)
        ,rTag(0)
        , lchild(NULL)
        , rchild(NULL)
    {}
};

template<class T> class binary_tree
{
    typedef BTNode<T> node;
public:
    binary_tree(T* a, size_t n, const T&invalid)
    {
        size_t index = 0;
        _root = _create_tree(a, n, invalid, index);
    }

    //创建一棵二叉树
    BTNode<T>* _create_tree(T*a, size_t n, const T& invalid, size_t& index)
    {
        BTNode<T>* root = NULL;
        if (a[index] != invalid)
        {
            root = new BTNode<T>(a[index]);
            root->lchild = _create_tree(a, n, invalid, ++index);
            root->rchild = _create_tree(a, n, invalid, ++index);
        }
        
        return root;
    }

    //线索二叉树前序遍历
    void preThread()
    {
        BTNode<T> *p=NULL;
        BTNode<T> *root=_root;
        _preThread(root,p);
        while(root!=NULL)
        {
            while(!root->lTag)
            {
                cout<<root->data<<"  ";
                root=root->lchild;
            }
            cout<<root->data<<"  ";
            root=root->rchild;
        }
        cout<<endl;
    }

    void _preThread(BTNode<T> *p,BTNode<T> *&pre)
    {
        if(p!=NULL)
        {
            if(p->lchild==NULL)
            {
                p->lchild=pre;
                p->lTag=1;
            }
            if(pre!=NULL&&pre->rchild==NULL)
            {
                pre->rchild=p;
                pre->rTag=1;
            }
            pre=p;
            if(p->lTag==0)
                _preThread(p->lchild,pre);
            if(p->rTag==0)
                _preThread(p->rchild,pre);
        }
    }
protected:
    node *_root;
};


//测试部分
void test_binary_tree()
{
    int array[] = { 1, 2, 4, '^', '^' , 5, '^', '^', 3, 6, 8, '^', '^', '^',7,'^','^'};
    binary_tree<int> t(array, sizeof(array) / sizeof(int), '^');
    t.preThread();
}

int main(void)
{
    test_binary_tree();
    system("pause");
}

2.后序线索二叉树

因为和前序二叉树有点像，所以就先说明后序线索二叉树。
在这里插入图片描述
思路：
沿类似于上图中的后序遍历路径行走，如果发现左孩子结点或右孩子结点为空（也就是度为1或者0的结点），把它们的左空孩子结点指向它的前驱结点，把它们的右空孩子结点指向它的后继结点。当没有前驱或者后继结点时不用指。

关于如何找到它们的前驱或后继结点？
如下图：
我们可以通过图中（-）负号的看出路径，可以得到后序遍历的顺序为：
4 5 2 8 6 7 3 1

我们以图中结点4为例子：
4为叶子结点，所以它的左右孩子结点都为空结点，我们可以从后序遍历的顺序看出，4的没有前驱结点，4的后继结点为5，其他同理可得，所以得到如图的连线。
在这里插入图片描述

我们把上图用代码表示出来，我们使用链式存储结构，让上图可视化：

在这里插入图片描述
由五个域组成
lichild:用来存储左孩子所在的链结点存储地址。
lTag:当ITag为0表示左孩子结点不空;为1表示空。

rchild:用来存储右孩子所在的链结点存储地址。
rTag:当rTag为1表示右孩子结点不空;为1表示空。

data:用来存储数据。

和我们前面的先序线索二叉树非常类似，只是代码的顺序不同，因为这个是左子树->右子树->根结点
代码如下：

void _postThread(BTNode<T> *p,BTNode<T> *&pre)
{
    if(p!=NULL)
    {
    	//左子树
        _postThread(p->lchild,pre);
        //右子树
        _postThread(p->rchild,pre);
        //当遇到左结点为NULL时，把左孩子结点指向前驱结点；把lTag设为1，表示左孩子结点为空
        if(p->lchild==NULL)
        {
            p->lchild=pre;
            p->lTag=1;
        }
         //当遇到结点不为空且右孩子结点为NULL时，把右孩子结点指向后继结点；把rTag设为1，表示右孩子结点为空
        if(pre!=NULL&&pre->rchild==NULL)
        {
            pre->rchild=p;
            pre->rTag=1;
        }
        //根结点
        pre=p;
    }
}

虽然我们实现了后序线索二叉树 ，但是要使用它来遍历打印出数据。
思路：
因为我们和先序遍历一样的方向，难以达到我们想要的效果，如果我们从与它相反的路径来看的话，我们所想要解决问题是不是就很明确，和我们先序遍历的解决方法和类似，不过打印出的数据是逆后序遍历，所以我们需要一个自定义栈来存储逆后序遍历，出栈则为后序遍历。

打印路径：如图红色线条
因为我们没有用后继驱结点，我就把它删掉了。
在这里插入图片描述
代码表示：

void postThread()
{
    BTNode<T> *p=NULL;
    BTNode<T> *root2=_root;
    BTNode<T> *stack[maxSize];
    int top=-1;
    _postThread(root2,p);
    while(root2!=NULL)
    {
        while(!root2->rTag)
        {
            stack[++top]=root2;
            root2=root2->rchild;
        }
        stack[++top]=root2;
        root2=root2->lchild;
    }
    while(top!=-1)
    {
        p=stack[top--];
        cout<<p->data<<"  ";
    }
    cout<<endl;
}

整体代码：

#include<iostream>
using namespace std;
#define maxSize 10

template<class T>
struct BTNode
{
    T data;
    T lTag;
    T rTag;
    BTNode<T>* lchild;
    BTNode<T>* rchild;

    BTNode(const T& x)
        :data(x)
        ,lTag(0)
        ,rTag(0)
        , lchild(NULL)
        , rchild(NULL)
    {}
};

template<class T> class binary_tree
{
    typedef BTNode<T> node;
public:
    binary_tree(T* a, size_t n, const T&invalid)
    {
        size_t index = 0;
        _root = _create_tree(a, n, invalid, index);
    }

    //创建一棵二叉树
    BTNode<T>* _create_tree(T*a, size_t n, const T& invalid, size_t& index)
    {
        BTNode<T>* root = NULL;
        if (a[index] != invalid)
        {
            root = new BTNode<T>(a[index]);
            root->lchild = _create_tree(a, n, invalid, ++index);
            root->rchild = _create_tree(a, n, invalid, ++index);
        }
        
        return root;
    }

    //线索二叉树后序遍历
    void postThread()
    {
        BTNode<T> *p=NULL;
        BTNode<T> *root2=_root;
        BTNode<T> *stack[maxSize];
        int top=-1;
        _postThread(root2,p);
        while(root2!=NULL)
        {
            while(!root2->rTag)
            {
                stack[++top]=root2;
                root2=root2->rchild;
            }
            stack[++top]=root2;
            root2=root2->lchild;
        }
        while(top!=-1)
        {
            p=stack[top--];
            cout<<p->data<<"  ";
        }
        cout<<endl;
    }
    void _postThread(BTNode<T> *p,BTNode<T> *&pre)
    {
        if(p!=NULL)
        {
            _postThread(p->lchild,pre);
            _postThread(p->rchild,pre);
            if(p->lchild==NULL)
            {
                p->lchild=pre;
                p->lTag=1;
            }
            if(pre!=NULL&&pre->rchild==NULL)
            {
                pre->rchild=p;
                pre->rTag=1;
            }
            pre=p;
        }
    }

   
protected:
    node *_root;
};


//测试部分
void test_binary_tree()
{
    int array[] = { 1, 2, 4, '^', '^' , 5, '^', '^', 3, 6, 8, '^', '^', '^',7,'^','^'};
    binary_tree<int> t2(array, sizeof(array) / sizeof(int), '^');
    t2.postThread();
}

int main(void)
{
    test_binary_tree();
    system("pause");
}

3.中序线索二叉树

在这里插入图片描述
思路：
沿类似于上图中的中序遍历路径行走，如果发现左孩子结点或右孩子结点为空（也就是度为1或者0的结点），把它们的左空孩子结点指向它的前驱结点，把它们的右空孩子结点指向它的后继结点。当没有前驱或者后继结点时不用指。

关于如何找到它们的前驱或后继结点？
如下图：
我们可以通过图中（=）等于号的看出路径，可以得到中序遍历的顺序为：
4 2 5 1 8 6 3 7

我们以图中结点4为例子：
4为叶子结点，所以它的左右孩子结点都为空结点，我们可以从后序遍历的顺序看出，4的没有前驱结点，4的后继结点为2，其他同理可得，所以得到如图的连线。

在这里插入图片描述
我们把上图用代码表示出来，我们使用链式存储结构，让上图可视化：

在这里插入图片描述
由五个域组成
lichild:用来存储左孩子所在的链结点存储地址。
lTag:当ITag为0表示左孩子结点不空;为1表示空。

rchild:用来存储右孩子所在的链结点存储地址。
rTag:当rTag为1表示右孩子结点不空;为1表示空。

data:用来存储数据。

和我们中序遍历的递归非常类似，顺序为：
左子树->根结点->右子树

代码：

void _inThread(BTNode<T> *&p,BTNode<T> *&pre)
{
    if(p!=NULL)
    {
    	//左子树
        _inThread(p->lchild,pre);
         //当遇到左结点为NULL时，把左孩子结点指向前驱结点；把lTag设为1，表示左孩子结点为空
        if(p->lchild==NULL)
        {
            p->lchild=pre;
            p->lTag=1;
        }
          //当遇到结点不为空且右孩子结点为NULL时，把右孩子结点指向后继结点；把rTag设为1，表示右孩子结点为空
        if(pre!=NULL&&pre->rchild==NULL)
        {
            pre->rchild=p;
            pre->rTag=1;
        }
        //根结点
        pre=p;
        //右子树
        _inThread(p->rchild,pre);
    }
}

虽然我们实现了中序线索二叉树 ，但是要使用它来遍历打印出数据。

图中：
蓝色箭头+红色箭头为路径，其中红色箭头的起点为打印结点。
在这里插入图片描述

思路：
沿如图入口处进入，如果遇到存在结点且左子结点不空，使用它的左子结点等于当前结点，当结点的左子结点为空时，我们打印出当前结点；然后判断右子结点是否为空，当为空时，使结点的后继结点等于当前结点，当不为空时，使结点的右子结点等于当前结点，然后继续 判断当前结点存在结点且左子结点不空，让左子结点等于当前结点；然后循环进行。

看代码可能更轻易看懂：

void inThread()
{
    BTNode<T> *p=NULL;
    BTNode<T> *root1=_root;
    _inThread(root1,p);
    while(root1!=NULL&&root1->lTag==0)
    {
        root1=root1->lchild;
    }
    while(root1!=NULL)
    {
        cout<<root1->data<<"  ";
        if(root1->rTag==1){
            root1=root1->rchild;
        }else{
            root1=root1->rchild;
             while(root1!=NULL&&root1->lTag==0)
             {
                root1=root1->lchild;
             }
        }
    }
    cout<<endl;
}

整体代码：

#include<iostream>
using namespace std;
#define maxSize 10

template<class T>
struct BTNode
{
    T data;
    T lTag;
    T rTag;
    BTNode<T>* lchild;
    BTNode<T>* rchild;

    BTNode(const T& x)
        :data(x)
        ,lTag(0)
        ,rTag(0)
        , lchild(NULL)
        , rchild(NULL)
    {}
};

template<class T> class binary_tree
{
    typedef BTNode<T> node;
public:
    binary_tree(T* a, size_t n, const T&invalid)
    {
        size_t index = 0;
        _root = _create_tree(a, n, invalid, index);
    }

    //创建一棵二叉树
    BTNode<T>* _create_tree(T*a, size_t n, const T& invalid, size_t& index)
    {
        BTNode<T>* root = NULL;
        if (a[index] != invalid)
        {
            root = new BTNode<T>(a[index]);
            root->lchild = _create_tree(a, n, invalid, ++index);
            root->rchild = _create_tree(a, n, invalid, ++index);
        }
        
        return root;
    }

    //线索二叉树中序遍历
    void inThread()
    {
        BTNode<T> *p=NULL;
        BTNode<T> *root1=_root;
        _inThread(root1,p);
        while(root1!=NULL&&root1->lTag==0)
        {
            root1=root1->lchild;
        }
        while(root1!=NULL)
        {
            cout<<root1->data<<"  ";
            if(root1->rTag==1){
                root1=root1->rchild;
            }else{
                root1=root1->rchild;
                 while(root1!=NULL&&root1->lTag==0)
                 {
                    root1=root1->lchild;
                 }
            }
        }
        cout<<endl;
    }
    void _inThread(BTNode<T> *&p,BTNode<T> *&pre)
    {
        if(p!=NULL)
        {
            _inThread(p->lchild,pre);
            if(p->lchild==NULL)
            {
                p->lchild=pre;
                p->lTag=1;
            }
            if(pre!=NULL&&pre->rchild==NULL)
            {
                pre->rchild=p;
                pre->rTag=1;
            }
            pre=p;
            _inThread(p->rchild,pre);
        }
    }
protected:
    node *_root;
};


//测试部分
void test_binary_tree()
{
    int array[] = { 1, 2, 4, '^', '^' , 5, '^', '^', 3, 6, 8, '^', '^', '^',7,'^','^'};
    binary_tree<int> t1(array, sizeof(array) / sizeof(int), '^');
    t1.inThread();
}

int main(void)
{
    test_binary_tree();
    system("pause");
}

4.代码打印结果：

在这里插入图片描述

android 小白星
关注
  • 11
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
非递归前序,中序,后序遍历二叉树(优化算法).rar_nooneyh_二叉树 非递归_前序 中序 后序_树遍历算法_遍历二叉树
09-14
对于二叉树的非递归遍历算法，除了优化栈空间使用之外，还有助于理解和实现其他数据结构，如线索二叉树，以及在实际问题中的应用，如序列化和反序列化二叉树。这些算法在面试中也经常被问到，是每个程序员应该掌握的...
数据结构-线索二叉树（后序线索二叉树及遍历）
[SZU_Crayon]
07-20 4万+
后序线索二叉树 线索化的概念及相关图解 在上一篇中详细介绍了中序线索二叉树，线索化图解及相关概念都放在那篇博客啦，放个传送门 线索二叉树详细解析（含图解）：传送门 包括还有先序线索二叉树：传送门   后序线索二叉树 （1）后序线索二叉树的构造              ①思路：在这里说下构造的原因，与先序中序线索二叉树不同，在遍历时后序时先把孩子全部遍历了再回到父...
【数据结构】-线索二叉树(后序)
RunningSnail的博客
08-11 3995
后序线索化二叉树1.头文件及类型定义2.线索二叉树结点类型定义3.函数声明4.基本操作4.1 先序建立线索二叉树4.2 初始化tag4.3 后序线索化二叉树4.3.1 访问并建立线索4.3.2 遍历4.3.3 后序线索化主过程4.4 寻找后序前驱4.5 逆向后序遍历4.5.1 打印结点4.5.2 利用后序前驱实现逆向后序遍历4.6 main函数4.7 测试4.7.1 二叉树结构4.7.2 测试结果5.小结 1.头文件及类型定义 #include<stdio.h> #include<stdl
线索二叉树(中序线索化)
最新发布
2302_78280224的博客
04-29 472
对于n个结点的二叉树，在二叉链存储结构中有n+1个空链域，利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针，这些指针称为线索，加上线索的二叉树称为线索二叉树。这种加上了线索的二叉链表称为线索，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种。
c语言后序线索二叉树（超详细）学习笔记
记录学习过程
11-30 1276
详细推导+完整代码+运行结果 = 值得一看。
线索二叉树(中序、先序和后序及遍历)
达的程序员日记
05-02 1万+
线索二叉树是二叉树的一种。介绍了线索二叉树的三种遍历以及实现。
线索二叉树(前中后序线索化/遍历/画线索)
Curz酥的博客
05-01 1万+
考研数据结构笔记。线索二叉树(前中后序线索化/遍历/画线索)
二叉树的基本操作，包括前序、中序、后序遍历的递归和非递归算法
10-21
本文将深入探讨二叉树的前序、中序、后序遍历的递归和非递归算法。 1. **前序遍历**： - **递归算法**：首先访问根节点，然后递归地对左子树进行前序遍历，最后对右子树进行前序遍历。伪代码如下： ``` function...
2008-数据结构与算法-期末试题B1
08-03
【数据结构与算法期末试题解析】 1. 对称矩阵压缩存储：在10阶对称矩阵中，元素85a位于第8行第5列，由于是对称矩阵，所以存储时只需要存储下三角或上三角部分，对于主序存储，地址计算公式通常为(行下标-1)*阶数+列...
C语言数据结构之线索二叉树及其遍历
08-29
线索二叉树是一种特殊的二叉树结构，它的设计目的是为了在非递归方式下更高效地查找二叉树中节点的前驱和后继。在普通的二叉链表中，节点仅通过...理解线索二叉树的原理和实现，对于深入学习数据结构和算法至关重要。
C语言 数据结构之中序二叉树实例详解
01-20
在C语言中，数据结构是计算机科学中的一个重要概念，它涉及到如何有效地组织和管理数据，以便于高效地执行各种操作。...理解和实现线索二叉树是深入学习数据结构和算法的重要一步，也是提高程序性能的关键。
算法-理论基础- 二叉树- 线索链表（包含源程序）.rar
09-16
二叉树是计算机科学中一种重要的数据结构，它在算法设计和实现中起着至关重要的作用。线索链表是二叉树的一种存储方式，尤其在遍历和查找操作中非常实用。本文将深入探讨二叉树的基本概念、线索单链表的概念以及如何...
二叉树(线索二叉树、链式二叉树、有序二叉树) 常见操作代码实现
04-08
内容概要：用c代码完成链式二叉树、有序二叉树、线索二叉树的的常见操作。其中包括构建、销毁、前序/后序/中序遍历、高度、密度、添加、删除、查询等操作 适合人群：具备一定编程基础，尤其是c语言基础，并很好地...
数据结构之线索二叉树详细解释
01-15
线索二叉树是一种在二叉树中添加额外线索来辅助遍历的数据结构，它使得在二叉树中实现前序、中序和后序遍历变得更加高效。在标准的二叉链表表示中，我们只能通过左右孩子指针进行遍历，而线索二叉树通过在节点中增加...
数据结构第三版(清华大学出版社)中各种结构与算法的C++代码实现
03-14
1. **线索二叉树.cpp**：线索二叉树是一种增强型的二叉搜索树，通过在二叉树的边（指针）上附加线索，使得在二叉树中进行前序、中序和后序遍历更为便捷。这个文件实现了线索二叉树的插入、删除和遍历操作。 2. **...
数据结构与算法总复习（知识点+习题+关键代码）
05-08
7. **二叉树**：线索二叉树是为遍历提供线索的二叉树，可以方便地进行前序、中序和后序遍历。构建线索二叉树时，需要找到空域并连接左右线索。 8. **图**：连通图是指无向图中任意两个节点都有路径相连。强连通图则...
【数据结构】树-线索二叉树（动态图解、c++、java）
扑腾的江鱼复习仓库
03-01 2334
URLeisure的线索二叉树“完美”复习资料。
【数据结构·考研】后序线索二叉树
Jiawen9的博客
03-09 1676
后序线索二叉树c++实现
后序线索化二叉树及遍历（图解）
热门推荐
CodingStart
08-01 7万+
线索二叉树的后序遍历详细介绍，图解，特别适合初学者，以及懒得画图的童鞋了
c++数据结构树的二叉树前序中序后序的递归与非递归代码
06-06
好的，以下是C++数据结构树的二叉树前序、中序和后序遍历的递归和非递归实现代码。 ```c++ // 定义二叉树的结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; // 二叉树前序遍历（递归）代码 void preorderTraversal(TreeNode* root) { if (root == NULL) return; cout << root->val << " "; // 输出当前节点的值 preorderTraversal(root->left); // 递归遍历左子树 preorderTraversal(root->right); // 递归遍历右子树 } // 二叉树前序遍历（非递归）代码 void preorderTraversal(TreeNode* root) { if (root == NULL) return; stack<TreeNode*> s; // 定义栈 s.push(root); // 根节点入栈 while (!s.empty()) { TreeNode* cur = s.top(); // 取出栈顶元素 s.pop(); cout << cur->val << " "; // 输出当前节点的值 if (cur->right != NULL) s.push(cur->right); // 先将右子树入栈 if (cur->left != NULL) s.push(cur->left); // 再将左子树入栈 } } // 二叉树中序遍历（递归）代码 void inorderTraversal(TreeNode* root) { if (root == NULL) return; inorderTraversal(root->left); // 递归遍历左子树 cout << root->val << " "; // 输出当前节点的值 inorderTraversal(root->right); // 递归遍历右子树 } // 二叉树中序遍历（非递归）代码 void inorderTraversal(TreeNode* root) { if (root == NULL) return; stack<TreeNode*> s; // 定义栈 TreeNode* cur = root; while (cur != NULL || !s.empty()) { while (cur != NULL) { // 将当前节点及其左子树入栈 s.push(cur); cur = cur->left; } cur = s.top(); // 取出栈顶元素 s.pop(); cout << cur->val << " "; // 输出当前节点的值 cur = cur->right; // 遍历右子树 } } // 二叉树后序遍历（递归）代码 void postorderTraversal(TreeNode* root) { if (root == NULL) return; postorderTraversal(root->left); // 递归遍历左子树 postorderTraversal(root->right); // 递归遍历右子树 cout << root->val << " "; // 输出当前节点的值 } // 二叉树后序遍历（非递归）代码 void postorderTraversal(TreeNode* root) { if (root == NULL) return; stack<TreeNode*> s1, s2; // 定义两个栈 s1.push(root); // 根节点入栈 while (!s1.empty()) { TreeNode* cur = s1.top(); // 取出栈顶元素 s1.pop(); s2.push(cur); // 将栈顶元素存入第二个栈 if (cur->left != NULL) s1.push(cur->left); // 将左子树入栈 if (cur->right != NULL) s1.push(cur->right); // 将右子树入栈 } while (!s2.empty()) { cout << s2.top()->val << " "; // 输出第二个栈的元素 s2.pop(); } } ``` 希望这些代码可以帮助到您。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值