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

已于 2022-08-04 21:54:43 修改
阅读量7.4k 收藏 48
点赞数 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
    点赞
  • 踩
  • 48
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c++先序二叉树的构建详解
08-26
"c++先序二叉树的构建详解" 在本篇文章中，我们将详细介绍c++先序二叉树的构建，包括二叉树的定义、构建、二叉树的遍历方法等相关知识点。 一、定义BinaryTreeNode类 在c++中，我们可以使用模板类来定义二叉树...
C语言 数据结构之中序二叉树实例详解
01-20
在二叉树中，有几种特定的遍历方式，包括前序遍历、中序遍历和后序遍历。本篇文章将重点讨论中序二叉树以及线索二叉树的概念。 中序遍历是一种访问二叉树所有节点的方法，其顺序通常是左子树、根节点、右子树。在...
详解二叉树的遍历
supermouse的博客
02-16 1万+
概述 二叉树的遍历是一个很常见的问题。二叉树的遍历方式主要有：先序遍历、中序遍历、后序遍历、层次遍历。先序、中序、后序其实指的是父节点被访问的次序。若在遍历过程中，父节点先于它的子节点被访问，就是先序遍历；父节点被访问的次序位于左右孩子节点之间，就是中序遍历；访问完左右孩子节点之后再访问父节点，就是后序遍历。不论是先序遍历、中序遍历还是后序遍历，左右孩子节点的相对访问次序是不变的，总是先访问左孩子...
数据结构——二叉树的先序、中序、后序和层次遍历
小匠码农
06-28 969
二叉树
二叉树非递归先序、中序、后序遍历过程详解及C++详细实现
weixin_45651616的博客
07-14 2723
数据结构，二叉树非递归先序、中序、后序遍历过程详解及C++详细实现
二叉树先序、中序、后序遍历 递归+迭代详解
哇咔咔的博客
11-19 2250
二叉树遍历定义前序遍历递归实现迭代实现思路代码中序遍历递归实现迭代实现思路后序遍历递归实现迭代实现 定义 二叉树的遍历（ traversing binary tree）是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。 这里有两个关键词：访问和次序。 二叉树的遍历次序不同于线性结构，最多也就是从头至尾、循环、双向等简单的遍历方式。树的结点之间不存在唯一的前驱和后继关系，在访问一个结点后，下一个被访问的结点面临着不同的选择。 因此也就产生了不同的遍历方式，主要分为4
二叉树的先序遍历、中序遍历、后序遍历、层次遍历-图文详解
热门推荐
古月哲亭
04-07 4万+
二叉树的遍历详解AProgrammer微信公众号：AProgrammer​关注他概述二叉树的遍历是一个很常见的问题。二叉树的遍历方式主要有：先序遍历、中序遍历、后序遍历、层次遍历。先序、中序、后序其实指的是父节点被访问的次序。若在遍历过程中，父节点先于它的子节点被访问，就是先序遍历；父节点被访问的次序位于左右孩子节点之间，就是中序遍历；访问完左右孩子节点之后再访问父节点，就是后序遍历。不论是先序遍...
【C++】二叉树的先序、中序、后序遍历序列
qq_45829112的博客
03-18 8347
二叉树常用到的遍历有这三种 先序遍历：先遍历根节点，然后再分别遍历左节点和右节点。(根左右) 中序遍历：先遍历左节点，然后再遍历根节点，最后遍历右节点。(左根右) 后序遍历：先遍历左节点，然后再遍历右节点，最后遍历根节点。（左右根） 如下图所示： 按照中序遍历的打印顺序为：D　B　E　A　F　C　G 按照先序遍历的打印顺序为：A　B　D　E　C　F　G 按照后序遍历的打印顺序为：D　E　B 　F 　G 　C 　A 我们先来看一下关于二叉树的创建: 先来看关于二叉树中指针的指向的创建
二叉树的前序遍历，中序遍历，后序遍历-详解-配套例题
爱吃橘子的小翟
04-03 1万+
二叉树作为数据结构中一种简单而且重要的数据结构，他的存储结构和算法都相对比较简单，因此他也显得特别重要，因为很多问题都可以抽象为二叉树的问题。 在这里我们对于二叉树的基本概念不做详细介绍，我们这里主要介绍二叉树的前序遍历，中序遍历，和后序遍历三种问题和如何通过他的前序遍历，中序遍历，后序遍历构造相应的二叉搜索树的问题。 在这之前，我们先简单了解一下二叉树的三种遍历到底是什么样子的。 我的记忆方式为： 前序遍历-DLR（根...
二叉树的四种遍历详解（先序，中序，后序，层次）
2301_80035594的博客
01-16 5341
详细讲解了二叉树的四种遍历，用画图的方式帮助大家理解（包括二叉树的图），并给出例题供读者学习，文中的所有代码均经过调试。
C语言实现非递归先序、中序、后序遍历
呵呵哒!的博客
11-22 5391
C语言实现非递归先序、中序、后序遍历
二叉树的前序中序后序三种遍历方式及递归算法介绍
qq_45768060的博客
04-27 2787
二叉树的遍历是整个二叉树的核心，二叉树的几本操作都要依赖于遍历，对于二叉树的遍历，递归是最简单也最容易理解的，本文详细介绍了二叉树的三种遍历方法，并用递归来实现：
数据结构二叉树的建立与遍历.doc
09-25
2. **深入理解二叉树**：掌握二叉树的链式存储结构以及非递归遍历的实现方式。 3. **提升解决问题能力**：通过实际编程实践，提高分析问题和解决问题的能力，加深对教科书理论知识的理解。 #### 实验内容概述 1. *...
链式表的前 中 后序遍历
11-30
链式表的前中后序遍历：C++实现详解 在计算机科学中，链式表（或称为链表）是一种常见的数据结构，用于存储线性序列的数据元素，每个元素包含一个指向序列中下一个元素的链接。然而，在题目中提到的“链式表的前中...
实习二【唯一的确定一颗二叉树】[参考].pdf
10-29
后序遍历序列的最后一个元素是根节点，中序遍历序列中根节点的位置再次将序列分成两部分，但构建过程稍有不同。 6. **凹入法输出**： - 凹入法（或层次遍历）是另一种遍历二叉树的方法，按照从上到下、从左到右的...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1327
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
A 语言B语言
最新发布
WSH2012ffff的博客
07-26 343
A语言和B语言是指与C语言类似的编程语言，它们分别用于特定领域或特定用途的编程任务。A语言和B语言的名称可能因不同的上下文而有所不同，可能代表不同的编程语言。关于A语言和B语言的具体细节会根据上下文而有所不同。
用cmake创建一个c++工程，调用c语言函数打印“c hello!”。
LW_12345的博客
07-26 251
添加语言类型：在project命令中指定项目支持C和C++语言。设置标准：在CMakeLists.txt中明确设置C和C++的标准。添加库：使用创建C语言库，并用将其链接到C++可执行文件。这样，CMake就能正确识别C语言源文件，并将其链接到C++项目中。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值