c语言程序设计二叉树，要求使用括号表示法输入二叉树并转化为二叉树的链式存储结构；横向输出二叉树；求二叉树的高度；统计二叉树中的节点个数；中序遍历该二叉树（采用递归算法）；层序遍历该二叉树；【选做】判断该二叉树是否为完全二叉树；最后编写main函数对以上功能进行测试。

C语言程序设计中，二叉树是一种非常重要的数据结构。它的定义是一个有限的节点集合，该集合或者为空集，或者由一个根节点和两棵分别称为左子树和右子树的二叉树组成。下面是实现二叉树所需的相关功能：

1. 使用括号表示法输入二叉树并转化为二叉树的链式存储结构

使用括号表示法，我们可以将二叉树转化为一个字符串，从而方便对二叉树进行处理。例如，对于如下的二叉树：

      A
     / \
    B   C
   /   / \
  D   E   F

使用括号表示法，可以将该二叉树表示为：A(B(D),C(E,F))。

接下来，我们需要将这个字符串转化为二叉树的链式存储结构。具体实现可以采用递归的方式，从字符串的第一个字符开始读取，遇到左括号就递归处理左子树，遇到右括号就递归处理右子树。

2. 横向输出二叉树

横向输出二叉树可以方便地观察该二叉树的结构。实现思路是使用中序遍历的方式，先遍历右子树，然后输出当前节点，最后遍历左子树。输出时需要考虑每个节点的深度和位置。

3. 求二叉树的高度

求二叉树的高度可以采用递归的方式实现。二叉树的高度等于左子树高度和右子树高度中较大的那个再加1。

4. 统计二叉树中的节点个数

统计二叉树中的节点个数也可以采用递归的方式实现。二叉树中节点个数等于左子树中节点个数加右子树中节点个数再加1。

5. 中序遍历该二叉树（采用递归算法）

中序遍历是指先遍历左子树，然后访问当前节点，最后遍历右子树。采用递归算法实现比较简单。

6. 层序遍历该二叉树

层序遍历是指按照从上到下、从左到右的顺序依次访问每个节点。可以使用队列来实现。

7. 判断该二叉树是否为完全二叉树

完全二叉树是指除了最后一层以外，其他层都是满的，并且最后一层上的节点都尽量靠左排列。可以采用层序遍历的方式来判断。

下面是一个简单的代码实现，仅供参考：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_TREE_SIZE 100

typedef struct BiTNode {
    char data;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

int CreateBiTree(BiTree *T, char *s, int *p);
void PrintTree(BiTree T, int depth);
int GetTreeHeight(BiTree T);
int CountTreeNodes(BiTree T);
void InOrderTraverse(BiTree T);
void LevelOrderTraverse(BiTree T);
int IsCompleteBinaryTree(BiTree T);

int main() {
    BiTree T = NULL;
    char s[MAX_TREE_SIZE];
    printf("请输入二叉树的括号表示法：\n");
    fgets(s, MAX_TREE_SIZE, stdin);
    int p = 0;
    CreateBiTree(&T, s, &p);
    printf("横向输出二叉树：\n");
    PrintTree(T, 0);
    printf("二叉树高度：%d\n", GetTreeHeight(T));
    printf("二叉树节点个数：%d\n", CountTreeNodes(T));
    printf("中序遍历结果：");
    InOrderTraverse(T);
    printf("\n");
    printf("层序遍历结果：");
    LevelOrderTraverse(T);
    printf("\n");
    if (IsCompleteBinaryTree(T)) {
        printf("该二叉树是完全二叉树\n");
    } else {
        printf("该二叉树不是完全二叉树\n");
    }
    return 0;
}

int CreateBiTree(BiTree *T, char *s, int *p) {
    if (s[*p] == '\0' || s[*p] == ')') {
        *T = NULL;
        (*p)++;
    } else if (s[*p] == '(') {
        (*p)++;
        if (s[*p] == ')') {
            *T = NULL;
            (*p)++;
        } else {
            *T = (BiTree)malloc(sizeof(BiTNode));
            (*T)->data = s[*p];
            CreateBiTree(&((*T)->lchild), s, p);
            CreateBiTree(&((*T)->rchild), s, p);
        }
    } else {
        *T = (BiTree)malloc(sizeof(BiTNode));
        (*T)->data = s[*p];
        (*T)->lchild = NULL;
        (*T)->rchild = NULL;
        (*p)++;
    }
    return 1;
}

void PrintTree(BiTree T, int depth) {
    if (T) {
        PrintTree(T->rchild, depth + 1);
        for (int i = 0; i < depth; i++) {
            printf("   ");
        }
        printf("%c\n", T->data);
        PrintTree(T->lchild, depth + 1);
    }
}

int GetTreeHeight(BiTree T) {
    if (!T) {
        return 0;
    } else {
        int left_height = GetTreeHeight(T->lchild);
        int right_height = GetTreeHeight(T->rchild);
        return left_height > right_height ? left_height + 1 : right_height + 1;
    }
}

int CountTreeNodes(BiTree T) {
    if (!T) {
        return 0;
    } else {
        return CountTreeNodes(T->lchild) + CountTreeNodes(T->rchild) + 1;
    }
}

void InOrderTraverse(BiTree T) {
    if (T) {
        InOrderTraverse(T->lchild);
        printf("%c", T->data);
        InOrderTraverse(T->rchild);
    }
}

void LevelOrderTraverse(BiTree T) {
    if (!T) {
        return;
    }
    BiTree queue[MAX_TREE_SIZE];
    int front = 0, rear = 0;
    queue[rear++] = T;
    while (front != rear) {
        BiTree node = queue[front++];
        printf("%c", node->data);
        if (node->lchild) {
            queue[rear++] = node->lchild;
        }
        if (node->rchild) {
            queue[rear++] = node->rchild;
        }
    }
}

int IsCompleteBinaryTree(BiTree T) {
    if (!T) {
        return 1;
    }
    BiTree queue[MAX_TREE_SIZE];
    int front = 0, rear = 0;
    queue[rear++] = T;
    while (front != rear) {
        BiTree node = queue[front++];
        if (!node) { // 遇到空节点，检查队列中是否还有非空节点
            while (front != rear && queue[front] == NULL) {
                front++;
            }
            if (front != rear) { // 队列中还有非空节点，则不是完全二叉树
                return 0;
            }
        } else { // 非空节点入队
            queue[rear++] = node->lchild;
            queue[rear++] = node->rchild;
        }
    }
    return 1;
}