2. 二叉树的建立与基本操作

编写程序实现二叉树的如下操作：
1) 建立二叉链表
2) 二叉树的先序、中序、后序遍历
3) 求二叉树的叶子结点个数
4) 将二叉树中所有结点的左、右子树相互交换

输入：
　　按完全二叉树的层次关系给出二叉树的遍历序列（#表示虚结点，数据结点为单一字符）。

输出：
　　二叉树的凹入表示
　　二叉树的先序序列、中序序列、后序序列
　　二叉树叶子结点个数
　　左、右子树相互交换后的二叉树的凹入表示
　　左、右子树相互交换后的二叉树的先序序列、中序序列、后序序列。

说明：
　　在输出凹入表示的二叉树时，先输出根结点，然后依次输出左右子树，上下层结点之间相隔 3 个空格。

	测试输入	期待的输出	时间限制	内存限制	额外进程
测试用例 1	以文本方式显示 abc#de↵	以文本方式显示 BiTree↵ a↵     b↵         d↵     c↵         e↵ pre_sequence  : abdce↵ in_sequence   : bdaec↵ post_sequence : dbeca↵ Number of leaf: 2↵ BiTree swapped↵ a↵     c↵         e↵     b↵         d↵ pre_sequence  : acebd↵ in_sequence   : ceadb↵ post_sequence : ecdba↵	1秒	64M	0
测试用例 2	以文本方式显示 abcdefg↵	以文本方式显示 BiTree↵ a↵     b↵         d↵         e↵     c↵         f↵         g↵ pre_sequence  : abdecfg↵ in_sequence   : dbeafcg↵ post_sequence : debfgca↵ Number of leaf: 4↵ BiTree swapped↵ a↵     c↵         g↵         f↵     b↵         e↵         d↵ pre_sequence  : acgfbed↵ in_sequence   : gcfaebd↵ post_sequence : gfcedba↵	1秒	64M	0

代码如下：

相当套路化的一道题，不想加注释了

#include 
#include 
#include 
#include 

int leafamount;
typedef struct BITree
{
    char data;
    struct BITree *r;
    struct BITree *l;
} Tree;

Tree *createNode(char data)
{
    Tree *node = (Tree *)malloc(sizeof(Tree));
    node->data = data;
    node->l = NULL;
    node->r = NULL;
    return node;
}
Tree *createBiTree(char *input, int length, int index)
{
    if (index >= length || input[index] == '#')
        return NULL;
    Tree *root = createNode(input[index]);
    int leftIndex = 2 * index + 1;
    int rightIndex = 2 * index + 2;
    if (leftIndex < length)
        root->l = createBiTree(input, length, leftIndex);
    if (rightIndex < length)
        root->r = createBiTree(input, length, rightIndex);
    return root;
}
void printTree(Tree *root, int rank)
{
    if (root == NULL)
        return;
    for (int i = 0; i < rank; i++)
        printf("    ");
    printf("%c\n", root->data);
    printTree(root->l, rank + 1);
    printTree(root->r, rank + 1);
}
void Preorder(Tree *root)
{
    if (root == NULL)
        return;
    printf("%c", root->data);
    Preorder(root->l);
    Preorder(root->r);
}
void Inorder(Tree *root)
{
    if (root == NULL)
        return;
    Inorder(root->l);
    printf("%c", root->data);
    Inorder(root->r);
}
void Postorder(Tree *root)
{
    if (root == NULL)
        return;
    Postorder(root->l);
    Postorder(root->r);
    printf("%c", root->data);
}
int Leafamount(Tree *root)
{
    if (root == NULL)
        return 0;
    if (root->l == NULL && root->r == NULL)
        leafamount++;
    Leafamount(root->l);
    Leafamount(root->r);
    return 0;
}
Tree *swapSubtrees(Tree *root)
{
    if (root == NULL)
        return NULL;
    Tree *temp = root->l;
    root->l = root->r;
    root->r = temp;
    swapSubtrees(root->l);
    swapSubtrees(root->r);
    return root;
}
const char *traversalNames[] =
    {
        "pre_sequence  : ",
        "in_sequence   : ",
        "post_sequence : "};
void (*traversalFunctions[])(Tree *) =
    {
        Preorder,
        Inorder,
        Postorder};
void output(Tree *root)
{
    for (int i = 0; i < 3; i++)
    {
        printf("%s", traversalNames[i]);
        traversalFunctions[i](root);
        printf("\n");
    }
}
int main()
{
    char input[200];
    memset(input, '\0', sizeof(input));
    scanf("%s", input);
    int length = strlen(input);
    int index = 0;
    Tree *root = createBiTree(input, length, index);

    printf("BiTree\n");
    printTree(root, 0);
    output(root);

    leafamount = 0;
    Leafamount(root);
    printf("Number of leaf: %d\n", leafamount);

    root = swapSubtrees(root);

    printf("BiTree swapped\n");
    printTree(root, 0);
    output(root);

    return 0;
}