【C语言】二叉树基本操作

#include <stdio.h>
#include <windows.h>
#include <stdlib.h>

typedef struct BiTree
{
    char data;
    struct BiTree *lchild;
    struct BiTree *rchild;
} BiTNode, *BinaryTree; // 二叉树结点

typedef struct LNode
{
    BinaryTree data;
    struct LNode *next;
} LinkNode;

typedef struct
{
    LinkNode *front;
    LinkNode *rear;
} LinkQueue; // 链队列

typedef struct
{
    LinkNode *top;
} LinkStack; // 链栈

// 链队列操作
void InitLinkQueue(LinkQueue *LQ);
void EnQueue(LinkQueue *LQ, BinaryTree e);
void DeQueue(LinkQueue *LQ, BinaryTree *e);
int IsQueueEmpty(LinkQueue LQ);

// 链栈操作
void InitLinkStack(LinkStack *LS);
void push(LinkStack *LS, BinaryTree e);
void pop(LinkStack *LS, BinaryTree *e);
int IsStackEmpty(LinkStack LS);
void GetTop(LinkStack LS, BinaryTree *e);

// 二叉树操作
void CreateBinaryTree(BinaryTree *BT);
void PreOrder(BinaryTree BT);
void InOrder(BinaryTree BT);
void PostOrder(BinaryTree BT);
int CountLeaf(BinaryTree BT);
int CountNode(BinaryTree BT);
int Depth(BinaryTree BT);
void PreOrder2(BinaryTree BT);
void InOrder2(BinaryTree BT);
void PostOrder2(BinaryTree BT);
void LevelOrder(BinaryTree BT);
int Depth2(BinaryTree BT);
int main()
{
    BinaryTree BT; // 测试用例：ABD#G###CE##F##
    CreateBinaryTree(&BT);
    printf("先序遍历:\n");
    PreOrder(BT);
    printf("\n");
    printf("先序遍历(非递归):\n");
    PreOrder2(BT);
    printf("\n");
    printf("中序遍历:\n");
    InOrder(BT);
    printf("\n");
    printf("中序遍历(非递归):\n");
    InOrder2(BT);
    printf("\n");
    printf("后序遍历:\n");
    PostOrder(BT);
    printf("\n");
    printf("后序遍历(非递归):\n");
    PostOrder2(BT);
    printf("\n");
    printf("层序遍历:\n");
    LevelOrder(BT);
    printf("\n叶子节点数: %d\n总结点数: %d\n二叉树深度: %d\n",
           CountLeaf(BT), CountNode(BT), Depth(BT));
    system("pause");
    return 0;
}

void InitLinkQueue(LinkQueue *LQ)
{
    LQ->front = LQ->rear = (LinkNode *)malloc(sizeof(LinkNode));
    LQ->front->next = NULL;
}
void EnQueue(LinkQueue *LQ, BinaryTree e)
{
    LinkNode *p = (LinkNode *)malloc(sizeof(LinkNode));
    p->data = e;
    p->next = NULL;
    LQ->rear->next = p;
    LQ->rear = p;
}
void DeQueue(LinkQueue *LQ, BinaryTree *e)
{
    if (LQ->front == LQ->rear)
    {
        return;
    }
    LinkNode *p = LQ->front->next;
    LQ->front->next = p->next;
    *e = p->data;
    if (p == LQ->rear)
    {
        LQ->rear = LQ->front;
    }
    free(p);
}

int IsQueueEmpty(LinkQueue LQ)
{
    return LQ.front == LQ.rear;
}

void InitLinkStack(LinkStack *LS)
{
    LS->top = NULL;
}
void push(LinkStack *LS, BinaryTree e)
{
    LinkNode *p = (LinkNode *)malloc(sizeof(LinkNode));
    p->data = e;
    p->next = LS->top;
    LS->top = p;
}
void pop(LinkStack *LS, BinaryTree *e)
{
    if (LS->top == NULL)
    {
        return;
    }
    LinkNode *p = LS->top;
    LS->top = p->next;
    *e = p->data;
    free(p);
}
int IsStackEmpty(LinkStack LS)
{
    return LS.top == NULL;
}

void GetTop(LinkStack LS, BinaryTree *e)
{
    if (!IsStackEmpty(LS))
    {
        *e = LS.top->data;
    }
    else
    {
        *e = NULL;
    }
}

void CreateBinaryTree(BinaryTree *BT)
{
    char e;
    scanf("%c", &e);
    if (e == '#')
    {
        *BT = NULL;
        return;
    }
    else
    {
        *BT = (BiTNode *)malloc(sizeof(BiTNode));
        (*BT)->data = e;
        CreateBinaryTree(&(*BT)->lchild);
        CreateBinaryTree(&(*BT)->rchild);
    }
}
void PreOrder(BinaryTree BT)
{
    if (BT)
    {
        printf("%c ", BT->data);
        PreOrder(BT->lchild);
        PreOrder(BT->rchild);
    }
}

void InOrder(BinaryTree BT)
{
    if (BT)
    {
        InOrder(BT->lchild);
        printf("%c ", (BT)->data);
        InOrder(BT->rchild);
    }
}

void PostOrder(BinaryTree BT)
{
    if (BT)
    {
        PostOrder(BT->lchild);
        PostOrder(BT->rchild);
        printf("%c ", BT->data);
    }
}

int CountLeaf(BinaryTree BT)
{
    if (BT == NULL)
    {
        return 0;
    }
    if (BT->lchild == NULL && BT->rchild == NULL)
    {
        return 1;
    }
    else
    {
        return CountLeaf(BT->lchild) + CountLeaf(BT->rchild);
    }
}

int CountNode(BinaryTree BT)
{
    if (BT == NULL)
    {
        return 0;
    }
    else
    {
        return CountNode(BT->lchild) + CountNode(BT->rchild) + 1;
    }
}

int Depth(BinaryTree BT)
{
    if (BT == NULL)
    {
        return 0;
    }
    else
    {
        int L = Depth(BT->lchild);
        int R = Depth(BT->rchild);
        return (L > R ? L : R) + 1;
    }
}

void PreOrder2(BinaryTree BT)
{
    LinkStack LS;
    InitLinkStack(&LS);
    BinaryTree p = BT;
    while (p || !IsStackEmpty(LS))
    {
        if (p)
        {
            printf("%c ", p->data);
            push(&LS, p);
            p = p->lchild;
        }
        else
        {
            pop(&LS, &p);
            p = p->rchild;
        }
    }
}

void InOrder2(BinaryTree BT)
{
    LinkStack LS;
    InitLinkStack(&LS);
    BinaryTree p = BT;
    while (p || !IsStackEmpty(LS))
    {
        if (p)
        {
            push(&LS, p);
            p = p->lchild;
        }
        else
        {
            pop(&LS, &p);
            printf("%c ", p->data);
            p = p->rchild;
        }
    }
}
void LevelOrder(BinaryTree BT)
{
    LinkQueue LQ;
    BinaryTree p = BT;
    InitLinkQueue(&LQ);
    EnQueue(&LQ, p);
    while (!IsQueueEmpty(LQ))
    {
        DeQueue(&LQ, &p);
        printf("%c ", p->data);
        if (p->lchild)
        {
            EnQueue(&LQ, p->lchild);
        }
        if (p->rchild)
        {
            EnQueue(&LQ, p->rchild);
        }
    }
}
int Depth2(BinaryTree BT)
{
    if(!BT)
    {
        return 0;
    }
    int front=-1;
    int rear=-1;
    BinaryTree Queue[100]={NULL};
    int last=0;
    int level=0;
    BinaryTree p;
    Queue[++rear]=BT;
    while(front<rear)
    {
        p=Queue[++front];
        if(p->lchild)
        {
            Queue[++rear]=p->lchild;
        }
        if(p->rchild)
        {
            Queue[++rear]=p->rchild;
        }
        if(front==last)
        {
            level++;
            last=rear;
        }
        
    }
    return level;
}
void PostOrder2(BinaryTree BT)
{
    LinkStack LS;
    InitLinkStack(&LS);
    BinaryTree p = BT;
    BinaryTree tag = NULL; // 标志指针
    while (p || !IsStackEmpty(LS))
    {
        if (p)
        {
            push(&LS, p);
            p = p->lchild;
        }
        else
        {
            GetTop(LS, &p);
            if (p->rchild && p->rchild != tag)
            {
                p = p->rchild;
            }
            else
            {
                pop(&LS, &p);
                printf("%c ", p->data);
                tag = p;
                p = NULL;
            }
        }
    }
}

测试结果：