二叉树链式存储的前中后递归和非递归遍历层序遍历实现

Posted 阿宝逃离地球

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了二叉树链式存储的前中后递归和非递归遍历层序遍历实现相关的知识,希望对你有一定的参考价值。

二叉树链式存储的前中后递归和非递归遍历、层序遍历实现

1. 二叉树的链式存储结构

#define ElementType char
typedef struct BTNode{
    ElementType data;
    struct BTNode *left,*right;
}BTNode,*BinTree;

2. 二叉树的前序、中序、后序递归遍历

时间复杂度和空间复杂度都为O(n)

前序
  • 如果二叉树空,则空操作;
  • 如果不空,
    • 先访问根结点
    • 然后前序遍历左子树
    • 再前序遍历右子树
void PreOderTraverse(BinTree T){
    if(!T) return;
    else {
        printf("%c\\t",T->data);
        PreOderTraverse(T->left);
        PreOderTraverse(T->right);
    }
}
中序
  • 如果二叉树空,则空操作;
  • 如果不空,
    • 中序遍历左子树
    • 访问根结点
    • 中序遍历右子树
void PreOderTraverse(BinTree T){
    if(!T) return;
    else {
        printf("%c\\t",T->data);
        PreOderTraverse(T->left);
        PreOderTraverse(T->right);
    }
}
后序
  • 如果二叉树空,则空操作;
  • 如果不空,
    • 后序遍历左子树
    • 后序遍历右子树
    • 访问根结点
void PreOderTraverse(BinTree T){
    if(!T) return;
    else {
        printf("%c\\t",T->data);
        PreOderTraverse(T->left);
        PreOderTraverse(T->right);
    }
}

输入的二叉树如下:

运行测试
int main(void)
{   
    //创建二叉树
    BinTree A = (BinTree)malloc(sizeof(struct BTNode));
    A->data = 'A';

    BinTree B = (BinTree)malloc(sizeof(struct BTNode));
    B->data = 'B';

    BinTree C = (BinTree)malloc(sizeof(struct BTNode));
    C->data = 'C';

    BinTree D = (BinTree)malloc(sizeof(struct BTNode));
    D->data = 'D';

    BinTree E = (BinTree)malloc(sizeof(struct BTNode));
    E->data = 'E';

    BinTree F = (BinTree)malloc(sizeof(struct BTNode));
    F->data = 'F';
    
    A->left = B;A->right = C;
    B->left = D;B->right = E;
    C->left = F;C->right = NULL;
    D->left = NULL;D->right =NULL;
    E->left = NULL;E->right =NULL;
    F->left = NULL;F->right =NULL;
    

    //前序遍历
    printf("先序遍历:");
    PreOderTraverse(A);
    printf("\\n");
    //中序遍历
    printf("中序遍历:");
    InOderTraverse(A);
    printf("\\n");
    //后序遍历
    printf("后序遍历:");
    PostOrderTraverse(A);
    printf("\\n");
    //释放内存
    free(A);
    free(B);
    free(C);
    free(D);
    free(E);
    free(F);
    
    return 0;
}

输出结果:

3. 二叉树的非递归遍历

中序非递归遍历,利用栈的链式存储来实现中序非递归遍历

存放二叉树结点的栈的链式存储结构、创建空栈、判空、出栈、入栈
/*栈的结点结构*/
typedef struct SNode{
    BinTree data;
    struct SNode *next;
}*Stack;

/*创建空栈*/
Stack CreateStack(){
    //创造头结点S,S不定义任何元素
    Stack S = (Stack)malloc(sizeof(struct SNode));
    S->next = NULL;
    return S;
}

/*判断栈空不空*/
int IsEmpty(Stack S){
    return (S->next == NULL);
}

/*入栈*/
void Push(Stack S,BinTree T){
        Stack newone = (Stack)malloc(sizeof(struct SNode));
        newone->data = T;
        newone->next = S->next;
        S->next = newone;
}

/*出栈*/
BinTree Pop(Stack S){
    if (!S)
    {   
        return NULL;
    }else{
        Stack tmp;BinTree T;

        tmp = S->next;//获取要删除的结点
        S->next = tmp->next;//更新栈顶的下一个结点地址
        T = tmp->data;//获取被弹出的栈元素的值

        free(tmp);//释放弹出的栈顶结点内存
        return T;
    }
}
先序非递归遍历二叉树
void InOrderTraverse(BinTree T){
    Stack S = CreateStack();//创建有头结点的空栈的指针
    BinTree p = T;//临时树结点
    BinTree q;
    while (p || !IsEmpty(S)) //树不空或者栈空 
    {
        if (p) 
        {
            Push(S,p);//将根结点的指针放入栈中
            p = p->left;//查看左子树,遍历左子树
        }else{
            //如果左子树遍历完,则从栈弹出根结点的值,开始遍历右子树
            q = Pop(S); 
            printf("%c\\t",q->data);
            p = q->right;
        }
    }
}
运行测试

//创建二叉树同上
//测试中序非递归遍历二叉树
    printf("中序非递归遍历:\\n");
    InOrderTraverse(A);

输出结果如下:

4. 层序遍历

层次遍历,利用队列的顺序存储结构实现

存放二叉树结点的队列的顺序存储结构、创建空队列、判空、入队、出队
/*定义队列的顺序存储结构*/
typedef struct QNode
{
    BinTree DataArray[MaxSize];//存放二叉树结点地址的数组
    int front,rear;//队头和队尾下标
    /*当front = rear时,链表为空*/
}*Queue;

/*创建空队列*/
Queue CreateQ(){
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->front = Q->rear = -1;
    return Q;
}

/*入队,尾加*/
void AddQ(Queue Q,BinTree bt){
    if ((Q->rear+1)%MaxSize == Q->front) return; /* 判断队列是否满 */
    Q->rear = (Q->rear+1)%MaxSize;
    Q->DataArray[Q->rear] = bt;  
}

/* 出队,头删 */
BinTree DeQ(Queue Q){
    if (Q->front == Q->rear) //判断队列是不是空
    {   
        printf("\\nit is null.\\n");
        return NULL;
    }else{
        Q->front = (Q->front+1)%MaxSize;
        BinTree bt = Q->DataArray[Q->front];
        return bt;
    }
}

/* 判断队列是否为空 */
int IsEmpty(Queue Q){
    return (Q->front == Q->rear);
}
层级遍历二叉树
void LevelTraversal(BinTree T){
    if(!T) return; //空二叉树
    //创建空队列
    Queue Q = CreateQ();
    BinTree p;
    //入队
    AddQ(Q,T); //根结点进入队列
    while (!IsEmpty(Q)) //队不为空则循环
    {
        //出队
        p = DeQ(Q);
        printf("%c\\t",p->data);
        if(p->left) AddQ(Q,p->left);
        if(p->right) AddQ(Q,p->right);
    }
}
运行测试
//测试层次非递归遍历二叉树
    printf("层次非递归遍历:\\n");
    LevelTraversal(A);

结果如图

以上是关于二叉树链式存储的前中后递归和非递归遍历层序遍历实现的主要内容,如果未能解决你的问题,请参考以下文章

二叉树的前中后和层序遍历详细图解(递归和非递归写法)

LeetCode JS实现 二叉树(前中后层序)遍历(递归迭代法)

LeetCode JS实现 二叉树(前中后层序)遍历(递归迭代法)

二叉树的前中后遍历-递归和非递归

二叉树的前中后遍历-递归和非递归

二叉树的前中后序递归和非递归遍历操作代码