C++ 二叉树 前序遍历 中序遍历 后序遍历

最新推荐文章于 2024-05-15 00:15:33 发布
最新推荐文章于 2024-05-15 00:15:33 发布
阅读量9.4k 收藏 22
点赞数 4
分类专栏： 算法与数据结构 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40702444/article/details/121986580
版权
10
6
4
8
14
12
16

一般二叉树有3中遍历方式

  1. 前序遍历：先访问根节点，再访问左子节点，最后访问右子节点。对于上图二叉树的前序遍历顺序是：10、6、4、8、14、12、16
  2. 中序遍历：先访问左子节点，再访问根节点，最后访问右子节点。对于上图二叉树的中序遍历顺序是：4、6、8、10、12、14、16
  3. 后序遍历：先访问左子节点，再访问右子节点，最后访问根节点。对于上图二叉树的后序遍历顺序是：4、8、6、12、16、14、10

定义与辅助代码

struct BinaryTreeNode{
    int value;
    BinaryTreeNode *pLeft;
    BinaryTreeNode *pRight;
};

namespace SON_NODE{
    typedef int dir_type;
    constexpr dir_type LEFT = 1;
    constexpr dir_type RIGHT = 2;
}

BinaryTreeNode* AddNode(BinaryTreeNode *rootNode, int value, SON_NODE::dir_type dir){
    if (rootNode == nullptr){
        return nullptr;
    }
    BinaryTreeNode *pNew = new BinaryTreeNode();
    pNew->value = value;
    pNew->pLeft = nullptr;
    pNew->pRight = nullptr;
    if (dir == SON_NODE::LEFT){
        rootNode->pLeft = pNew;
    }
    else{
        rootNode->pRight = pNew;
    }
    return pNew;
}
// 生成上图中的树结构
BinaryTreeNode *GetBinaryTree(){
    BinaryTreeNode *rootNode = new BinaryTreeNode();
    rootNode->value = 10;
    rootNode->pLeft = nullptr;
    rootNode->pRight = nullptr;

    BinaryTreeNode *pNew = AddNode(rootNode, 6, SON_NODE::LEFT);
    AddNode(pNew, 4, SON_NODE::LEFT);
    AddNode(pNew, 8, SON_NODE::RIGHT);

    pNew = AddNode(rootNode, 14, SON_NODE::RIGHT);
    AddNode(pNew, 12, SON_NODE::LEFT);
    AddNode(pNew, 16, SON_NODE::RIGHT);
    return rootNode;
}
BinaryTreeNode *GetBinaryTree1(){
    return nullptr;
}
BinaryTreeNode *GetBinaryTree2(){
    BinaryTreeNode *rootNode = new BinaryTreeNode();
    rootNode->value = 10;
    rootNode->pLeft = nullptr;
    rootNode->pRight = nullptr;

    BinaryTreeNode *pNew = AddNode(rootNode, 6, SON_NODE::LEFT);
    AddNode(pNew, 8, SON_NODE::RIGHT);

    return rootNode;
}
BinaryTreeNode *GetBinaryTree3(){
    BinaryTreeNode *rootNode = new BinaryTreeNode();
    rootNode->value = 10;
    rootNode->pLeft = nullptr;
    rootNode->pRight = nullptr;

    BinaryTreeNode *pNew = AddNode(rootNode, 14, SON_NODE::RIGHT);
    AddNode(pNew, 12, SON_NODE::RIGHT);

    return rootNode;
}

前序遍历

// 前序遍历-递归
void PreOrderByRecursive(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    cout << rootNode->value << " ";
    PreOrderByRecursive(rootNode->pLeft);
    PreOrderByRecursive(rootNode->pRight);
}

前序遍历的递归代码非常简洁，不必多说
但我们可以用递归的实现来推导非递归的实现
10
6
4
8
14
12
16

以上图为例，递归的思想既是先访问根节点10，然后将10的左子节点当作根节点递归调用
那么编译器具体是如何实现这种功能的呢？答案是函数栈，我们可以模拟一下大概的过程
当第一次调用函数时，便会开辟一个栈内存，这个栈中只有3个步骤
(方括号表示一个栈内存，删除线表示已经执行)

(栈顶)
A [访问node、左子节点递归调用、右子节点递归调用]

当函数执行到左子节点递归调用时，会有一个问题，递归调用的话肯定要执行一个新的函数，但是我(A)执行我自己(A’)，我(A)却还没有执行完，如何才能保证执行完我自己(A’)之后，我(A)再继续执行呢？答案是利用函数栈
在递归调用时，函数栈会开辟一个新的栈内存

(栈顶)
A’ [访问node、左子节点递归调用、右子节点递归调用]
A [访问node、左子节点递归调用、右子节点递归调用]

假如这时候(A’)又要递归，那么

(栈顶)
A’’ [访问node、左子节点递归调用、右子节点递归调用]
A’ [访问node、左子节点递归调用、右子节点递归调用]
A [访问node、左子节点递归调用、右子节点递归调用]

而当(A’’)执行完后，又到了(A’)的右子节点递归调用，那么

(栈顶)
A’’ [访问node、左子节点递归调用、右子节点递归调用]
A’ [访问node、左子节点递归调用、右子节点递归调用]
A [访问node、左子节点递归调用、右子节点递归调用]

之后，直到(A’’)执行完，才发现(A’)也执行完，之后才会轮到(A)的右子节点递归调用
假如我们模拟所有的操作都在一个栈中执行过程，那么最开始的时候是

(栈顶)
A [访问node]
A [左子节点递归调用]
A [右子节点递归调用]

当执行完访问node之后，该node就会出栈

(栈顶)
A [左子节点递归调用]
A [右子节点递归调用]

接下来执行左子节点递归调用

(栈顶)
A’ [访问node]
A’ [左子节点递归调用]
A’ [右子节点递归调用]
A [右子节点递归调用]

从上面的过程中，我们可以发现一个事情，对于每一个节点，都可以用3个栈内存来进行前序遍历，那就是右子节点在栈底，左子节点在上一层栈，本节点在栈顶，接着取出栈顶元素(访问本节点)，然后继续取出栈顶(左子节点)构建3个栈…如此循环直到栈为空表示所有节点都访问过

// 前序遍历-循环
/* 思想:
先将根节点放进栈
1. 取出栈顶节点node
2. 若node有右子节点，放进栈
3. 若node有左子节点，放进栈
重复1~3直到栈为空
*/
void PreOrderByLoop(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    vector<BinaryTreeNode *> treeNodeVec{rootNode};
    while (!treeNodeVec.empty()){
        auto pNode = treeNodeVec.back();
        treeNodeVec.pop_back();
        cout << pNode->value << " ";
        // 必须右子节点先进栈
        if (pNode->pRight != nullptr){
            treeNodeVec.push_back(pNode->pRight);
        }
        if (pNode->pLeft != nullptr){
            treeNodeVec.push_back(pNode->pLeft);
        }
    }
    cout << endl;
}

void TestPreOrder(){
    PreOrderByLoop(GetBinaryTree());
    PreOrderByLoop(GetBinaryTree1());
    PreOrderByLoop(GetBinaryTree2());
    PreOrderByLoop(GetBinaryTree3());
}

中序遍历

// 中序遍历-递归
void InOrderByRecursive(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    InOrderByRecursive(rootNode->pLeft);
    cout << rootNode->value << " ";
    InOrderByRecursive(rootNode->pRight);
}

根据递归代码推非递归实现，递归过程可以发现，对于每一个节点，右子节点会在栈底，该节点在中间，左子节点在栈顶构建3个栈空间，难点在于，对于栈顶节点，如何确保其左子节点已经被访问了，可以使用可访问标记来解决

/* 中序遍历-循环1
思想：
使用pair让每个节点都自带标记
1. 将根节点进栈
2. 取出栈顶元素
    a. 若左子节点没有被访问过，则依次将右子节点，本节点，左子节点入栈，并标记左子节点已访问
    b. 若左子节点已经被访问，输出本节点
3. 重复2至栈空
 */
void InOrderByLoop(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    vector< pair<BinaryTreeNode*, bool> > treeNodeVec;
    treeNodeVec.emplace_back(make_pair(rootNode, false));
    while (!treeNodeVec.empty()){
        auto pNode = treeNodeVec.back().first;
        auto &visited = treeNodeVec.back().second;
        treeNodeVec.pop_back();

        if (visited){
            cout << pNode->value << " ";
            treeNodeVec.pop_back();
            continue;
        }
        if (pNode->pRight != nullptr){
            treeNodeVec.emplace_back(make_pair(pNode->pRight, false));
        }
        treeNodeVec.emplace_back(make_pair(pNode, true));
        if (pNode->pLeft != nullptr){
            treeNodeVec.emplace_back(make_pair(pNode->pLeft, false));
        }
    }
    cout << endl;
}

void TestInOrder(){
    InOrderByLoop(GetBinaryTree());
    InOrderByLoop(GetBinaryTree1());
    InOrderByLoop(GetBinaryTree2());
    InOrderByLoop(GetBinaryTree3());
}

若不根据递归而根据中序遍历的规则(即先处理左子节点，只有左子节点输出后才处理右子节点)来实现非递归
10
6
4
8
14
12
16

我们根据上图来模拟一下后序遍历
首先从10开始遍历，根据规则，一定最先找到最左下角的叶子节点4，之后访问6，再到8，以此类推，访问结果为 4、6、8、10、12、14、16
遍历到一个节点时，先不输出，而是先将往左子节点遍历，待输出左子节点后，才输出本节点，这种先进后出的现象可以使用栈来解决
而对于一个栈顶节点，首先会将所有左子节点入栈(先访问左子节点)，那么此时栈顶节点有3种情况

  1. 没有左子节点
  2. 左子节点已经访问
  3. 左子节点没有访问

对第3中情况，继续入栈…
而前两种情况，直接出栈输出，输出该节点之后有2种情况

  1. 有右子节点
  2. 没有右子节点

第1种情况，显而易见需要处理右子节点(入栈)，然后继续处理栈顶节点
第2种情况，继续处理栈顶节点…

我们用上图来模拟一下，首先从根节点开始往左子节点遍历依次入栈，直到停止时栈情况为

(栈顶)
[4]
[6]
[10]

此时由于节点4没有左子节点，直接输出，然后也没有右子节点，所以栈变成

(栈顶)
[6]
[10]

请注意，这个时候我们并不用判断节点6的左子节点是否已经处理，因为一开始我们就把6的左子节点放到了栈的更上层。也就是说，当我们一开始便把所有左子节点依次入栈之后，对于所有栈顶元素，其要么没有左子节点要么左子节点已经被访问，此时我们只需要判断有没有右子节点并访问即可…
至此，我们便可以开始写代码

// 中序遍历-循环2
/* 思想:
1. 将指针指向根节点
2. 先遍历所有左子节点并入栈
3. 当指针没有左子节点时，出栈这个节点(相当于访问该节点)
4. 接着讲指针指向该节点的右子节点
5. 重复2~4操作直至栈空
*/
void InOrderByLoop1(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    vector<BinaryTreeNode *> treeNodeVec;
    auto *pNode = rootNode;
    while (!treeNodeVec.empty() || pNode != nullptr){
        while (pNode != nullptr){
            treeNodeVec.push_back(pNode);
            pNode = pNode->pLeft;
        }
        pNode = treeNodeVec.back();
        treeNodeVec.pop_back();
        cout << pNode->value << " ";
        pNode = pNode->pRight;
    }
    cout << endl;
}
// 不同实现
void InOrderByLoop2(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    vector<BinaryTreeNode *> treeNodeVec({rootNode});
    bool isNewNode = true;
    while (!treeNodeVec.empty()){
        auto pNode = treeNodeVec.back();
        // isNewNode表示当前栈顶是否是新加入的节点
        while (isNewNode && pNode->pLeft != nullptr){
            treeNodeVec.push_back(pNode->pLeft);
            pNode = pNode->pLeft;
        }
        treeNodeVec.pop_back();
        cout << pNode->value << " ";
        isNewNode = false;
        if (pNode->pRight != nullptr){
            treeNodeVec.push_back(pNode->pRight);
            isNewNode = true;
        }
    }
    cout << endl;
}

后序遍历

// 后序遍历-递归
void PostOrderByRecursive(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    PostOrderByRecursive(rootNode->pLeft);
    PostOrderByRecursive(rootNode->pRight);
    cout << rootNode->value << " ";
}

后序遍历的非递归方法中，难点在于，对于每一个节点，在访问前，如何确保这个节点的左右子节点都被访问过
通过递归调用栈可以得知，对于每一个节点，先将自己入栈，再将右子节点入栈，最后是左子节点入栈。那么只要本节点的左右节点入过栈，下一次本节点在栈顶时，就表示左右子节点已经访问过，此时就可访问本节点了
我们可以使用几种方式来标记本节点的左右节点入过栈

// 后序遍历-循环1
/* 思想:
在本节点入栈后，记录一个可访问标记，再将左右子节点入栈
这样每次发现栈顶的可访问标记为true时，就表示空标记下面的节点
的左右节点已经访问过，此时直接访问本节点
*/
void PostOrderByLoop(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    vector<BinaryTreeNode *> treeNodeVec({rootNode});
    while (!treeNodeVec.empty()){
        auto pNode = treeNodeVec.back();
        if (pNode == nullptr){
            treeNodeVec.pop_back();
            cout << treeNodeVec.back()->value << " ";
            treeNodeVec.pop_back();
            continue;
        }
        // 添加可访问标记
        treeNodeVec.push_back(nullptr);
        if (pNode->pRight != nullptr){
            treeNodeVec.push_back(pNode->pRight);
        }
        if (pNode->pLeft != nullptr){
            treeNodeVec.push_back(pNode->pLeft);
        }
    }
    cout << endl;
}
// 与上述思想一致
void PostOrderByLoop1(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    vector< pair<BinaryTreeNode*, bool> > treeNodeVec;
    treeNodeVec.emplace_back(make_pair(rootNode, false));
    while (!treeNodeVec.empty()){
        auto pNode = treeNodeVec.back().first;
        auto &visited = treeNodeVec.back().second;

        if (visited){
            cout << pNode->value << " ";
            treeNodeVec.pop_back();
            continue;
        }
        visited = true;
        if (pNode->pRight != nullptr){
            treeNodeVec.emplace_back(make_pair(pNode->pRight, false));
        }
        if (pNode->pLeft != nullptr){
            treeNodeVec.emplace_back(make_pair(pNode->pLeft, false));
        }
    }
    cout << endl;
}

void TestOrder(){
    PostOrderByLoop(GetBinaryTree());
    PostOrderByLoop(GetBinaryTree1());
    PostOrderByLoop(GetBinaryTree2());
    PostOrderByLoop(GetBinaryTree3());
}

代码中对于每一个节点，我们都额外创建了一个bool或者空指针来判断该节点是否左右子节点已访问，那么有没有不用为每个节点都创建标记的办法呢？
上述实现都是基于递归函数调用栈的想法来改进的，接下来我们直接通过后序遍历的规则(先处理左子节点，左子节点输出后，再处理右子节点)来实现一下
10
6
4
8
14
12
16

我们根据上图来模拟一下后序遍历
首先从10开始遍历，根据规则，一定最先找到最左下角的叶子节点4，之后回到6，发现6还有右子节点，那么会找到8，这时候6的左右子节点都被访问了，那么访问6，以此类推，访问结果为 4、8、6、12、16、14、10…
让我们找一下其中的规律，首先访问4之前，实际上已经经过6了，而输出4之后还要回到6再去访问8，接着才能访问6，对于这种先经过却后访问的方式，可以很容易联想到用栈来解决
我们首先创建一个栈，对于一个节点，我们先将所有左子节点依次入栈(先访问左子节点)。这时候我们可以确立一种规则，对于栈顶元素，我们可以保证该节点没有左子节点or左子节点已经被访问。接下来我们只需要判断该节点的右子节点是否被访问就能确定该节点能否访问了
此时栈顶的节点有3种情况：

  1. 没有右子节点
  2. 右子节点已经访问
  3. 右子节点还没访问

我们用上图来模拟一下，假设已经访问4(节点4已经出栈)，栈顶就是节点6，这时候我们要怎么确保节点8已经被访问过了呢？细心的同学一定会发现，假如节点6可以被访问，那么上一个出栈的一定是节点8(这不是废话嘛)，将这个顺序转换成二叉树的结构来说就是，一个节点可以被访问，那么上一个被访问的一定是该节点的右子节点!!!
至此，我们便可以开始写代码

/* 后序遍历-循环2
思想：
1. 根节点入栈
2. 循环将栈顶元素的左子节点入栈
3. 取栈顶元素node
    a. 若node没有右子节点，则输出node，出栈，重新进入步骤3
    b. 若node有右子节点，但右子节点为上一个输出的节点，则输出node，出栈，重新进入步骤3
    c. 若node有右子节点，且不是上一个输出的节点，右子节点进栈，返回步骤2
4. 循环2~4至栈空
 */
void PostOrderByLoop2(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    vector<BinaryTreeNode *> treeNodeVec({rootNode});
    BinaryTreeNode *lastOutputNode = nullptr;
    BinaryTreeNode *pNode = nullptr;
    while (!treeNodeVec.empty()){
        pNode = treeNodeVec.back();
        while (pNode->pLeft != nullptr){
            treeNodeVec.emplace_back(pNode->pLeft);
            pNode = pNode->pLeft;
        }
        // 所有节点已经入过栈了，此时只需要输出所有节点即可
        while (!treeNodeVec.empty()){
            pNode = treeNodeVec.back();
            if (pNode->pRight == lastOutputNode || pNode->pRight == nullptr){
                cout << pNode->value << " ";
                treeNodeVec.pop_back();
                lastOutputNode = pNode;
            }
            else{
                treeNodeVec.emplace_back(pNode->pRight);
                break;
            }
        }
    }
    cout << endl;
}

至此，豁然开朗
而后在网上搜了一下，貌似对于三种非递归用统一方式实现很受欢迎，就贴一下代码吧

void OrderByLoop(BinaryTreeNode *rootNode){
    if (rootNode == nullptr){
        return;
    }
    vector<pair<BinaryTreeNode*, bool>> treeNodeVec;
    treeNodeVec.emplace_back(make_pair(rootNode, false));
    while (!treeNodeVec.empty()){
        auto pNode = treeNodeVec.back().first;
        auto &visited = treeNodeVec.back().second;
        treeNodeVec.pop_back();

        if (visited){
            cout << pNode->value << " ";
            treeNodeVec.pop_back();
            continue;
        }
        // 对于不同遍历方式，只需要改变一下三种进栈顺序即可，需要先访问的后进栈
        // 右子节点
        if (pNode->pRight != nullptr){
            treeNodeVec.emplace_back(make_pair(pNode->pRight, false));
        }
        // 本节点
        treeNodeVec.emplace_back(make_pair(pNode, true));
        // 左子节点
        if (pNode->pLeft != nullptr){
            treeNodeVec.emplace_back(make_pair(pNode->pLeft, false));
        }
    }
    cout << endl;
}

参考文献：
[1] 李春葆.数据结构教程(第4版)[M].172-181.
[2] 何海涛.剑指Offer(第2版)[M].60-61.
[3] https://blog.csdn.net/czy47/article/details/81254984

佳哥在此
关注
  • 4
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++】前序遍历、中序遍历、后序遍历、层序遍历
https://blog.csdn.net/WL0616
07-31 1910
二叉树深度优先遍历：前序遍历、中序遍历、后序遍历 二叉树广度优先遍历：层序遍历 二叉树的遍历规则： 前序遍历：5 4 1 2 6 7 8 中序遍历：1 4 2 5 7 6 8 后序遍历：1 2 4 7 8 6 5 层序遍历： 以下以前序遍历为例： 1.确定递归函数的参数和返回值：因为要打印出前序遍历节点的数值，所以参数里需要传入vector在放节点的数值，除了这一点就不需要在处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下： void traversal(TreeNode* cu
二叉树遍历-前序中序后序层次遍历
02-28
本文将深入探讨四种常见的二叉树遍历方法：前序遍历、中序遍历、后序遍历以及层次遍历，并以C++编程语言为例，阐述如何实现这些遍历算法。 1. **前序遍历**（Preorder Traversal） 前序遍历的顺序是根节点 -> 左...
二叉树前序、中序、后序、层序遍历(递归、非递归、Morris遍历) C++语言实现
zhangbw's blog
04-25 941
二叉树前序、中序、后序、层序遍历。(递归、非递归、morris遍历) C++语言实现
C++先序遍历
babyai996的博客
12-22 1145
先序遍历是一种树形数据结构的遍历方式，它的顺序是先访问根节点，再访问左子树，最后访问右子树。输出： Preorder traversal: 1 2 4 5 3 6 7。的函数，该函数接受一个指向树节点的指针作为参数，并对树进行先序遍历。这段代码实现了一个名为。
C C++最全【算法】二叉树的遍历指南(前序、中序、后序、层序，《C C++面试题及解析》分享给大家
最新发布
2401_84976377的博客
05-15 760
二叉树（Binary tree）是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。在下面这副图中，F就是这棵二叉树的根节点，其左、右孩子节点分别为C、E。前序、中序、后序遍历其实都是深度优先思想的体现，我这里采用递归写法，便于记忆，三者的区别在于：遍历左右子树与对此节点做出操作（）的顺序对比三种算法，大家可以很清晰地找到他们唯一的不同点：print()函数与两个递归的先后执行顺序。总结以下，可以发现前序遍历。
后续遍历（Postorder traversal）c++语言
m0_61862494的博客
03-10 851
函数接收一个指向二叉树根节点的指针，遍历左子树、右子树和根节点的顺序符合后序遍历的要求。在函数中，当指针为空时，直接返回；否则，先遍历左子树，再遍历右子树，最后访问根节点并输出。后续遍历（Postorder traversal）是二叉树的一种遍历方式，它的遍历顺序是先访问左子树，再访问右子树，最后访问根节点。在实际的代码中，我们可以通过调用这个构造函数来创建一个新的。在这个构造函数中，通过初始化列表的方式，给节点的。节点，并将节点的值和左右子树指针初始化为默认值。的构造函数，用于创建一个新的。
数据结构实验：C++实现二叉树的建立与遍历(先、中、后序，层次)
qq_45050714的博客
01-01 2235
数据结构实验三：二叉树的建立与遍历 1. 实验内容 运用先序遍历的顺序建立二叉树, 对二叉树进行先序、中序、后序(包括递归与非递归)和层次遍历 2.二叉树结点类与二叉树类 template<typename ElemType> class treeNode { public: ElemType data; treeNode* lchild, * rchild; //树左右孩子结点 treeNode() :data(0), lchild(NULL), rchild(NULL) {};
二叉树前中后遍历、层次遍历及构造写法（C++）
m19166的博客
04-05 188
二叉树遍历时，递归法代码相对简单，递归法是方便程序员自身读取，其保存函数指针到栈等操作相比非迭代法来说，空间损耗严重。这里面之所以C++结构体可以使用构造函数，是因为C++的结构体本质上与函数没有区别，只是初始时结构体的访问类型为public。从代码可以发现，其实我们仅仅是使用了NULL来进行对节点访问的控制，当然这与栈的特性也有关。向量表达方式，不常用，且每次递归需要创建vector向量，开销较大。
C++基于先序、中序遍历结果重建二叉树的方法
12-26
本文实例讲述了C++基于先序、中序遍历结果重建二叉树的方法。分享给大家供大家参考，具体如下： 题目： 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含...
前序遍历中序遍历生成二叉树并查找节点
10-31
设二叉树结点值为大写字母，输入二叉树的前序遍历和中序遍历序列，生成此二叉树，输出该二叉树的后序遍历和按层次遍历序列。输入某结点值，在二叉树中查找该结点，若该结点存在，则输出从根到该结点的路径，否则给出...
C++数据结构已知二叉树的前序遍历与中序遍历结果求后序遍历.pdf
11-25
常见的遍历方式有前序遍历、中序遍历和后序遍历。 3. 前序遍历：前序遍历是一种遍历方式，先访问当前节点，然后递归地访问左子节点和右子节点。其顺序是：当前节点 -> 左子节点 -> 右子节点。 4. 中序遍历：中序...
c++二叉树中序遍历
05-27
c++环境下 二叉树的存储结构及实现 中序遍历
先序 中序 后序遍历二叉树代码
02-14
按要求输入二叉树，然后执行可输出先序 中序 后序遍历二叉树的结果。
二叉树已知后序和中序遍历求前序遍历，C++代码
12-02
二叉树已知后序和中序遍历求前序遍历，C++编写已通过编译
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历）
12-31
C++ 数据结构二叉树（前序/中序/后序递归、非递归遍历） 二叉树的性质： 二叉树是一棵特殊的树，二叉树每个节点最多有两个孩子结点，分别称为左孩子和右孩子。 例： 实例代码： #include #include #include ...
数据结构C++二叉树的先序遍历、中序遍历和后序遍历实现
12-06
数据结构C++二叉链表的先序遍历、中序遍历和后序遍历实现
数据结构与算法之中序遍历
weixin_47225948的博客
09-20 5433
中序遍历是一种二叉树的遍历方式，其遍历顺序为先遍历左子树，然后遍历根节点，最后遍历右子树。具体的过程如下：如果当前节点的左子树非空，则递归遍历左子树。访问当前节点。如果当前节点的右子树非空，则递归遍历右子树。中序遍历是二叉搜索树中最常用的遍历方式之一，因为它可以将树中所有节点按照大小顺序输出。在实际应用中，中序遍历常用于查找二叉搜索树中的某个节点，或者对二叉搜索树中的节点进行排序。
二叉树的前中后序遍历（C++）
海&的博客
07-17 262
二叉树及表达式二叉树的遍历方式
c++二叉树的前，中，后序遍历实现
性感的小君君
08-31 977
本文主要实现了一个二叉树（c++），并且通过迭代的方式，实现了二叉树的前序遍历，中序遍历，后续遍历。
用c++实现二叉树的前序中序后序遍历
05-31
以下是使用C++实现二叉树的前序中序后序遍历的示例代码： ```cpp #include <iostream> using namespace std; // 定义二叉树结点 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} }; // 构建二叉树 TreeNode* buildTree(int pre[], int in[], int preStart, int preEnd, int inStart, int inEnd) { if (preStart > preEnd || inStart > inEnd) { return nullptr; } int rootVal = pre[preStart]; int rootIndex = 0; for (int i = inStart; i <= inEnd; i++) { if (in[i] == rootVal) { rootIndex = i; break; } } int leftLen = rootIndex - inStart; TreeNode* root = new TreeNode(rootVal); root->left = buildTree(pre, in, preStart + 1, preStart + leftLen, inStart, rootIndex - 1); root->right = buildTree(pre, in, preStart + leftLen + 1, preEnd, rootIndex + 1, inEnd); return root; } // 前序遍历 void preOrder(TreeNode* root) { if (root == nullptr) { return; } cout << root->val << " "; preOrder(root->left); preOrder(root->right); } // 中序遍历 void inOrder(TreeNode* root) { if (root == nullptr) { return; } inOrder(root->left); cout << root->val << " "; inOrder(root->right); } // 后序遍历 void postOrder(TreeNode* root) { if (root == nullptr) { return; } postOrder(root->left); postOrder(root->right); cout << root->val << " "; } int main() { int pre[] = {1, 2, 4, 5, 3, 6, 7}; int in[] = {4, 2, 5, 1, 6, 3, 7}; TreeNode* root = buildTree(pre, in, 0, 6, 0, 6); cout << "前序遍历结果："; preOrder(root); cout << endl; cout << "中序遍历结果："; inOrder(root); cout << endl; cout << "后序遍历结果："; postOrder(root); cout << endl; return 0; } ``` 在上面的代码中，我们首先定义了二叉树结点结构体`TreeNode`，然后实现了一个`buildTree`函数，该函数用于根据前序遍历数组和中序遍历数组构建二叉树。接着，我们分别实现了前序遍历、中序遍历和后序遍历的函数，最后在主函数中调用这些函数进行遍历。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值