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

Posted 2021-09-01 阿宝逃离地球

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

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);

结果如图