C++二叉树的创建、递归及非递归遍历（前、中、后、层序）

最新推荐文章于 2024-07-25 15:31:50 发布
最新推荐文章于 2024-07-25 15:31:50 发布
阅读量1.1k 收藏 11
点赞数 2
文章标签： 二叉树 数据结构 队列 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MilkLeong/article/details/104270917
版权

二叉树是《数据结构》中的一种较重要的数据类型，关于它的基本操作有：二叉树的创建、二叉树的遍历、求二叉树的高度等。
本文是对近期学习二叉树的一点总结，涉及的主要操作如下：

  • 二叉树的创建：基于递归的先序创建、层序创建
  • 二叉树的递归遍历：先序遍历、中序遍历、后序遍历
  • 二叉树的非递归遍历：先序遍历、中序遍历、后续遍历、层序遍历
  • 输出二叉树的叶子结点
  • 求二叉树的高度

二叉树有数组实现和链表实现两种形式，但数组实现不如链表灵活，本文涉及的二叉树的各种操作都是基于链表。

定义二叉树结点类型：

typedef struct BinNode
{
    ElementType data;
    BinNode *Left;
    BinNode *Right;
}BinTree;

一、二叉树的创建

二叉树是非线性的结构，创建一棵二叉树必须首先确定树中结点的输入顺序，常有的方法是先序创建和层序创建。
（一）先序创建
先序创建一棵二叉树，其操作步骤主要是基于二叉树的先序遍历。对于整棵树中的任意一棵子树，先输入其父结点，再输入其左孩子结点、右孩子结点。
像如下一棵二叉树，若以输入‘0’表示结点为空，按先序创建输入的结点顺序为：A B C 0 0 D E 0 G F 0 0 0
在这里插入图片描述
按先序遍历创建二叉树的代码如下：

/*按先序遍历创建二叉树*/
BinTree *CreatePre(BinTree* &BT)
{
    char ch;
    cout<<"ch=";
    cin>>ch;
    if(ch=='0')
        BT=NULL;
    else{
        BT=new BinTree;
        BT->data=ch;
        BT->Left=CreatePre(BT->Left);
        BT->Right=CreatePre(BT->Right);
    }
    return(BT);
}

（二）层序创建
层序创建所用的结点输入序列是按树的从上至下从左至右的顺序形成的，如上图的二叉树按层序创建，各结点的输入顺序为：A B 0 C D 0 0 E F 0 G 0 0
在构造二叉树的过程中，需要一个队列暂时存储各结点地址。过程如下：
（1）输入第一个数据：
若为0，表示此树为空，将空指针赋给根指针，树构造完毕；
若不为空，动态分配一个结点单元，并存入输入的数据，同时将该结点放入队列。
（2）若队列不为空，从队列中取出一个结点地址，并建立该结点的左右孩子：
从输入序列中读入下一数据：若读入的数据为0，将出队结点的左孩子指针置空；否则，分配一个结点单元，存入所读数值，并将其置为出队结点的左孩子，同时将此孩子地址入队。
再从输入序列中读入下一个数据：若读入的数据为0，将出队结点的右孩子指针置空；否则，分配一个结点单元，存入所读数值，并将其置为出队结点的右孩子，同时将此孩子地址入队。
（3）重复（2），直到队空再无结点入队。

因这一过程涉及有关队列的操作，现将关于队列的操作写在下面：
1.定义队列结点类型：

/*定义队列结点类型*/
struct QueNode
{
    BinTree *node;
    QueNode *next;
};

/*定义队列结点的指针*/
struct LinkQueue
{
    QueNode *Front;
    QueNode *Rear;
};

2.初始化队列

/*初始化队列*/
void CreateQueue(LinkQueue *Q)
{
    QueNode *Node;
    Node=new QueNode;
    Node->next=NULL;
    Q->Front=Node;
    Q->Rear=Node;
}

3.判断队列是否为空

/*判断队列是否为空*/
bool IsEmpty(LinkQueue *Q)
{
    return(Q->Front->next==NULL && Q->Rear->next==NULL);
}

4.将二叉树结点插入队尾

/*将二叉树结点插入队中*/
void InsertQueue(LinkQueue *Q,BinTree *X)
{
    QueNode *P;
    P=new QueNode;
    P->node=X;
    P->next=NULL;
    if(IsEmpty(Q))
        Q->Front->next=Q->Rear=P;
    else{
        Q->Rear->next=P;
        Q->Rear=P;
    }
}

5.返回并删除队头结点

/*返回并删除队头结点*/
BinTree *DeleteQueue(LinkQueue *Q)
{
    QueNode *P;
    BinTree *X;
    if(IsEmpty(Q)){
        cout<<"队空"<<endl;
        return NULL;
    }
    else{
        P=Q->Front->next;
        X=P->node;
        Q->Front->next=P->next;
        if(Q->Rear==P)
            Q->Rear=Q->Front;
        delete P;
        return(X);
}
}

层序创建二叉树的代码如下：

/*层序创建二叉树*/
void CreateLev(BinTree* &BT)
{
    BinTree *T;
    LinkQueue *Q;
    Q=new LinkQueue;
    CreateQueue(Q);
    char ch;
    cout<<"ch=";
    cin>>ch;
    if(ch!='0'){
        BT=new BinTree;
        BT->data=ch;
        BT->Left=NULL;
        BT->Right=NULL;
        InsertQueue(Q,BT);
    }
    else
        return;
    while(!IsEmpty(Q)){
        T=DeleteQueue(Q);
        cout<<"ch=";
        cin>>ch;
        if(ch!='0'){
            T->Left=new BinTree;
            T->Left->data=ch;
            T->Left->Left=T->Left->Right=NULL;
            InsertQueue(Q,T->Left);
        }
        else
            T->Left=NULL;
        cout<<"ch=";
        cin>>ch;
        if(ch!='0'){
            T->Right=new BinTree;
            T->Right->data=ch;
            T->Right->Left=T->Right->Right=NULL;
            InsertQueue(Q,T->Right);
        }
        else
            T->Right=NULL;
    }
}

二、二叉树的递归遍历

（一）先序遍历
对结点的访问在其左右子树遍历之前，遍历从根结点开始，具体过程：
访问根结点；
先序遍历其左子树；
先序遍历其右子树。
递归实现的代码如下：

/*先序遍历*/
void PreorderTraversal(BinTree* &BT)
{
    if(BT){
        cout<<BT->data<<' ';
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}

（二）中序遍历
遍历过程是：
中序遍历左子树；
访问根结点；
中序遍历右子树。
递归实现的代码如下：

/*中序遍历*/
void InorderTraversal(BinTree* &BT)
{
    if(BT){
        InorderTraversal(BT->Left);
        cout<<BT->data;
        InorderTraversal(BT->Right);
    }
}

（三）后序遍历
遍历过程是：
中序遍历左子树；
中序遍历右子树；
访问根结点。
递归实现的代码如下：

/*后序遍历*/
void PostorderTraversal(BinTree* &BT)
{
    if(BT){
        PostorderTraversal(BT->Left);
        PostorderTraversal(BT->Right);
        cout<<BT->data;
    }
}

三、二叉树的非递归遍历

二叉树的非递归遍历需要先从根结点开始，沿二叉树的左子树或右子树深入，当深入不下去时，再返回根结点。在这一过程中，返回结点的顺序与进入结点的顺序相反，即先入后出，可用堆栈来辅助实现。
有关链栈的操作：
1.定义链栈结构

/*定义链栈结构*/
typedef struct SNode
{
    BinTree *node;
    SNode *next;
}LinkStack;

2.初始化链栈

/*初始化链栈*/
LinkStack *CreateStack()
{
    LinkStack *S;
    S=new LinkStack;
    S->next=NULL;
    return(S);
}

3.入栈：将二叉树结点插入栈中

/*入栈：将结点插入栈顶*/
void Push(LinkStack *S,BinTree *X)
{
    LinkStack *P;
    P=new LinkStack;
    P->node=X;
    P->next=S->next;
    S->next=P;
}

4.出栈：从栈顶弹出二叉树结点

/*出栈：从栈顶弹出二叉树结点*/
BinTree *Pop(LinkStack *S)
{
    LinkStack *P;
    BinTree *T;
    if(S->next==NULL)
        T=NULL;
    else{
        P=S->next;
        T=P->node;
        S->next=P->next;
        delete P;
    }
    return(T);
}

（一）先序遍历
遍历过程：
遇到一个结点，访问之，将它压栈；
遍历它的左子树；
当左子树遍历结束后，从栈顶弹出这个结点，再先序遍历它的右子树。

/*非递归先序遍历*/
void NoRecuPreorder(BinTree* &BT)
{
    BinTree *T;
    LinkStack *S;
    S=CreateStack();
    T=BT;
    while(T || S->next!=NULL){
        while(T){
            cout<<T->data;
            Push(S,T);
            T=T->Left;
        }
        T=Pop(S);
        T=T->Right;
    }
}

（二）中序遍历
遍历过程：
遇到一个结点，将它压栈，并遍历它的左子树；
当左子树遍历结束后，从栈顶弹出这个结点并访问它；
按其右指针再中序遍历该结点的右子树。

/*非递归中序遍历*/
void NoRecuInorder(BinTree* &BT)
{
    BinTree *T;
    LinkStack *S;
    S=CreateStack();
    T=BT;
    while(T || S->next!=NULL){
        while(T){
            Push(S,T);
            T=T->Left;
        }
        T=Pop(S);
        cout<<T->data;
        T=T->Right;
    }
}

（三）后序遍历
非递归后序遍历，对每个结点，需要两次将其入栈。具体的遍历过程如下：
遇到一个结点，将它压栈，并遍历它的左子树；
当沿左子树无法深入，弹出该结点获得其右指针信息，再将其压入栈中，遍历其右子树；
当右子树无法深入，弹出结点并访问它。

由于需要将一个结点两次入栈、弹出（第一次入栈后遍历其左子树；第一次弹出以获得其指向右子树的指针信息；第二次入栈后遍历其右子树；第二次弹出后访问该结点），因此可在二叉树的结点定义中增加一个bool（或int）型的Tag变量，当变量值为true(1)，表示遍历或已遍历其左子树；当变量值为false(0)，表示遍历或已遍历其右子树。
新增Tag变量后的二叉树结点类型：

/*定义二叉树结点类型*/
typedef struct BinNode
{
    ElementType data;
    BinNode *Left;
    BinNode *Right;
    bool Tag;
}BinTree;

后序遍历函数代码：

/*非递归后序遍历*/
void NoRecuPostorder(BinTree* &BT)
{
    BinTree *T;
    LinkStack *S;
    S=CreateStack();
    T=BT;
    T->Tag=true;
    while(T || S->next!=NULL){
        while(T){
            Push(S,T);
            if(T->Tag){  //遍历左子树
                T=T->Left;
                if(T)
                    T->Tag=true;
            }
            else{       //遍历右子树
                T=T->Right;
                if(T)
                    T->Tag=true;
            }
        }

        T=Pop(S);
        if(T->Tag)  //右子树还没遍历
            T->Tag=!T->Tag;
        else{      //右子树已经遍历
            while(!T->Tag){
                cout<<T->data;
                if(S->next!=NULL)
                    T=Pop(S);
                else
                    break;
            }
            if(T->Tag)
                T->Tag=!T->Tag;
            else
                T=NULL;
        }
    }
}

（四）层序遍历
按树的层次，从左至右、从上到下进行访问。先遇到的结点先访问，完成某一层结点的访问后，再按它们的访问次序依次访问各结点的左右孩子结点。其具体实现，需要借助队列。
从根结点开始遍历，将根结点指针入队，然后反复执行如下操作，直到队列为空：
从队中取出一个元素；
访问该元素所指结点；
若该元素所指结点的左、右孩子结点非空，则将其左右孩子的指针顺序入队。

有关队列的操作见前文层序创建二叉树部分。
遍历代码如下：

/*层序遍历*/
void LevelorderTraversal(BinTree* &BT)
{
    LinkQueue *Q;
    Q=new LinkQueue;
    CreateQueue(Q);
    BinTree *T;
    T=BT;

    if(!BT)
        return;
    InsertQueue(Q,T);
    while(!IsEmpty(Q)){
        T=DeleteQueue(Q);
        cout<<T->data;
        if(T->Left)
            InsertQueue(Q,T->Left);
        if(T->Right)
            InsertQueue(Q,T->Right);
    }
}

四、输出二叉树的叶子结点

按递归的先序遍历算法，在访问结点时，添加if语句判断其是否为叶子结点。

/*打印叶子结点*/
void PreorderPrintLeaves(BinTree *BT)
{
    if(BT){
        if(!BT->Left && !BT->Right)
            cout<<BT->data;
        PreorderPrintLeaves(BT->Left);
        PreorderPrintLeaves(BT->Right);
    }
}

五、求二叉树高度

二叉树的高度为左右子树高度的最大值加一（根结点的高度），稍修改递归的后序遍历算法即可。

/*求二叉树的高度*/
int GetHeight(BinTree *BT)
{
    int HL,HR,MaxH;
    if(BT){
        HL=GetHeight(BT->Left);
        HR=GetHeight(BT->Right);
        MaxH=HL>HR?HL:HR;
        return(MaxH+1);
    }
    else
        return 0;
}

能直接运行的、实现以上全部操作的完整代码：

#include <iostream>
using namespace std;
typedef char ElementType;
/*定义二叉树结点类型*/
typedef struct BinNode
{
    ElementType data;
    BinNode *Left;
    BinNode *Right;
    bool Tag;
}BinTree;
/*定义链栈结构*/
typedef struct SNode
{
    BinTree *node;
    SNode *next;
}LinkStack;
/*定义队列结点类型*/
struct QueNode
{
    BinTree *node;
    QueNode *next;
};
/*定义队列结点的指针*/
struct LinkQueue
{
    QueNode *Front;
    QueNode *Rear;
};

BinTree *CreatePre(BinTree* &BT);      //先序创建二叉树
void CreateLev(BinTree* &BT);          //层序创建二叉树
void PreorderTraversal(BinTree* &BT);  //递归的先序遍历
void InorderTraversal(BinTree* &BT);   //递归的中序遍历
void PostorderTraversal(BinTree* &BT); //递归的后序遍历
void NoRecuPreorder(BinTree* &BT);     //非递归的先序遍历
void NoRecuInorder(BinTree* &BT);      //非递归的中序遍历
void NoRecuPostorder(BinTree* &BT);    //非递归的后序遍历
void LevelorderTraversal(BinTree* &BT);//层序遍历
void PreorderPrintLeaves(BinTree *BT); //打印叶子结点
int GetHeight(BinTree *BT);            //求二叉树高度


int main()
{
    BinTree *BT;

    CreatePre(BT);
    //CreateLev(BT); 层序创建

    cout<<"递归先序遍历："<<endl;
    PreorderTraversal(BT);
    cout<<endl;
    cout<<"非递归先序遍历："<<endl;
    NoRecuPreorder(BT);
    cout<<endl;
    cout<<"递归中序遍历："<<endl;
    InorderTraversal(BT);
    cout<<endl;
    cout<<"非递归中序遍历："<<endl;
    NoRecuInorder(BT);
    cout<<endl;
    cout<<"递归后序遍历："<<endl;
    PostorderTraversal(BT);
    cout<<endl;
    cout<<"非递归后序遍历："<<endl;
    NoRecuPostorder(BT);
    cout<<endl;
    cout<<"层序遍历："<<endl;
    LevelorderTraversal(BT);
    cout<<endl;

    cout<<"输出叶子结点："<<endl;
    PreorderPrintLeaves(BT);
    cout<<endl;
    cout<<"二叉树的高度："<<endl;
    cout<<GetHeight(BT)<<endl;

    return 0;
}

/*初始化链栈*/
LinkStack *CreateStack()
{
    LinkStack *S;
    S=new LinkStack;
    S->next=NULL;
    return(S);
}
/*入栈：将二叉树结点压入栈顶*/
void Push(LinkStack *S,BinTree *X)
{
    LinkStack *P;
    P=new LinkStack;
    P->node=X;
    P->next=S->next;
    S->next=P;
}
/*出栈：将二叉树结点从栈顶弹出*/
BinTree *Pop(LinkStack *S)
{
    LinkStack *P;
    BinTree *T;
    if(S->next==NULL)
        T=NULL;
    else{
        P=S->next;
        T=P->node;
        S->next=P->next;
        delete P;
    }
    return(T);
}

/*初始化队列*/
void CreateQueue(LinkQueue *Q)
{
    QueNode *Node;
    Node=new QueNode;
    Node->next=NULL;
    Q->Front=Node;
    Q->Rear=Node;
}
/*判断队列是否为空*/
bool IsEmpty(LinkQueue *Q)
{
    return(Q->Front->next==NULL && Q->Rear->next==NULL);
}
/*入队：将二叉树结点插入队中*/
void InsertQueue(LinkQueue *Q,BinTree *X)
{
    QueNode *P;
    P=new QueNode;
    P->node=X;
    P->next=NULL;
    if(IsEmpty(Q))
        Q->Front->next=Q->Rear=P;
    else{
        Q->Rear->next=P;
        Q->Rear=P;
    }
}
/*出队：返回并删除队头结点*/
BinTree *DeleteQueue(LinkQueue *Q)
{
    QueNode *P;
    BinTree *X;
    if(IsEmpty(Q)){
        cout<<"队空"<<endl;
        return NULL;
    }
    else{
        P=Q->Front->next;
        X=P->node;
        Q->Front->next=P->next;
        if(Q->Rear==P)
            Q->Rear=Q->Front;
        delete P;
        return(X);
}
}


/*按先序遍历创建二叉树*/
BinTree *CreatePre(BinTree* &BT)
{
    char ch;
    cout<<"ch=";
    cin>>ch;
    if(ch=='0')
        BT=NULL;
    else{
        BT=new BinTree;
        BT->data=ch;
        BT->Left=CreatePre(BT->Left);
        BT->Right=CreatePre(BT->Right);
    }
    return(BT);
}
/*层序创建二叉树*/
void CreateLev(BinTree* &BT)
{
    BinTree *T;
    LinkQueue *Q;
    Q=new LinkQueue;
    CreateQueue(Q);
    char ch;
    cout<<"ch=";
    cin>>ch;
    if(ch!='0'){
        BT=new BinTree;
        BT->data=ch;
        BT->Left=NULL;
        BT->Right=NULL;
        InsertQueue(Q,BT);
    }
    else
        return;
    while(!IsEmpty(Q)){
        T=DeleteQueue(Q);
        cout<<"ch=";
        cin>>ch;
        if(ch!='0'){
            T->Left=new BinTree;
            T->Left->data=ch;
            T->Left->Left=T->Left->Right=NULL;
            InsertQueue(Q,T->Left);
        }
        else
            T->Left=NULL;
        cout<<"ch=";
        cin>>ch;
        if(ch!='0'){
            T->Right=new BinTree;
            T->Right->data=ch;
            T->Right->Left=T->Right->Right=NULL;
            InsertQueue(Q,T->Right);
        }
        else
            T->Right=NULL;
    }
}


/*递归先序遍历*/
void PreorderTraversal(BinTree* &BT)
{
    if(BT){
        cout<<BT->data;
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}
/*递归中序遍历*/
void InorderTraversal(BinTree* &BT)
{
    if(BT){
        InorderTraversal(BT->Left);
        cout<<BT->data;
        InorderTraversal(BT->Right);
    }
}
/*递归后序遍历*/
void PostorderTraversal(BinTree* &BT)
{
    if(BT){
        PostorderTraversal(BT->Left);
        PostorderTraversal(BT->Right);
        cout<<BT->data;
    }
}

/*非递归先序遍历*/
void NoRecuPreorder(BinTree* &BT)
{
    BinTree *T;
    LinkStack *S;
    S=CreateStack();
    T=BT;
    while(T || S->next!=NULL){
        while(T){
            cout<<T->data;
            Push(S,T);
            T=T->Left;
        }
        T=Pop(S);
        T=T->Right;
    }
}
/*非递归中序遍历*/
void NoRecuInorder(BinTree* &BT)
{
    BinTree *T;
    LinkStack *S;
    S=CreateStack();
    T=BT;
    while(T || S->next!=NULL){
        while(T){
            Push(S,T);
            T=T->Left;
        }
        T=Pop(S);
        cout<<T->data;
        T=T->Right;
    }
}
/*非递归后序遍历*/
void NoRecuPostorder(BinTree* &BT)
{
    BinTree *T;
    LinkStack *S;
    S=CreateStack();
    T=BT;
    T->Tag=true;
    while(T || S->next!=NULL){
        while(T){
            Push(S,T);
            if(T->Tag){  //遍历左子树
                T=T->Left;
                if(T)
                    T->Tag=true;
            }
            else{       //遍历右子树
                T=T->Right;
                if(T)
                    T->Tag=true;
            }
        }

        T=Pop(S);
        if(T->Tag)  //右子树还没遍历
            T->Tag=!T->Tag;
        else{      //右子树已经遍历
            while(!T->Tag){
                cout<<T->data;
                if(S->next!=NULL)
                    T=Pop(S);
                else
                    break;
            }
            if(T->Tag)
                T->Tag=!T->Tag;
            else
                T=NULL;
        }
    }
}
/*层序遍历*/
void LevelorderTraversal(BinTree* &BT)
{
    LinkQueue *Q;
    Q=new LinkQueue;
    CreateQueue(Q);
    BinTree *T;
    T=BT;

    if(!BT)
        return;
    InsertQueue(Q,T);
    while(!IsEmpty(Q)){
        T=DeleteQueue(Q);
        cout<<T->data;
        if(T->Left)
            InsertQueue(Q,T->Left);
        if(T->Right)
            InsertQueue(Q,T->Right);
    }
}


/*打印叶子结点*/
void PreorderPrintLeaves(BinTree *BT)
{
    if(BT){
        if(!BT->Left && !BT->Right)
            cout<<BT->data;
        PreorderPrintLeaves(BT->Left);
        PreorderPrintLeaves(BT->Right);
    }
}


/*求二叉树的高度*/
int GetHeight(BinTree *BT)
{
    int HL,HR,MaxH;
    if(BT){
        HL=GetHeight(BT->Left);
        HR=GetHeight(BT->Right);
        MaxH=HL>HR?HL:HR;
        return(MaxH+1);
    }
    else
        return 0;
}

可用此层序构建一棵表达式树，程序运行结果如下：
在这里插入图片描述
红框以外为手动输入。
可知，表达式树中，叶结点是运算数，非叶结点是运算符。

MilkLeong
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树前中后层序遍历及树，节点构建c++代码样例
03-11
本文将详细介绍如何使用C++语言实现二叉树的前、中、后层序遍历以及如何构建和添加节点。 首先，我们需要定义一个二叉树节点类，包含数据、左子节点和右子节点的指针。在C++中，这可以表示为： ```cpp class ...
二叉树（递归非递归层序）遍历报告
05-05
在这个报告中，我们关注的是如何利用先序序列建立二叉树，并在建立的二叉树上执行不同类型的遍历：递归遍历（先序、中序、后序）、非递归遍历（先序、中序、后序）以及层序遍历。 首先，我们需要理解二叉树的基本...
C++实现二叉树(二叉链表)前序，中序，后序，层序遍历
weixin_73754150的博客
04-18 2117
若不为空，则将二叉树的根节点入队，然后开始队列不为空的判断，在此判断(循环)中：输出此结点，并对他的左右子树进行判断，左右子树不为空则进入队列，为空则直接跳过，最后再将遍历过的结点出队，这样一次判断(循环)便完成了。设二叉树中的结点均为一个字符，假设扩展二叉树的前序遍历序列有键盘输入，root为指向跟结点的指针，二叉链表的建立过程是：首先输入根节点，若输入的是一个“#”字符，则表明该二叉树为空树，也就是root=NULL；的语句顺序是：输出根节点，访问左子树，访问右子树；遍历，结果为：DGBAECF；
C++实现二叉树的前序、中序、后序、层次遍历（递归&非递归版）
qq_53527856的博客
06-10 1688
C++实现二叉树遍历（前序遍历、中序遍历、后续遍历、层次遍历），代码简洁易懂，注释详细。
C++实现二叉树的创建以及四种遍历方式（递归与非递归）
weixin_42133358的博客
05-23 4750
C++实现二叉树的创建以及四种遍历方式（递归与非递归） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 下图是我们要创建的二叉树，其中的#代表空字符； 为了验证我们程序的正确性，现给出此二叉树的四种遍历结果： 前序遍历（Preorder traversal）： A B C D E F
C++ 二叉树的遍历递归、非递归
09-28
对二叉树进行前、中、后、层序遍历。对前、中、后分别用递归和非递归。
C++二叉树的前序,中序,后序,层序遍历的递归算法55555.docx
06-02
C++二叉树的前序、中序、后序、层序遍历的递归算法 在计算机科学中，二叉树是一种重要的数据结构，广泛应用于计算机科学和信息技术领域。二叉树的遍历是指从二叉树的根结点出发，依次访问树中的每个结点的过程。...
非递归建立二叉树及测试代码.zip
05-05
在给定的压缩包"非递归建立二叉树及测试代码.zip"中，包含了实现这些功能的C++代码。通过这些代码，我们可以学习如何在实际编程中应用非递归算法来操作二叉树，这对于提升程序性能和理解数据结构有极大的帮助。测试...
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 901
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
数据结构之《栈》
2303_81098358的博客
07-24 1288
在之前我们已经学习了数据结构中线性表里面的顺序表与链表，了解了如何实现顺序表与链表增、删、查、该等功能。其实在线性表中除了顺序表和链表还有其他的类别，在本篇中我们就将学习另外一种线性表——栈，在通过本篇的学习后，你将会对栈的结构有充足的了解，在了解完结构后我们还将进行栈的实现。
【数据结构】：用Java实现链表
Yechiel的博客
07-24 1361
本篇文章用Java介绍了：链表的概念，以及单链表的主要功能的具体实现方法
数据结构——双向链表及其总结
2406_83392683的博客
07-23 425
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
【数据结构】单链表&带头双向循环链表的实现
t5y22的博客
07-24 445
链表
数据结构-C语言-排序（4）
h_number_1的博客
07-23 1198
归并排序、计数排序
2024.7.24 作业
qq_64434282的博客
07-24 1981
【代码】2024.7.24 作业。
数据结构和算法入门
weixin_67852890的博客
07-25 1493
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
qt练习控件label控件-lineEdit控件样例代码
最新发布
07-30
qt练习控件label控件-lineEdit控件样例代码
【JCR一区级】麻雀搜索算法SSA-CNN-LSTM-Attention故障诊断分类预测【含源码 5689期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Attention分类系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Attention分类 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Attention分类 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Attention分类 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Attention分类 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Attention分类
详解MATLAB Simulink通信系统建模与仿真
07-30
第1 章 MATLAB 基础与通信系统仿真 1.1 MATLAB 简介 1.2 MATLAB 程序设计 1.3 通信系统仿真 第2 章 Simulink 仿真基础 2.1 Simulink 简介 2.2 Simulink 工作环境 2.3 Simulink 仿真的基本方法 2.4 创建自己的模块库 2.5 S-函数的编写 第3 章 通信信号与系统分析 3.1 离散信号和系统 3.2 Fourier 分析 3.3 带通信号的低通等效 3.4 随机信号分析 第4 章 信道 4.1 加性高斯白噪声信道 4.2 多径衰落信道 第5 章 模拟调制 5.1 幅度调制 5.2 角度调制 第6 章 数字基带传输 6.1 概述 6.2 二进制基带信号传输 6.3 基带PAM 信号传输 6.4 带限信道的信号传输 第7 章 数字信号载波传输 7.1 概述 7.2 载波幅度调制（PAM） 7.3 载波相位调制（PSK） 7.4 正交幅度调制（QAM） 7.5 载波频率调制（FSK） 第8 章 信道编码和交织 8.1 概述 8.2 线性分组码
二叉树遍历算法详解：递归与非递归实现
"这篇文档是关于二叉树遍历的课程设计报告，涵盖了二叉树的各种遍历方法，包括递归和非递归的前序、中序、后序遍历，以及层序遍历。报告旨在提升学生的编程能力和理论实践结合的能力。" 二叉树遍历是计算机科学中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值