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

为了更好地演示，我先给你展示一下二叉树的括号表示法：

(A(B(D)(E))(C(F)(G)))

其中，每个节点都用括号括起来，括号内的第一个字符表示该节点的值，括号内的括号表示该节点的左右子树。

接下来，我将按照你的要求逐步完成这道题目。

首先，我们需要定义二叉树的数据结构：

typedef struct TreeNode {
    char value;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

然后，我们需要实现将括号表示法转化为二叉树的函数：

TreeNode* treeFromString(char* str) {
    if (!str || *str == '\0') {
        return NULL;
    }
    if (*str == '(') {
        str++;
    }
    if (*str == ')') {
        return NULL;
    }
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->value = *str;
    node->left = treeFromString(str + 1);
    node->right = treeFromString(str + 2);
    return node;
}

接下来，我们需要实现横向输出二叉树的函数：

void printTree(TreeNode* root, int level) {
    if (!root) {
        return;
    }
    printTree(root->right, level + 1);
    printf("\n");
    for (int i = 0; i < level; i++) {
        printf("    ");
    }
    printf("%c", root->value);
    printTree(root->left, level + 1);
}

然后，我们需要实现求二叉树高度的函数：

int treeHeight(TreeNode* root) {
    if (!root) {
        return 0;
    }
    int leftHeight = treeHeight(root->left);
    int rightHeight = treeHeight(root->right);
    return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

接下来，我们需要实现统计二叉树中节点个数的函数：

int treeNodeCount(TreeNode* root) {
    if (!root) {
        return 0;
    }
    return treeNodeCount(root->left) + treeNodeCount(root->right) + 1;
}

然后，我们需要实现中序遍历二叉树的函数：

void inOrderTraversal(TreeNode* root) {
    if (!root) {
        return;
    }
    inOrderTraversal(root->left);
    printf("%c ", root->value);
    inOrderTraversal(root->right);
}

接下来，我们需要实现层序遍历二叉树的函数：

void levelOrderTraversal(TreeNode* root) {
    if (!root) {
        return;
    }
    Queue* queue = createQueue();
    enqueue(queue, root);
    while (!isEmpty(queue)) {
        TreeNode* node = dequeue(queue);
        printf("%c ", node->value);
        if (node->left) {
            enqueue(queue, node->left);
        }
        if (node->right) {
            enqueue(queue, node->right);
        }
    }
    destroyQueue(queue);
}

最后，我们需要实现判断是否为完全二叉树的函数：

int isCompleteTree(TreeNode* root) {
    if (!root) {
        return 1;
    }
    Queue* queue = createQueue();
    enqueue(queue, root);
    int flag = 0;
    while (!isEmpty(queue)) {
        TreeNode* node = dequeue(queue);
        if (!node->left) {
            flag = 1;
        } else if (flag) {
            destroyQueue(queue);
            return 0;
        } else {
            enqueue(queue, node->left);
        }
        if (!node->right) {
            flag = 1;
        } else if (flag) {
            destroyQueue(queue);
            return 0;
        } else {
            enqueue(queue, node->right);
        }
    }
    destroyQueue(queue);
    return 1;
}

最后，我们可以编写main函数对以上功能进行测试：

int main() {
    char str[] = "(A(B(D)(E))(C(F)(G)))";
    TreeNode* root = treeFromString(str);
    printTree(root, 0);
    printf("\n");
    printf("tree height: %d\n", treeHeight(root));
    printf("tree node count: %d\n", treeNodeCount(root));
    printf("in-order traversal: ");
    inOrderTraversal(root);
    printf("\n");
    printf("level-order traversal: ");
    levelOrderTraversal(root);
    printf("\n");
    printf("is complete tree: %d\n", isCompleteTree(root));
    return 0;
}

完整代码如下：