2020-9-27 严蔚敏《数据结构》 二叉链表： 递归、非递归（非递归用栈）先序、中序、后序遍历（非递归后序遍历麻烦点，需要用到flag标志）以及层序遍历（层序用队列），以及建立在遍历上的一些操作

最新推荐文章于 2022-12-25 10:27:40 发布
最新推荐文章于 2022-12-25 10:27:40 发布
阅读量435 收藏 4
点赞数
文章标签： 数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45888287/article/details/108830973
版权 
//严蔚敏《数据结构》
//二叉链表： 递归、非递归（非递归用栈）先序、中序、后序遍历（非递归后序遍历麻烦点，需要用到flag标志）
//以及层序遍历（层序用队列），以及建立在遍历上的一些操作

//思考：对二叉链表的操作几乎都是建立在遍历的基础上（所以说遍历很重要！！）
//若为简单的输出遍历，递归容易实现，但效率较低；
//若不是简单的输出，是建立在遍历基础上的一些操作，比如 寻找双亲，非递归容易实现
//5-7行是基于现在水平的我的理解，可能不太对，我会回来的

//自学中，加油！！！
#include<iostream>
using namespace std;
#define TElemType double

typedef struct BiTNode
{
    TElemType data;
    struct BiTNode* lchild,* rchild;
    int flag;//标志变量 标志非递归的后序遍历
}BiTNode,* BiTree;

bool Creat_BiTree(BiTree& T)//递归先序创建并输入
{
    TElemType num;
    if(cin>>num){//此处应用if而不是while循环  这是在用递归，就不用while循环了
        T=new BiTNode;
        if(!T)
            return false;
        T->data=num;
        Creat_BiTree(T->lchild);
        Creat_BiTree(T->rchild);
    }
    if(!cin)
        T=nullptr;
    if(!cin){
        cin.clear();
        while(cin.get()!='\n')
            continue;
    }
    return true;
}

void PreOrder_Bitree(BiTree T)//递归先序遍历
{
    if(T){
        cout<<T->data<<endl;
        PreOrder_Bitree(T->lchild);
        PreOrder_Bitree(T->rchild);
    }
}

void InOrder_bitree(BiTree T)//递归中序遍历
{
    if(T){
        InOrder_bitree(T->lchild);
        cout<<T->data<<endl;
        InOrder_bitree(T->rchild);
    }
}

void PostOrder_BiTree(BiTree T)//递归后序遍历
{
    if(T){
        PostOrder_BiTree(T->lchild);
        PostOrder_BiTree(T->rchild);
        cout<<T->data<<endl;
    }
}
//构造的队列为层序遍历服务
#define QElemType BiTree
typedef struct QNode
{
    QElemType data;
    struct QNode* next;
}QNode,* QPtr;

typedef struct
{
    QPtr head,tail;
    int length;
}QueueList;

bool Init_Queue(QueueList& Q)
{
    Q.head=new QNode;
    if(!Q.head)
        return false;
    Q.head->next=nullptr;
    Q.tail=Q.head;
    Q.length=0;
    return true;
}

bool IsEmpty_Queue(QueueList Q)
{
    if(Q.length)
        return false;
    return true;
}

bool Push_Queue(QueueList& Q,QElemType e)
{
    QPtr p=new QNode;
    if(!p)
        return false;
    p->data=e;
    p->next=Q.tail->next;
    Q.tail->next=p;
    Q.tail=p;
    Q.length++;
    return true;
}

bool Pop_Queue(QueueList& Q,QElemType& e)
{
    if(IsEmpty_Queue(Q))
        return false;
    QPtr p=Q.head->next;
    e=p->data;
    Q.head->next=p->next;
    if(p==Q.tail)//若头指针后面就是尾指针，需改动Q.tail的值
        Q.tail=Q.head;
    delete p;
    Q.length--;//bug2:忘记该行代码
    return true;
}

void LevelOrder_BiTree(BiTree T)//利用队列层序遍历
{
    QueueList Q;
    Init_Queue(Q);
    Push_Queue(Q,T);
    while(!IsEmpty_Queue(Q)){
        BiTree bt;
        Pop_Queue(Q,bt);
        cout<<bt->data<<endl;
        if(bt->lchild)
            Push_Queue(Q,bt->lchild);
        if(bt->rchild)
            Push_Queue(Q,bt->rchild);
    }
}
//构造的栈为非递归 先序、中序、后序遍历服务
#define SElemType BiTree
typedef struct SNode
{
    SElemType data;
    struct SNode* next,* prior;
}SNode,* SLink;

typedef struct
{
    SLink head,tail;
    int length;
}LinkStack;

bool Init_Stack(LinkStack& S)
{
    S.head=new SNode;
    if(!S.head)
        return false;
    S.head->next=S.head->prior=nullptr;
    S.tail=S.head;
    S.length=0;
    return true;
}

bool IsEmpty_Stack(LinkStack S)
{
    if(!S.length)
        return true;
    return false;
}
SElemType GetTop_Stack(LinkStack S)
{
    return S.tail->data;
}

bool Push_Stack(LinkStack& S,SElemType e)
{
    SLink p=new SNode;
    if(!p)
        return false;
    p->data=e;
    p->next=S.tail->next;
    S.tail->next=p;
    p->prior=S.tail;
    S.tail=p;
    S.length++;
    return true;
}

bool Pop_Stack(LinkStack& S,SElemType& e)
{
    SLink p=S.tail;
    e=S.tail->data;
    S.tail=S.tail->prior;
    S.tail->next=p->next;
    delete p;
    S.length--;
    return true;
}

void PreOrder_Bitree1(BiTree bt)//非递归先序遍历 使用栈
{
    BiTree T=bt;
    LinkStack S;
    Init_Stack(S);
    while(T||!IsEmpty_Stack(S)){
        while(T){
            cout<<T->data<<endl;
            Push_Stack(S,T);
            T=T->lchild;
        }
        if(!IsEmpty_Stack(S)){
            Pop_Stack(S,T);
            T=T->rchild;
        }
    }
}

void InOrder_bitree1(BiTree bt)//非递归中序遍历 使用栈
{
    BiTree T=bt;
    LinkStack S;
    Init_Stack(S);
    while(T||!IsEmpty_Stack(S)){
        while(T){//T一直向左遍历，并将沿途结点压入栈
            Push_Stack(S,T);
            T=T->lchild;
        }
        if(!IsEmpty_Stack(S)){//从栈中得到双亲
            Pop_Stack(S,T);
            cout<<T->data<<endl;//打印结点数据
            T=T->rchild;
        }
    }
}

void PostOrder_BiTree1(BiTree bt)//非递归后序遍历 使用栈
{
    BiTree T=bt;
    LinkStack S;
    Init_Stack(S);
    while(T||!IsEmpty_Stack(S)){
        while(T){//T一直向左遍历，并将沿途结点压入栈
            T->flag=0;//在入栈之前将T->flag置为0，不然在main调用两次PostOrder_BiTree1,第二个会发生错误
            Push_Stack(S,T);
            T=T->lchild;
        }
        while(!IsEmpty_Stack(S)&&GetTop_Stack(S)->flag==1){
            Pop_Stack(S,T);
            cout<<T->data<<endl;//打印结点数据
        }
        if(!IsEmpty_Stack(S)){//若flag不为1，则不输出，然后继续向右子树遍历
            T=GetTop_Stack(S);
            T->flag=1;
            T=T->rchild;
        }
        else//左->右->根  当栈空时，遍历已经全部完成
            break;
    }
}
//以下的操作大多建立在遍历的基础之上 根据不同的要求进行不同的遍历
BiTree Clear_BiTree(BiTree& T)//清空二叉链表(选择递归后序遍历，好处：左右子树操作完后，才进行根的删除)
{
    BiTree bt=T;
    if(bt){
        bt->lchild=Clear_BiTree(bt->lchild);
        bt->rchild=Clear_BiTree(bt->rchild);
        delete bt;
        return nullptr;
    }
}

bool IsEmpty_BiTree(BiTree T)//二叉链表为空，返回true；否则返回false
{
    if(!T)
        return true;
    return false;
}

int Depth_BiTree(BiTree T)//返回二叉树的深度(采用递归后序遍历，先找Max(H左，H右),然后将其+1
{
    if(T){
        int Depth1=Depth_BiTree(T->lchild);
        int Depth2=Depth_BiTree(T->rchild);
        return (Depth1>Depth2?Depth1:Depth2)+1;
    }
    return 0;
}

BiTree Root(BiTree T)//返回指向根的指针
{
    return T;
}
/*
bool Value_BiTree(BiTree T,BiTree p)//输出p指向树结点的数据(这个三个次序都可以,在此我选择先序了)
{
    BiTree bt=T;
    if(bt){
        if(p==bt){
            cout<<bt->data;
        }
        Value_BiTree(bt->lchild,p);
        Value_BiTree(bt->rchild,p);
    }
    return true;
}
*/
//291-304行代码  输出选择递归，若函数类型为返回，递归不太好完成，在此选择非递归先序
TElemType Value_BiTree(BiTree T,BiTree p)
{
    BiTree bt=T;
    LinkStack S;
    Init_Stack(S);
    while(bt||!IsEmpty_Stack(S)){//bug1: 将||写为&&
        while(bt){
            if(bt==p)
               return bt->data;
            Push_Stack(S,bt);
            bt=bt->lchild;
        }
        if(!IsEmpty_Stack(S)){
            Pop_Stack(S,bt);//此处应为Pop_Stack(S,bt) 而不是Pop_Stack(S,e)
            bt=bt->rchild;
        }
    }
}

bool Assign_BiTree(BiTree& T,BiTree p,TElemType e)//将数据e赋给p指向树节点的数据域(递归先序遍历)
{
    //BiTree bt=T;//递归不要这一行，非递归需要
    if(T){
        if(T==p){
            T->data=e;
        }
        Assign_BiTree(T->lchild,p,e);
        Assign_BiTree(T->rchild,p,e);
    }
    return true;
}

bool Assign_BiTree1(BiTree& T,BiTree p,TElemType e)//非递归先序遍历
{
    BiTree bt=T;
    LinkStack S;
    Init_Stack(S);
    while(bt||!IsEmpty_Stack(S)){
        while(bt){
            if(p==bt){
                bt->data=e;
            }
            Push_Stack(S,bt);
            bt=bt->lchild;
        }
        if(!IsEmpty_Stack(S)){
            Pop_Stack(S,bt);
            bt=bt->rchild;
        }
    }
    return true;
}

//输出 选择递归较容易，非输出 递归、非递归均可，看情况使用。若函数类型为返回，递归不太好完成，在此选择非递归先序
void Parent_BiTree(BiTree T,BiTree p)//输出树指针p的双亲(选择递归先序遍历)   递归输出
{
    if(T){
        if(T->lchild==p||T->rchild==p)
            cout<<T->data<<endl;
        Parent_BiTree(T->lchild,p);
        Parent_BiTree(T->rchild,p);
    }
}

BiTree Parent_BiTree1(BiTree T,BiTree p)//非递归返回  先序遍历
{
    BiTree bt=T;
    LinkStack S;
    Init_Stack(S);
    if(T==p)//p为总根，无双亲
        return nullptr;
    while(bt||!IsEmpty_Stack(S)){
        while(bt){
            if(bt->lchild==p||bt->rchild==p)
               return bt;
            Push_Stack(S,bt);
            bt=bt->lchild;
        }
        if(!IsEmpty_Stack(S)){
            Pop_Stack(S,bt);
            bt=bt->rchild;
        }
    }
    return nullptr;
}
//二叉链表找双亲、兄弟需要从头开始遍历 找孩子不需要遍历
BiTree LeftChild_BiTree(BiTree T,BiTree p)//返回树指针p的左孩子，若无，返回nullptr
{
    return p->lchild;
}

BiTree RightChild_BiTree(BiTree T,BiTree p)//返回树指针p的右孩子，若无，返回nullptr
{
    return p->rchild;
}

BiTree LeftSibling(BiTree T,BiTree p)//返回树指针p的左兄弟指针，若无，返回nullptr
{
    return Parent_BiTree1(T,p)->lchild;
}

BiTree RightSibling(BiTree T,BiTree p)//返回树指针p的右兄弟指针，若无，返回nullptr
{
    return Parent_BiTree1(T,p)->rchild;
}

bool InsertChild_BiTree(BiTree& T,BiTree p,int LR,BiTree e)//LR=0:插入数据e到p指针的左孩子结点
                                                           //LR=1:插入数据e到p指针的右孩子结点
{
    if(LR==0){
        if(!p->lchild){
            p->lchild=e;
            return true;
        }
        return false;
    }
    else{
        if(!p->rchild){
            p->rchild=e;
            return true;
        }
        return false;
    }
}

bool DeleteChild_BiTree(BiTree& T,BiTree p,int LR,BiTree e)//LR=0:删除p指针的子树(采用非递归后序遍历 ，最后删除根)
                                                           //LR=1:删除p指针的子树
{
    BiTree bp=p;
    if(LR==0){
        bp=p->lchild;
        p->lchild=nullptr;
    }
    else{
        bp=p->rchild;
        p->rchild=nullptr;
    }
    LinkStack S;
    Init_Stack(S);
    while(bp&&!IsEmpty_Stack(S)){
        while(bp){
            bp->flag=0;//入栈前设置bp->flag=0
            Push_Stack(S,bp);
            bp=bp->lchild;
        }
        while(!IsEmpty_Stack(S)&&GetTop_Stack(S)->flag==1){
            Pop_Stack(S,bp);
            delete bp;
        }
        if(!IsEmpty_Stack(S)){
            bp=GetTop_Stack(S);
            bp->flag=1;
            bp=bp->rchild;
        }
        else
            break;
    }
    return true;
}
//while循环可以替代递归

int main()
{
    BiTree T;
    Creat_BiTree(T);
    cout<<"非递归后序遍历\n";
    PostOrder_BiTree1(T);//非递归 记得将flag 重置为0

    /*T=Clear_BiTree(T);
    cout<<"非递归后序遍历\n";//Clear_BiTree的测试代码
    PostOrder_BiTree1(T);*/

    /*cout<<"深度:"<<Depth_BiTree(T)<<endl;
    cout<<"非递归后序遍历\n";
    PostOrder_BiTree1(T);
    cout<<"值:"<<Value_BiTree(T,T->lchild->rchild->lchild)<<endl;
    Assign_BiTree1(T,T->lchild->rchild,9.9);
    cout<<"非递归后序遍历\n";
    PostOrder_BiTree1(T);
    Assign_BiTree(T,T->lchild->rchild,11.1);
    cout<<"非递归后序遍历\n";
    PostOrder_BiTree1(T);*///Clear_BiTree Depth_BiTree  Assign_BiTree操作的测试代码

    /*cout<<"====="<<endl;
    Parent_BiTree(T,T->lchild->rchild);
    cout<<"====="<<endl;
    cout<<Parent_BiTree1(T,T->lchild->rchild->lchild)->data<<endl;
    cout<<"====="<<endl;
    cout<<LeftChild_BiTree(T,T->lchild->rchild)->data<<endl;
    cout<<"====="<<endl;
    cout<<RightChild_BiTree(T,T->lchild->rchild)<<endl;
    cout<<"===="<<endl;
    cout<<LeftSibling(T,T->lchild->rchild)->data<<endl;
    cout<<"===="<<endl;
    cout<<RightSibling(T,T->lchild)->data;*///Parent、LeftChild、RightChild、LeftSibling、RightSibling
                                            //操作的测试代码
    //下面为测试 InsertChild、deleteChild操作的代码
    BiTree T2;
    Creat_BiTree(T2);
    cout<<"非递归后序遍历\n";
    PostOrder_BiTree1(T2);
    InsertChild_BiTree(T,T->lchild->lchild,0,T2);
    cout<<"非递归后序遍历\n";
    PostOrder_BiTree1(T);
    DeleteChild_BiTree(T,T->lchild->lchild,0,T2);
    cout<<"非递归后序遍历\n";
    PostOrder_BiTree1(T);
    return 0;
}

main函数的测试图如下所示
在这里插入图片描述

1.1
2.2
4.4
@
6.6
@
@
5.5
7.7
@
@
@
3.3
@
@
非递归后序遍历
6.6
4.4
7.7
5.5
2.2
3.3
1.1
8.8
9.9
@
11.1
@
@
12.2
@
13.3
@
@
非递归后序遍历
11.1
9.9
13.3
12.2
8.8
非递归后序遍历
11.1
9.9
13.3
12.2
8.8
6.6
4.4
7.7
5.5
2.2
3.3
1.1
非递归后序遍历
6.6
4.4
7.7
5.5
2.2
3.3
1.1

Process returned 0 (0x0)   execution time : 16.433 s
Press any key to continue.
prvyx
关注
ccnu-data-structures：《数据结构及应用算法教程》（严蔚敏陈文博编着）彭老师课堂作业
02-05
《数据结构及应用算法教程》是由严蔚敏和陈文博两位知名计算机科学家编著的一本经典教材，这本书深入浅出地介绍了数据结构这一核心的计算机科学概念。在这个名为"ccnu-data-structures"的项目中，我们可以看到彭老师...
数据结构C语言版清华大学严蔚敏（学习笔记总结4，代码在下面）——树、空树的建立、创建树、销毁树、统计叶子结点、树的遍历、前序中序后序层次遍历、完全二叉、哈夫曼树（前面是笔记方便理解，最下面有详细代码）
weixin_51538341的博客
01-01 565
1、创建树 #define _CRT_SECURE_NO_WARNINGS 1 #include "Tree.h" BTNode *BinaryTreeCreate(BTDataType*a, int* pi) //创建树 { if (a[*pi] == '#') { (*pi)++; return NULL; } BTNode* root = (BTNode*)malloc(sizeof(BTNode)); root->_left = root-&g..
数据结构(C语言版)严蔚敏-＞二叉树（链式存储结构）的构造及其几种遍历方式(先序、中序、后序、层次)和线索二叉树
坚持不懈的大白的博客
07-28 1868
本文主要讲述二叉树的构造及其遍历和线索二叉树的相关内容。
C语言 严蔚敏 数据结构 二叉树的遍历（前中后序遍历_二叉链表与三叉链表）
最新发布
qq_63052532的博客
12-25 660
二叉链表前中后序遍历利用栈来实现，用一个栈来存储二叉链表中结点。 三叉链表后序遍历利用队列+标记实现。
3-6-汉诺塔(Hanoi Tower)问题-栈和队列-第3章-《数据结构》课本源码-严蔚敏吴伟民版...
weixin_33979745的博客
02-28 177
课本源码部分 第3章  栈和队列 - 汉诺塔（Hanoi Tower）问题 ——《数据结构》-严蔚敏.吴伟民版        源码使用说明  链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明        课本源码合辑  链接☛☛☛ 《数据结构》课本源码合辑        习题集全解析  链接☛☛☛ 《数据结构题集》习题解析合辑          本...
2021-10-15【数据结构/严蔚敏】【二叉树的前/中/后/递归/非递归遍历&层序遍历】【代码实现算法6.1-6.4】
eternity_memory的博客
10-16 2427
二叉树的基本结构 2021-10-15【数据结构/严蔚敏】【二叉树基本实现】 因为非递归版需要用到 栈stack 的操作 #define SElemType BiTree // -----栈的链式存储结构---------------------------------- typedef struct SNode { SElemType data; // 数据域 struct SNode *next; // 指针域 } SNode, *
数据结构答案-严蔚敏李冬梅.pdf.zip
05-24
7. **递归与分治策略**：很多数据结构问题可以使用递归方法解决，如斐波那契序列、汉诺塔问题等；分治策略是处理大规模问题的有效方法，如归并排序、快速排序等。 8. **动态规划**：通过解决子问题来解决原问题，如...
考研资料--[数据结构(C语言版)].严蔚敏_吴伟民.扫描版.zip
07-09
数据结构是研究数据如何在计算机中组织和存储的一门学科，它包括线性结构（如数组、链表）、树形结构（如二叉树、堆）、图结构、集合以及特殊结构（如栈、队列、哈希表）等。这些结构的选择和设计直接影响到程序的...
《数据结构：C语言版》（严蔚敏）_datastructure_严蔚敏PDF_yanweimin_
10-02
《数据结构：C语言版》是由著名计算机教育家严蔚敏教授编写的一本经典教材，这本书深入浅出地讲解了数据结构这一计算机科学的核心概念。数据结构是计算机科学中的基石，它研究如何组织和存储数据，以便高效地访问和...
C：二叉树先序中序后序(递归，非递归)层序遍历算法严蔚敏版[新手向]⑦
qq_44886566的博客
01-26 1488
C：二叉树先序中序后序(递归，非递归)严蔚敏版[新手向]⑦ 近段时间本人在复习数据结构，重新敲一次代码，有什么不足的地方望大佬多多指教，严蔚敏版教程配套算法代码 #include<stdio.h> #include<stdlib.h> #define MAX_TREE_SIZE 100//二叉树的最大结点 #define STACK_INIT_SIZE 100//栈的初...
数据结构c语言版建立二叉树，中序非递归遍历（实验报告）
07-22
编写程序，用先序递归的方法建立二叉树，建立二叉树后，用中序非递归方法遍历该二叉树，并输出遍历序列。
链式二叉树的前序创建、递归遍历、利用堆栈的非递归遍历、前序销毁以及求二叉树的深度
06-12
链式二叉树的前序创建、递归遍历、利用堆栈的非递归遍历、前序销毁以及求二叉树的深度
2020-9-27 //严蔚敏《数据结构》 //二叉链表： 递归、非递归（非递归用栈）先序、中序、后序遍历（非递归后序遍历麻烦点，需要用到flag标志）
weixin_45888287的博客
09-27 366
//严蔚敏《数据结构》 //二叉链表： 递归、非递归（非递归用栈）先序、中序、后序遍历（非递归后序遍历麻烦点，需要用到flag标志） //以及层序遍历（层序用队列） //自学中，加油！！！ //过程很痛，但结果很美 #include<iostream> using namespace std; #define TElemType double typedef struct BiTNode { TElemType data; struct BiTNode* lchild,* rc
严蔚敏-数据结构-树的遍历
Belle_Chou的博客
10-20 1409
前序非递归遍历 PreOrderTraverse(BiTree T) { InitStack(S); p=T; while (p||!StackEmpty) { if(p) { print(p); if(p-&amp;gt;rchild) { Push(S,p-&amp;gt;rchild); } p=p-&amp;gt;lchild; } else ...
C语言两种非递归方式实现中序遍历链表二叉树
weixin_44352058的博客
04-21 3149
C语言两种非递归方式实现中序遍历链表二叉树 二叉树采用二叉链表存储结构，按照先序遍历的方式创建下面这棵二叉树。然后分别用中序遍历的两种非递归算法遍历这棵二叉树。最后释放二叉树的每个结点的存储空间。提示：释放二叉树结点时要先释放左子树，然后释放右子树，最后释放根结点。这与后序遍历的顺序一致，所以应付当在后序遍历的过程中释放结点，可以使用后序遍历的递归算法。 若二叉树如图所示，则 示例1： 输入:...
2020-11-16 //先序、中序、后序（递归、非递归(栈实现)） 后序非递归用到标志变量flag 以及层序遍历（队列实现）
weixin_45888287的博客
11-16 159
//先序、中序、后序（递归、非递归(栈实现)） 后序非递归用到标志变量flag 以及层序遍历（队列实现） #include<iostream> #include<queue> #include<stack> using namespace std; #define TElemType double typedef struct BiTNode { TElemType data; bool flag;//flag用于非递归后序遍历 struct Bi
二叉树遍历输出
SChenlyx
05-08 728
按先序遍历序列建立一个二叉树的二叉链表，并按先序遍历、中序遍历、后序遍历将其输出。 测试用例1 -+a##*b##c##/d##e##↵ 期待输出1 前序遍历结果：- + a * b c / d e ↵ 中序遍历结果：a + b * c - d / e ↵ 后序遍历结果：a b c * + d e / - ↵ #include <iostream> #include <lis...
二叉树前序中序后序遍历(递归和非递归)以及层序遍历代码
weixin_42201083的博客
05-19 386
树的定义以及采用先序遍历输入节点数据 //树的结构体定义 typedef struct BiTree { char data; struct BiTree *lchild,*rchild; }BiNode, *BTree; //递归创建二叉链表 void CreatBiTree(BTree &T) { char ch; cin >> ch;...
二叉树的非递归遍历（先序、中序、后序和层序遍历）
weixin_30564901的博客
11-17 179
[前文] 二叉树的非递归遍历有先序遍历、中序遍历、后续遍历和层序遍历。 非递归算法实现的基本思路：使用堆栈。而层序遍历的实现：使用队列。 如下图所示的二叉树： 　　　　 前序遍历顺序为：ABCDE　　（先访问根节点，然后先序遍历其左子树，最后先序遍历其右子树） 中序遍历顺序为：CBDAE　　（先中序遍历其左子树，然后访问很节点，最后中序遍历其右子树） 后续遍历顺序为：CDBE...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值