数据结构 通俗易懂版 c语言描述----树，排序二叉树的创建，删除，前中后、层序遍历

2022.2.18

排序二叉树的建立，删除，以及前中后序遍历，层次遍历（链队实现）

#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <stdlib.h>
//树结点
typedef struct Node
{
    int data;
    struct Node *lchild, *rchild;
} Node;
//树
typedef struct Tree
{
    struct Node *root;
    int size;
} Tree;
//链队结点
typedef struct Qnode
{
    struct Node *p;
    struct Qnode *next;
} Qnode;
//链队
typedef struct Queue
{
    struct Qnode *head, *rear;
} Queue;

//创一个结点
Node *GetNode(int val)
{
    Node *p = (Node *)malloc(sizeof(Node));
    p->data = val;
    p->lchild = p->rchild = NULL;
    return p;
}
//创一个树
Tree *GetTree()
{
    Tree *tree = (Tree *)malloc(sizeof(Tree));
    tree->root = NULL;
    tree->size = 0;
    return tree;
}
//清除传入结点下的所有结点
bool ClearNode(Node *node)
{
    if (node == NULL)
        return true;
    ClearNode(node->lchild);
    ClearNode(node->rchild);
    free(node);
    return true;
}
//清除树
bool ClearTree(Tree *tree)
{
    ClearNode(tree->root);
    free(tree);
    return true;
}
//排序插入结点
Node *InsertNode(Node *node, int val, int *flag)
{
    if (node == NULL)
    { //树空第一次进来的时候 (即tree->root=NULL)直接返回结点地址 在外面用tree->root接(tree->root=)，有了根结点后(tree->root!=NULL) 此步返回的结点地址被上一层的函数接收(node->r/lchild=),这样就完成了排序插入结点，而整个函数在递归调用结束后 返回的总是传进来的node即tree-root(栈)；
        *flag = 1;
        return GetNode(val);
    }
    if (val == node->data)
    {
        return node;
    }
    if (val > node->data)
    {
        node->rchild = InsertNode(node->rchild, val, flag);
    }
    else
        node->lchild = InsertNode(node->lchild, val, flag);
    return node;
}
//给树插入结点
void Insert(Tree *tree, int val)
{
    int flag = 0;
    tree->root = InsertNode(tree->root, val, &flag);
    if (flag == 1)
        tree->size++;
    return;
}
//中序遍历
void InOrder(Node *node)
{
    if (node == NULL)
        return;
    InOrder(node->lchild);
    printf(" %d", node->data);
    InOrder(node->rchild);
    return;
}
//前序遍历
bool PreOrder(Node *node)
{
    if (node == NULL)
        return true;
    printf(" %d", node->data);
    PreOrder(node->lchild);
    PreOrder(node->rchild);
    return true;
}
//后序遍历
bool PostOrder(Node *node)
{
    if (node == NULL)
        return true;
    PostOrder(node->lchild);
    PostOrder(node->rchild);
    printf(" %d", node->data);
    return true;
}
//初始化链队
Queue *InitQueue()
{
    Queue *s = (Queue *)malloc(sizeof(Queue));
    Qnode *p = (Qnode *)malloc(sizeof(Qnode));
    p->p = NULL;
    s->head = s->rear = p;
    return s;
}
//入队
bool EnQueue(Queue *p, Node *node)
{
    Qnode *s = (Qnode *)malloc(sizeof(Qnode));
    s->p = node;
    s->next = NULL;

    p->rear->next = s;
    p->rear = s;
    return true;
}
//出队
Node *OutQueue(Queue *p)
{
    if (p->head->next == NULL)
        return false;

    Qnode *s = p->head->next;
    p->head->next = s->next;

    if (p->head->next == NULL)  //如果队空 首尾结点指向头节点
        p->rear = p->head;
    return s->p;
}
//层序遍历
bool LeveOrderNode(Node *root)
{
    Queue *p = InitQueue();
    EnQueue(p, root);

    while (p->head->next != NULL)
    {
        Node *s = OutQueue(p);
        printf(" %d", s->data);
        if (s->lchild != NULL)
        {
            EnQueue(p, s->lchild);
        }
        if (s->rchild != NULL)
        {
            EnQueue(p, s->rchild);
        }
    }
}

int main()
{
    srand(time(0));
    Tree *p = GetTree();
    for (int i = 0; i < 50; i++)
    {
        int val = rand() % 100;
        Insert(p, val);
    }
    InOrder(p->root), putchar('\n');
    PreOrder(p->root), putchar('\n');
    PostOrder(p->root), putchar('\n');
    LeveOrderNode(p->root), putchar('\n');
}