二叉树的先序、中序、后序、层序遍历方式详解，由遍历序列构造二叉树过程详解以及C++代码详细实现

已于 2022-08-04 21:54:43 修改
阅读量7.3k 收藏 46
点赞数 9
分类专栏： 数据结构笔记 文章标签： c++ 算法 数据结构
于 2022-07-13 11:44:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45651616/article/details/125760207
版权

二叉树的遍历

树与二叉树的定义、性质，二叉树的顺序存储结构、链式存储结构

二叉树的遍历是指按某条搜索路径访问树中每个结点，使得每个结点均被访问一次，而且仅被访问一次。由于二叉树是一种非线性结构，每个结点都可能有两棵子树，因而需要寻找一种规律，以便使二叉树上的结点能排列在一个线性队列上，进而便于遍历。

由二叉树的递归定义可知，遍历一棵二叉树便要决定对根结点 N {\rm N} N 、左子树 L {\rm L} L 和右子树 R {\rm R} R 的访问顺序。按照先遍历左子树再遍历右子树的原则，常见的遍历次序有先序（ N L R {\rm NLR} NLR ）、中序（ L N R {\rm LNR} LNR ） 和后序（ L R N {\rm LRN} LRN ）三种遍历算法，其中"序"指的是根结点在何时被访问。

image-20220712161552290
一棵二叉树

1.先序遍历

先序遍历（ P r e O r d e r {\rm PreOrder} PreOrder）的操作过程如下。

若二叉树为空，则什么也不做；否则，

1）访问根结点；
2）先序遍历左子树；
3）先序遍历右子树。

对应的递归算法如下：

template<typename T>
struct BiTree {
    T data;                     //数据域
    BiTree *lchild, *rchild;    //左、右孩子指针
};

template<typename T>
void PreOrder(BiTree<T> *bt) {
    if (bt != NULL) {
        visit(bt);                //访问根结点
        PreOrder(bt->lchild);     //递归遍历左子树
        PreOrder(bt->rchild);     //递归遍历右子树
    }
}

对于上图所示的二叉树，先序遍历所得到的结点序列为1 2 4 6 3 5。

2.中序遍历

中序遍历（ I n O r d e r {\rm InOrder} InOrder）的操作过程如下。

若二叉树为空，则什么也不做；否则，

1）中序遍历左子树；
2）访问根结点；
3）中序遍历右子树。

对应的递归算法如下：

template<typename T>
void InOrder(BiTree<T> *bt) {
    if (bt != NULL) {
        InOrder(bt->lchild);     //递归遍历左子树
        visit(bt);               //访问根结点
        InOrder(bt->rchild);     //递归遍历右子树
    }
}

对于上图所示的二叉树，中序遍历所得到的结点序列为2 6 4 1 3 5

3.后序遍历

后序遍历（ P o s t O r d e r {\rm PostOrder} PostOrder）的操作过程如下。

若二叉树为空，则什么也不做；否则，

1）后序遍历左子树；
2）后序遍历右子树；
3）访问根结点。

对应的递归算法如下：

template<typename T>
void PostOrder(BiTree<T> *bt) {
    if (bt != NULL) {
        PostOrder(bt->lchild);     //递归遍历左子树
        PostOrder(bt->rchild);     //递归遍历右子树
        visit(bt);                 //访问根结点
    }
}

对于上图所示的二叉树，后序遍历所得到的结点序列为6 4 2 5 3 1。

三种遍历算法中，递归遍历左、右子树的顺序都是固定的，只是访问根结点的顺序不同。不管采用哪种遍历算法，每个结点都访问一次且仅访问一次，故时间复杂度都是 O ( n ) {\rm O(n)} O(n) 。在递归遍历中，递归工作栈的栈深恰好为树的深度，所以在最坏情况下，二叉树是有 n {\rm n} n 个结点且深度为 n {\rm n} n 的单支树，遍历算法的空间复杂度为 O ( n ) {\rm O(n)} O(n) 。

4.层序遍历

image-20220712192820972

上图所示为二叉树的层序遍历，即按照箭头所指方向，按照1，2，3，4的层次顺序，对二叉树中的各个结点进行访问。

要进行层序遍历，需要借助一个队列，其基本思路如下：

1）将根结点root加入队列q。
2）取出队首结点，访问它。
3）如果该结点有左孩子，将左孩子入队。
4）如果该结点有右孩子，将右孩子入队。
5）返回步骤2，直到队列为空。

对应的遍历算法如下：

template<typename T>
void LayerOrder(BiTree<T> *root) {
    queue<BiTree<T> *> q;   //注意队列里面存的是地址
    q.push(root);           //根结点地址入队
    while (!q.empty()) {
        BiTree<T> *now = q.front(); //取出队首元素
        q.pop();
        cout << now->data << "\t";  //访问队首元素
        if (now->lchild != NULL) q.push(now->lchild);   //左子树非空
        if (now->rchild != NULL) q.push(now->rchild);   //右子树非空
    }
}

5.由遍历序列构造二叉树

由二叉树的先序序列和中序序列可以唯一地确定一棵二叉树。

在先序遍历序列中，第一个结点一定是二叉树的根结点；
而在中序遍历中，根结点必然将中序序列分割成两个子序列，前一个子序列是根结点的左子树的中序序列，后一个子序列是根结点的右子树的中序序列。
根据这两个子序列，在先序序列中找到对应的左子序列和右子序列。在先序序列中，左子序列的第一个结点是左子树的根结点，右子序列的第一个结点是右子树的根结点。 如此递归地进行下去，便能唯一地确定这棵二叉树。

例子：求先序序列 A B C D E F G H I {\rm ABCDEFGHI} ABCDEFGHI 和中序序列 B C A E D G H F I {\rm BCAEDGHFI} BCAEDGHFI 所确定的二叉树。

1）首先，由先序序列可知 A {\rm A} A 为二叉树的根结点。
2）中序序列中 A {\rm A} A 之前的 B C {\rm BC} BC 为左子树的中序序列， E D G H F I {\rm EDGHFI} EDGHFI 为右子树的中序序列。
3）然后由先序序列可知 B {\rm B} B 是左子树的根结点， D {\rm D} D 是右子树的根结点。
4）以此类推，就能将剩下的结点继续分解下去，最后得到的二叉树如下图所示

image-20220712210753050
一棵二叉树的构造过程

6.下面推理由遍历序列构造二叉树的一般递归过程

构建二叉树第 1 步：

假设已知先序序列为 p r e 1 , p r e 2 , … , p r e n {\rm pre_1,pre_2, \dots, pre_n} pre1​,pre2​,…,pren​，中序序列为 i n 1 , i n 2 , … , i n n {\rm in_1,in_2, \dots, in_n} in1​,in2​,…,inn​，如下图所示。
那么由先序序列的性质可知，先序序列第一个元素 p r e 1 {\rm pre_1} pre1​ 是当前二叉树的根结点。
再由中序序列的性质可知，当前二叉树的根结点将中序序列划分为左子树和右子树。
因此，要做的就是在中序序列中找到某个结点 i n k {\rm in_k} ink​，使得 i n k = = p r e 1 {\rm in_k==pre_1} ink​==pre1​ ，这样就在中序序列中找到了根结点。由此可知左子树的结点个数 n u m L e f t = k − 1 {\rm numLeft=k-1} numLeft=k−1 。于是：
左子树的先序序列区间就是 [ 2 , k ] {\rm [2,k]} [2,k] ，
左子树的中序序列区间是 [ 1 , k − 1 ] {\rm [1,k-1]} [1,k−1] ；
右子树的先序序列区间是 [ k + 1 , n ] {\rm [k+1,n]} [k+1,n]
右子树的中序序列区间 [ k + 1 , n ] {\rm [k+1,n]} [k+1,n]
接着只需要往左子树和右子树进行递归构建二叉树即可。

image-20220712214237590
先序序列与中序序列构建二叉树第1步示意图

构建二叉树中间步：

事实上，如果递归过程中当前先序序列的区间为 [ p r e L , p r e R ] {\rm [preL,preR]} [preL,preR] ，中序序列的区间为 [ i n L , i n R ] {\rm [inL,inR]} [inL,inR] ，那么左子树的结点个数为 n u m L e f t = k − i n L {\rm numLeft=k-inL} numLeft=k−inL 。这样：
左子树的先序序列区间就是 [ p r e L + 1 , p r e L + n u m L e f t ] {\rm [preL+ 1,preL + numLeft]} [preL+1,preL+numLeft] ，
左子树的中序序列区间是 [ i n L , k − 1 ] {\rm [inL, k - 1]} [inL,k−1] ，
右子树的先序序列区间是 [ p r e L + n u m L e f t + 1 , p r e R ] {\rm [preL +numLeft +1, preR]} [preL+numLeft+1,preR] ，
右子树的中序序列区间是 [ k + 1 , i n R ] {\rm [k+1, inR]} [k+1,inR] ，如下图所示。

那么，如果一直这样递归下去，什么时候是尽头呢？这个问题的答案是显然的，因为只要先序序列的长度小于等于0时，当前二叉树就不存在了，于是就能以这个条件作为递归边界。

image-20220712215556764
先序序列与中序序列构建二叉树中间步示意图

对应的完整二叉树构造算法代码如下：

这里构造先序序列为 A B C D E F G H I {\rm ABCDEFGHI} ABCDEFGHI 和中序序列为 B C A E D G H F I {\rm BCAEDGHFI} BCAEDGHFI 所确定的二叉树。

image-20220712232558316 
#include <iostream>

using namespace std;

template<typename T>
struct BiTNode {
    T data;                     //数据域
    BiTNode *lchild, *rchild;   //左、右孩子指针
};

template<typename T>
class BiTree {
private:
    BiTNode<T> *root;   //根结点
    T *pre;             //先序序列
    T *in;              //中序序列
    int length;         //二叉树中的结点个数

    //构造二叉树
    //当前先序序列区间为[preL, preR]，中序序列区间为[inL, inR]，返回根结点地址
    BiTNode<T> *create(int preL, int preR, int inL, int inR) {
        if (preL > preR)
            return NULL;    //先序序列长度小于等于0时,直接返回

        BiTNode<T> *biTNode = new BiTNode<T>;   //新建一个新的结点,用来存放当前二叉树的根结点
        biTNode->data = pre[preL];  //新结点的数据域为根结点的值，根结点是当前先序序列区间的第1个结点

        int k;  //存储当前中序序列区间的根结点的索引
        for (k = inL; k <= inR; k++)
            if (in[k] == pre[preL])     //在中序序列中找到in[k] == pre[L]的结点
                break;

        int numLeft = k - inL;  //左子树的结点个数

        //左子树的先序区间为[preL+1,preL+numLeft]，中序区间为[inL,k-1]
        //返回左子树的根结点地址,赋值给root的左指针
        biTNode->lchild = create(preL + 1, preL + numLeft, inL, k - 1);

        //右子树的先序区间为[preL + numLeft + 1,preR]，中序区间为[k+1,inR]
        //返回右子树的根结点地址,赋值给root的右指针
        biTNode->rchild = create(preL + numLeft + 1, preR, k + 1, inR);

        return biTNode; //返回根结点地址
    }

    //后序遍历
    void PostOrder(BiTNode<T> *biTNode) {
        if (biTNode != NULL) {
            PostOrder(biTNode->lchild);
            PostOrder(biTNode->rchild);
            cout << biTNode->data << "\t";
        }
    }

public:
    //初始化先序序列，中序序列，然后根据这两个序列构造二叉树
    BiTree(T *pre, T *in, int length) {

        this->length = length;
        this->pre = new T[length + 1];
        this->in = new T[length + 1];

        //初始化先序序列，中序序列
        for (int i = 1; i <= length; i++) {
            this->pre[i] = pre[i];
            this->in[i] = in[i];
        }

        //构造二叉树
        root = create(1, length, 1, length);
    }


    //后序遍历
    void PostOrder() {
        PostOrder(root);
    }

};

int main() {
    char pre[] = {'#', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'};
    char in[] = {'#', 'B', 'C', 'A', 'E', 'D', 'G', 'H', 'F', 'I'};

    BiTree<char> biTree(pre, in, 9);
    biTree.PostOrder();
    return 0;
}

运行结果：

C       B       E       H       G       I       F       D       A

继续以上面例子的二叉树为例，实现先序遍历，中序遍历，后序遍历，层序遍历，二叉树构造算法完整代码以及测试代码如下：

#include <iostream>
#include "queue"

using namespace std;

template<typename T>
struct BiTNode {
    T data;                     //数据域
    BiTNode *lchild, *rchild;   //左、右孩子指针
};

template<typename T>
class BiTree {
private:
    BiTNode<T> *root;   //根结点
    T *pre;             //先序序列
    T *in;              //中序序列
    int length;         //二叉树中的结点个数

    //构造二叉树
    //当前先序序列区间为[preL, preR]，中序序列区间为[inL, inR]，返回根结点地址
    BiTNode<T> *create(int preL, int preR, int inL, int inR) {
        if (preL > preR)
            return NULL;    //先序序列长度小于等于0时,直接返回

        BiTNode<T> *biTNode = new BiTNode<T>;   //新建一个新的结点,用来存放当前二叉树的根结点
        biTNode->data = pre[preL];  //新结点的数据域为根结点的值，根结点是当前先序序列区间的第1个结点

        int k;  //存储当前中序序列区间的根结点的索引
        for (k = inL; k <= inR; k++)
            if (in[k] == pre[preL])     //在中序序列中找到in[k] == pre[L]的结点
                break;

        int numLeft = k - inL;  //左子树的结点个数

        //左子树的先序区间为[preL+1,preL+numLeft]，中序区间为[inL,k-1]
        //返回左子树的根结点地址,赋值给root的左指针
        biTNode->lchild = create(preL + 1, preL + numLeft, inL, k - 1);

        //右子树的先序区间为[preL + numLeft + 1,preR]，中序区间为[k+1,inR]
        //返回右子树的根结点地址,赋值给root的右指针
        biTNode->rchild = create(preL + numLeft + 1, preR, k + 1, inR);

        return biTNode; //返回根结点地址
    }

    //先序遍历
    void PreOrder(BiTNode<T> *biTNode) {
        if (biTNode != NULL) {
            cout << biTNode->data << "\t";
            PreOrder(biTNode->lchild);
            PreOrder(biTNode->rchild);
        }
    }

    //中序遍历
    void InOrder(BiTNode<T> *biTNode) {
        if (biTNode != NULL) {
            InOrder(biTNode->lchild);
            cout << biTNode->data << "\t";
            InOrder(biTNode->rchild);
        }
    }

    //后序遍历
    void PostOrder(BiTNode<T> *biTNode) {
        if (biTNode != NULL) {
            PostOrder(biTNode->lchild);
            PostOrder(biTNode->rchild);
            cout << biTNode->data << "\t";
        }
    }

    //层序遍历
    void LayerOrder(BiTNode<T> *root) {
        queue<BiTNode<T> *> q;   //注意队列里面存的是地址
        q.push(root);            //根结点地址入队

        while (!q.empty()) {
            BiTNode<T> *now = q.front(); //取出队首元素
            q.pop();
            cout << now->data << "\t";   //访问队首元素
            if (now->lchild != NULL) q.push(now->lchild);   //左子树非空
            if (now->rchild != NULL) q.push(now->rchild);   //右子树非空
        }
    }


public:
    //初始化先序序列，中序序列，然后根据这两个序列构造二叉树
    BiTree(T *pre, T *in, int length) {

        this->length = length;
        this->pre = new T[length + 1];
        this->in = new T[length + 1];

        //初始化先序序列，中序序列
        for (int i = 1; i <= length; i++) {
            this->pre[i] = pre[i];
            this->in[i] = in[i];
        }

        //构造二叉树
        root = create(1, length, 1, length);
    }


    //先序遍历
    void PreOrder() {
        PreOrder(root);
    }

    //中序遍历
    void InOrder() {
        InOrder(root);
    }

    //后序遍历
    void PostOrder() {
        PostOrder(root);
    }

    //层序遍历
    void LayerOrder() {
        LayerOrder(root);
    }
};

int main() {
    char pre[] = {'#', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'};
    char in[] = {'#', 'B', 'C', 'A', 'E', 'D', 'G', 'H', 'F', 'I'};

    BiTree<char> biTree(pre, in, 9);

    cout << "PreOrder:\t";
    biTree.PreOrder();
    cout << endl;

    cout << "InOrder:\t";
    biTree.InOrder();
    cout << endl;

    cout << "PostOrder:\t";
    biTree.PostOrder();
    cout << endl;

    cout << "LayerOrder:\t";
    biTree.LayerOrder();
    cout << endl;
    return 0;
}

运行结果：

PreOrder:       A       B       C       D       E       F       G       H       I
InOrder:        B       C       A       E       D       G       H       F       I
PostOrder:      C       B       E       H       G       I       F       D       A
LayerOrder:     A       B       D       C       E       F       G       I       H

小结：中序序列可以与先序序列、后序序列、层序序列中的任意一个来构建唯一的二叉树，而后三者两两搭配或是三个一起上都无法构建唯一的二叉树。原因是先序、后序、层序均是提供根结点，作用是相同的，都必须由中序序列来区分出左右子树。

7.使用扩充二叉树的遍历序列构造二叉树

二叉树对应的扩充二叉树的先序或者后序序列能够唯一确定一棵二叉树

扩充二叉树的中序序列不能唯一确定一棵二叉树

什么是扩充二叉树？

扩充二叉树是指在二叉树中出现空子树的位置增加空树叶所形成的二叉树，如下图所示。

image-20220713105813494

因为扩充二叉树包含空的叶子结点，可以用来判断子树是否为空，因此可以通过扩充二叉树的先序或者后序序列唯一构建一棵二叉树。

上图所示的扩充二叉树先序序列为：AB#C##DE##FG#H##I##

构造过程：

1）根据给定的扩充二叉树写出先序序列

2）如果当前先序序列第一个结点为空树叶，说明子树为空，返回空，否则构造根结点

3）然后使用先序序列 [ p r e L + 1 , p r e R ] {\rm [preL+1,preR]} [preL+1,preR]，继续递归构造当前根结点的左子树，构造完成后，返回左孩子

4）然后使用先序序列 [ p r e L + n u m L e f t + 1 , p r e R ] {\rm [preL+numLeft+1,preR]} [preL+numLeft+1,preR]，继续递归构造当前根结点的右子树，构造完成后，返回右孩子

以上面写好的代码为基础，使用扩充二叉树遍历序列构造二叉树代码，测试代码如下：

template<typename T>
struct BiTNode {
    T data;                     //数据域
    BiTNode *lchild, *rchild;   //左、右孩子指针
};

template<typename T>
class BiTree {
private:
    BiTNode<T> *root;     //根结点
    T emptyLeaf;          //空树叶
    
    //扩充二叉树遍历序列构造二叉树
    BiTNode<T> *ExtendCreate() {
        BiTNode<T> *biTNode;
        T node;
        cin >> node;            //输入根结点的数据域
        if (node == emptyLeaf)  //当前结点为空树叶
            return NULL;
        else {
            //新建根结点
            biTNode = new BiTNode<T>;
            biTNode->data = node;

            //递归构造当前根结点的左右子树
            biTNode->lchild = ExtendCreate();
            biTNode->rchild = ExtendCreate();
        }
        return biTNode;
    }
    
public:
    //使用扩充二叉树构造二叉树
    BiTree(T emptyLeaf) {
        this->emptyLeaf = emptyLeaf;
        root = ExtendCreate();
    }
}

int main() {
    BiTree<char> biTree('#');

    cout << "PreOrder:\t";
    biTree.PreOrder();
    cout << endl;

    cout << "InOrder:\t";
    biTree.InOrder();
    cout << endl;

    cout << "PostOrder:\t";
    biTree.PostOrder();
    cout << endl;

    cout << "LayerOrder:\t";
    biTree.LayerOrder();
    cout << endl;
    return 0;
}

运行结果：

AB#C##DE##FG#H##I##
PreOrder:       A       B       C       D       E       F       G       H       I
InOrder:        B       C       A       E       D       G       H       F       I
PostOrder:      C       B       E       H       G       I       F       D       A
LayerOrder:     A       B       D       C       E       F       G       I       H
诗之本秋穂
关注
  • 9
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构——二叉树的先序遍历
huaimaisui的博客
07-20 5981
数据结构——二叉树的先序遍历
层序创建二叉树，层序遍历二叉树
cmd12138的博客
01-18 7943
在学习树的过程中发现，他们都有一个共同的特点，无论是在创建时还是遍历时，都是需要先父母再左孩子右孩子的顺序如图 层序遍历时顺序为A->B->C->D->E->F->G,先被访问的结点，他的孩子也是先被访问的，层序创建二叉树时，先创建的结点他的孩子也先创建，符合先进先出原则，因此可以用队列来实现。所以他们的共同点就是都可以用队列来帮助实现。 那就先从较为简单的遍历开始吧！ 1.层序遍历 思路：刚才分析时我们发现可用队列，第一步，若根节点不为空我们先让根节点入队，判断他的左
详解二叉树的遍历
supermouse的博客
02-16 1万+
概述 二叉树的遍历是一个很常见的问题。二叉树的遍历方式主要有：先序遍历、中序遍历、后序遍历、层次遍历。先序、中序、后序其实指的是父节点被访问的次序。若在遍历过程中，父节点先于它的子节点被访问，就是先序遍历；父节点被访问的次序位于左右孩子节点之间，就是中序遍历；访问完左右孩子节点之后再访问父节点，就是后序遍历。不论是先序遍历、中序遍历还是后序遍历，左右孩子节点的相对访问次序是不变的，总是先访问左孩子...
数据结构——二叉树先序、中序、后序三种遍历
legendarykk的博客
07-17 3万+
二叉树
二叉树（先序，后序，层次）建立及（先序，中序，后序，层次遍历）
最新发布
m0_60939919的博客
05-31 738
个人电子笔记，内容多有雷同---PS：中序创建二叉树是不存在的,因为中序无法确定一棵唯一的二叉树,即可能有两棵或多棵不同的二叉树,它们的中序是一样的。
前序、中序、后序排列
flyq_coffee
10-09 1万+
1、前序遍历 先输出父结点，再左结点，最后右结点（父左右） 2、中序遍历 先输出左结点，再父结点，最后右结点（左父右） 3、后序遍历 先左结点，再右结点，最后父结点（左右父） 4、实例 前序:ABDGHICEJF 中序:GDIHBAEJCF 后序:GIHDBJEFCA ...
【数据结构】理解二叉树的三种遍历--前序、中序、后序 +层序（简明易懂）
YuXi_0520的博客
03-02 8884
一、易懂的形象理解 其实从名字就可以很好的理解这三种遍历，我在第二点时候说，但是估计能翻到我的文的同学们之前肯定看过好多类似的了，那咱们换个思路~ 先用我想的一种简单易懂的形象思维理解一下前序、中序、后序 +层序！ 1、先序遍历 先序遍历可以想象成，小人从树根开始绕着整棵树的外围转一圈，经过结点的顺序就是先序遍历的顺序 先序遍历结果：ABDHIEJCFKG 让我们来看下动画，和小人儿一起跑两遍就...
c++先序二叉树的构建详解
08-26
"c++先序二叉树的构建详解" 在本篇文章中，我们将详细介绍c++先序二叉树的构建，包括二叉树的定义、构建、二叉树的遍历方法等相关知识点。 一、定义BinaryTreeNode类 在c++中，我们可以使用模板类来定义二叉树...
C语言 数据结构之中序二叉树实例详解
01-20
在二叉树中，有几种特定的遍历方式，包括前序遍历、中序遍历和后序遍历。本篇文章将重点讨论中序二叉树以及线索二叉树的概念。 中序遍历是一种访问二叉树所有节点的方法，其顺序通常是左子树、根节点、右子树。在...
实习二【唯一的确定一颗二叉树】[参考].pdf
10-29
后序遍历序列的最后一个元素是根节点，中序遍历序列中根节点的位置再次将序列分成两部分，但构建过程稍有不同。 6. **凹入法输出**： - 凹入法（或层次遍历）是另一种遍历二叉树的方法，按照从上到下、从左到右的...
杭电算法PPT详解以及各类算法精炼
07-19
4. **动态规划**：PPT可能详细解释了动态规划的思想和基本框架，包括记忆化搜索、最优化原理等，以及经典的动态规划问题，如斐波那契数列、背包问题、最长公共子序列等。 5. **贪心算法**：贪心算法通常用于求解...
线索二叉树(中序、先序和后序及遍历)
12-21
目录链式存储线索二叉树中序线索二叉树中序线索化实现实现的代码过程中序线索二叉树的遍历遍历代码中序线索二叉树可运行代码先序线索二叉树先序线索化实现先序线索二叉树的遍历遍历代码先序线索二叉树可运行代码后序线索二叉树后序线索化实现后序线索二叉树的遍历遍历代码后序线索二叉树可运行代码 链式存储 线索二叉树是二叉树的一类，在看线索二叉树之前我们先看一下二叉树的链式存储。 原创文章 8获赞 9访问量 732 关注
BST:C++ 中的 BST
07-08
在有序BST中，中序遍历可以得到排序后的键值序列。 3. 后序遍历（左-右-根）：首先遍历左子树，然后遍历右子树，最后访问根节点。 **删除操作** 删除BST中的节点相对复杂，可能涉及以下几种情况： 1. 节点没有子...
二叉树的前序，中序，后序遍历（递归和非递归写法）
weixin_46060794的博客
07-09 1173
一、前序遍历 前序遍历是二叉树遍历的一种，也叫做先根遍历、先序遍历、前序周游，可记做根左右 前序遍历首先访问根结点然后遍历左子树，最后遍历右子树。在遍历左、右子树时，仍然先访问根节点，然后遍历左子树，最后遍历右子树。 若二叉树为空则结束返回，否则： （1）访问根结点。 （2）前序遍历左子树。 （3）前序遍历右子树 。 如图所示，前序遍历的结果为：ABDECFG 递归实现： ...
树的遍历（先序、中序、后序详解）
热门推荐
qq_44721518的博客
06-28 3万+
树的遍历主要有三种 1、先序遍历：先遍历根节点，再遍历左节点，最后遍历右节点； 2、中序遍历：先遍历左节点，再遍历根节点，最后遍历右节点； 3、后序遍历：先遍历左节点，再遍历右节点，最后遍历根节点； 总结：先、中、后就表示根节点的遍历处于哪个位置，而总是先左节点后右节点。例如先序遍历，“先”表示根节点最先遍历，再左节点，最后右节点。依此类推中序遍历，后序遍历。 接下来看一个题目，看一下你们是怎么做的。 我们以中序遍历为例来讲（每次以三个节点为一个整体）： 首先从树的根节点开始即C F E 我们再依次来看，
二叉树的遍历(非递归)
zjzj95的博客
09-27 342
title: Binary Tree Traversal date: 2020-09-27 categories: 数据结构与算法 tags: 二叉树 二叉树的遍历 1. 递归方法 递归方法比较简单，不过多赘述，直接看代码： public class BinaryTreeTraversal { //先序遍历 public void preOrder(TreeNode root){ if(root==null)return; System.out.print.
二叉树序列
weixin_47440242的博客
07-25 245
若已知一颗二叉树先序序列为ABCDEFG，中序序列为CBDAEGF画出该二叉 树，并写出后序遍历顺序
二叉树的分类及遍历（前序、中序、后序、层序）
prinntgo的博客
03-14 208
int val;} }
C语言--数据结构--实现先序遍历、中序遍历、后序遍历、二叉树的高度、二叉树结点总数；
weixin_69491512的博客
12-13 2231
C语言--数据结构--实现先序遍历、中序遍历、后序遍历、二叉树的高度、二叉树结点总数；
根据二叉树先序序列和中序序列确定层序序列
05-13
要确定二叉树的层序遍历，需要同时知道其先序遍历和中序遍历。 以下是确定二叉树层序遍历的步骤： 1. 根据先序遍历找到根节点。 2. 根据中序遍历将树分为左子树和右子树。 3. 递归地对左子树和右子树执行步骤 1 和 2，直到遍历完所有节点。 4. 最后按层序遍历的顺序输出每个节点的值。 具体实现可以使用队列来存储每一层的节点，从根节点开始，将其加入队列中，然后遍历队列中的每个节点，将它们的左右子节点加入队列中，直到队列为空为止。这样就可以按层序遍历输出每个节点的值了。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值