BST（二叉搜索树）的层级遍历 后序遍历 建树

//后序遍历
void inOrder(BST_t* tree)
{
    inOrder1(tree->root);
}

void inOrder1(TreeNode_t* node)
{
    //边界条件
    if (node == NULL)
        return;
    //递归公式
    inOrder1(node->left);
    inOrder1(node->right);
    printf("%c ", node->key);
}

//层次遍历
void levelOrder(BST_t* tree)
{
    if (tree->root == NULL)
        return;
    Queue_t* q = createQueue();
    //将根结点入队列
    enqueue(q, tree->root);
    while (!isEmpty(q))
    {
        //出队列
        TreeNode_t* newNode = dequeue(q);
        //遍历该结点
        printf("%c ", newNode->key);
        if (newNode->left != NULL) {
            enqueue(q, newNode->left);
        }
        if (newNode->right != NULL) {
            enqueue(q, newNode->right);
        }
    }
}

Queue_t* createQueue()
{
    return calloc(1, sizeof(Queue_t));
}

void enqueue(Queue_t* q, TreeNode_t* node)//头插法
{
    if (isFull(q)) {
        printf("Error：queue is full\n");
        exit(1);
    }
    TreeNode_t* newcode = calloc(1, sizeof(TreeNode_t));
    newcode->key = node->key;
    newcode->left = node->left;
    newcode->right = node->right;

    if (isEmpty(q))
    {
        newcode->next = NULL;
        q->head = newcode;
        q->rear = newcode;
        q->size++;
    }
    else
    {
        newcode->next = q->head;
        q->head = newcode;
        q->size++;
    }
}

TreeNode_t* dequeue(Queue_t* q)//尾删法
{
    if (isEmpty(q))
    {
        printf("Error: queue is emtpy\n");
        exit(1);
    }
    TreeNode_t* findrear = q->head;
    if (q->head == q->rear)//是否只有一个结点
    {
        q->head = NULL;
        q->rear = NULL;
        q->size--;
        return findrear;
    }

    //找到尾结点前一个节点
    while (!(findrear->next == q->rear))
    {
        findrear = findrear->next;
    }
    q->rear = findrear;
    findrear = findrear->next;
    q->rear->next = NULL;
    q->size--;

    return findrear;
}

bool isEmpty(Queue_t* q)
{
    return q->size == 0;
}

bool isFull(Queue_t* q)
{
    return q->size == N;
}

//建树
BST_t* build(char* aftOrder, char* inOrder, int n)
{
    BST_t* tree = create();
    //委托
    tree->root = build(aftOrder, inOrder, n);
    return tree;
}

TreeNode_t* build1(char* aftOrder, char* inOrder, int n)
{
    //边界条件
    if (n == 0)
        return NULL;
    //递归公式 构建根结点
    TreeNode_t* node = malloc(sizeof(TreeNode_t));
    if (node == NULL) {
        printf("Error: malloc failed\n");
        exit(1);
    }
    int idx = 0;
    //找到根结点 不管是已知先中序的建树还是已知中后序，第一步都是先找根结点
    node->key = aftOrder[n - 1 - idx];
    while (inOrder[idx] != node->key)
        idx++;
    //构建右子树
    node->right = build1(aftOrder + idx, inOrder + 1 + idx, n - idx - 1);
    //构建左子树
    node->left = build1(aftOrder + idx, inOrder + 1 + idx, n - idx - 1);

    return node;
}

层次遍历图：

 头文件内容：

#include <stdbool.h>
#include <stdlib.h>
#include<stdio.h>
#define N 10

//创建一个树结点类型
typedef struct treeNode_s {
    char key;
    struct treeNode_s* left;
    struct treeNode_s* right;
    struct treeNode_s* next;
}TreeNode_t;

//创建一个二叉搜索树类型
typedef struct bst_s {
    struct treeNode_s* root;
}BST_t;

//建个队列来进行层次遍历
typedef struct queue_s {
    TreeNode_t* head, * rear;
    int size;
}Queue_t;

// 接口
//BST_t* 类型 因为我们用calloc初始化的话，返回的是指针类型
BST_t* create();
void insert(BST_t* tree, char key);
void rm(BST_t* tree, char key);
bool search(BST_t* tree, char key);
// 遍历
void inOrder(BST_t* tree);
void levelOrder(BST_t* tree);
// 建树
BST_t* build(char* aftOrder, char* inOrder, int n);
char minKey(BST_t* tree);
char maxKey(BST_t* tree);
void enqueue(Queue_t* q, int val);
TreeNode_t* dequeue(Queue_t* q);
Queue_t* createQueue();
bool isEmpty(Queue_t* q);
bool isFull(Queue_t* q);