C语言二叉树的基本操作

二叉树在数据管理中应用广泛，现给出二叉树的操作实例以供参考：

/*
给一组数字，按照二叉树层序排布，其中-1表示空节点
*/
#include <cstdio>
#include <cstdlib>
typedef struct _BiTree {
    char num;
    struct _BiTree *left;
    struct _BiTree *right;
} BiTree;

// 创建二叉树
void CreateTree(BiTree **Tree)
{
    char n;
    char temp;
    scanf("%c", &n);
    temp = getchar();
    if (n == '#') {
        (*Tree) = NULL;
    } else {
        (*Tree) = (BiTree)malloc(sizeof(BiTree *));
        (*Tree)->num = n;
        CreateTree(&(*Tree)->left);
        CreateTree(&(*Tree)->right);
    }
    return;
}

// 先序遍历：根-左-右
void FistTraverse(BiTree *Tree)
{
    if (Tree == NULL) {
        return;
    }
    printf("%c", Tree->num);
    FistTraverse(Tree->left);
    FistTraverse(Tree->right);
}

// 中序遍历：左-根-右
void MidTraverse(BiTree *Tree)
{
    if (Tree == NULL) {
        return;
    }
    MidTraverse(Tree->left);
    printf("%c", Tree->num);
    MidTraverse(Tree->right);
}

// 后序遍历：左-右-根
void LastTraverse(BiTree *Tree)
{
    if (Tree == NULL) {
        return;
    }
    LastTraverse(Tree->left);
    LastTraverse(Tree->right);
    printf("%c", Tree->num);
}

// 层序遍历
#define MAXSIZE 50
typedef struct _SqQueue{
    BiTree* date[MAXSIZE];
    int front;//头指针 
    int rear;//尾指针 
} SqQueue;

void InitQueue(SqQueue *Sq)
{
    Sq->front = 0;
    Sq->rear = 0;
}

bool IsSqEmpty(SqQueue Sq)
{
    if (Sq.front == SqQueue.rear) {
        return true;
    } else {
        return false;
    }
}
// 入队
void EnQueue(SqQueue *Sq, BiTree *Tree)
{
    Sq->date[Sq->rear++] = Tree;
}
// 出队
void DeQueue(SqQueue *Sq, BiTree **Temp)
{
    (*Temp) = Sq->date[Sq->front++];
}

void LevelTraverse(BiTree *Tree)
{
    SqQueue Sq;
    BiTree *temp;
    InitQueue(&Sq);
    EnQueue(&Sq, Tree);
    while (!IsSqEmpty(Sq)) {
        DeQueue(&Sq, &temp);
        printf("%c", temp->num);
        if (temp->left) {
            EnQueue(&Sq, temp->left);
        }
        if (temp->right) {
            EnQueue(&Sq, temp->right);
        }
    }
}

// 根据先序+中序创建二叉树，输出后序遍历序列
BiTree CreateBinTreetoBack(char *pre, /* 先序 */
                     char *in,  /* 中序 */
                     int n      /* 序列个数 */)
{
    BiTree *Tree;
    if (n <= 0) {
        return NULL;
    }
    int i;
    Tree = (BiTree *)malloc(sizeof(BiTree));
    Tree->num = pre[0];
    for (i = 0; in[i] != pre[0]; i++);
    Tree->left = CreateBinTreetoBack(pre + 1, in, i);
    Tree->right = CreateBinTreetoBack(pre + i + 1, in + i + 1, n - i - 1);
    return Tree;
}

// 根据后序+中序创建二叉树，输出先序遍历序列
BiTree CreateBinTreetoFront(char *post, /* 后序 */
                     char *in,  /* 中序 */
                     int n      /* 序列个数 */)
{
    BiTree *Tree;
    if (n <= 0) {
        return NULL;
    }
    int i;
    Tree = (BiTree *)malloc(sizeof(BiTree));
    Tree->num = post[n - 1];
    for (i = 0; in[i] != post[n - 1]; i++);
    Tree->left = CreateBinTreetoFront(post, in, i);
    Tree->right = CreateBinTreetoFront(post + i, in + i + 1; n - i - 1);
    return Tree;
}
// 复制二叉树
int CopyTree(BiTree **NewTree, BiTree *Tree)
{
    if (Tree == NULL) {
        (*NewTree) = NULL;
        return 0;
    } else {
        (*NewTree) = (BiTree *)malloc(sizeof(BiTree));
        (*NewTree)->num = Tree->num;
        CopyTree(&(*NewTree)->left, Tree->left);
        CopyTree(&(*NewTree)->right, Tree->right);
    }
}
// 计算二叉树深度 前序遍历
int depth;
void DepthTreeFront(BiTree *Tree, int tempDepth)
{
    if (Tree == NULL) {
        return;
    }
    if (Tree->left == NULL && Tree->right == NULL) {
        depth = fmax(tempDepth, depth);
    }
    DepthTreeFront(Tree->left, tempDepth + 1);
    DepthTreeFront(Tree->right, tempDepth + 1);
}
// 计算二叉树深度 后序遍历
int DepthTree(BiTree *Tree)
{
    int m, n;
    if (Tree == NULL) {
        return 0;
    } else {
        m = DepthTree(Tree->left);
        n = DepthTree(Tree->right);
        if (m > n) {
            return (m + 1);
        } else {
            return (n + 1);
        }
    }
}

// 计算二叉树结点个数
int NodeCountTree(BiTree *Tree)
{
    if (Tree == NULL) {
        return 0;
    } else {
        return NodeCountTree(Tree->left) + NodeCountTree(Tree->right) + 1;
    }
}

// 计算二叉树叶子结点数
int LeavesCountTree(BiTree *Tree)
{
    if (Tree == NULL) {
        return 0;
    }
    if (Tree->left == NULL && Tree->right == NULL) {
        return 1;
    } else {
        return LeavesCountTree(Tree->left) + LeavesCountTree(Tree->right);
    }
}

// 释放
void FreeTree(BiTree **Tree)
{
    BiTree *temp = (*Tree);
    if ((*Tree) == NULL) {
        return;
    }
    FreeTree(&(*Tree)->left);
    FreeTree(&(*Tree)->right);
    free((*Tree));
    (*Tree) = NULL;
}

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

#define MAX_NUM 2000
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes)
{
    if (root == NULL) {
        *returnSize = 0;
        return NULL;
    }
    int **ret = (int **)malloc(sizeof(int *) * MAX_NUM);
    memset(ret, 0, sizeof(int *) * MAX_NUM);
    *returnColumnSizes = (int *)malloc(sizeof(int) * MAX_NUM); // 存储返回的二维数组每一行元素个数
    int head = 0;
    int tail = 0;
    struct TreeNode *queue[MAX_NUM] = {0};
    queue[tail++] = root;
    int level = 0; // 二叉树层数
    while (head < tail) {
        int len = tail - head;
        (*returnColumnSizes)[level] = len;
        ret[level] = (int *)malloc(sizeof(int) * len);
        for (int i = 0; i < len; i++) {
            struct TreeNode *temp = queue[head++];
            if (temp == NULL) {
                continue;
            }
            ret[level][i] = temp->val;
            if (temp->left) {
                queue[tail++] = temp->left;
            }
            if (temp->right) {
                queue[tail++] = temp->right;
            }
        }
        level++;
    }
    *returnSize = level;
    return ret;
}