用C语言从键盘读入字符（数字、字母或其他符号）建立一个深度不小于3层的树的孩子兄弟表存储结构，然后①分别递归先根、后根遍历该树并输出相应遍历树结点序列。

### 回答1：
以下是基于孩子兄弟表存储结构的C代码实现：

#include <stdio.h>
#include <stdlib.h>

#define MAX_NODE_NUM 100   // 最大结点数

typedef char DataType;     // 结点数据类型
typedef struct CSNode {
    DataType data;         // 结点数据
    struct CSNode* firstchild;   // 第一个孩子结点
    struct CSNode* rightsib;     // 右兄弟结点
} CSNode, *CSTree;

CSTree createCSTree();     // 创建树
void preOrder(CSTree t);   // 先根遍历
void postOrder(CSTree t);  // 后根遍历
void freeTree(CSTree t);   // 释放树内存

int main() {
    CSTree tree = createCSTree();
    printf("先根遍历：");
    preOrder(tree);
    printf("\n后根遍历：");
    postOrder(tree);
    freeTree(tree);
    return 0;
}

CSTree createCSTree() {
    CSTree t = NULL;
    char ch;
    scanf("%c", &ch);
    if (ch == '#') {
        t = NULL;
    } else {
        t = (CSTree)malloc(sizeof(CSNode));
        if (t == NULL) {
            printf("内存分配失败！");
            exit(1);
        }
        t->data = ch;
        t->firstchild = createCSTree();
        t->rightsib = createCSTree();
    }
    return t;
}

void preOrder(CSTree t) {
    if (t != NULL) {
        printf("%c ", t->data);
        preOrder(t->firstchild);
        preOrder(t->rightsib);
    }
}

void postOrder(CSTree t) {
    if (t != NULL) {
        postOrder(t->firstchild);
        printf("%c ", t->data);
        postOrder(t->rightsib);
    }
}

void freeTree(CSTree t) {
    if (t != NULL) {
        freeTree(t->firstchild);
        freeTree(t->rightsib);
        free(t);
    }
}

程序执行时，会提示输入树的结点，输入示例：

A
B
D
#
E
H
#
#
C
F
#
G
I
#
J
#
#

输入完成后按下回车键，程序会依次输出先根遍历和后根遍历的结点序列。

### 回答2：
首先，我们需要定义树的孩子兄弟表存储结构：

#include <stdio.h>
#include <stdlib.h>

typedef struct node {
    char data;                     // 节点的数据
    struct node *firstChild;       // 第一个孩子节点
    struct node *nextSibling;      // 下一个兄弟节点
} Node, *Tree;

接下来，我们可以编写递归函数来建立树的孩子兄弟表存储结构：

Tree createTree() {
    Tree root, p, q;

    char ch;
    scanf("%c", &ch);

    if (ch == '#') {
        root = NULL;
    } else {
        root = (Tree)malloc(sizeof(Node));
        root->data = ch;
        root->firstChild = NULL;
        root->nextSibling = NULL;

        p = createTree();
        root->firstChild = p;

        while (p != NULL) {
            q = createTree();
            p->nextSibling = q;
            p = q;
        }
    }

    return root;
}

为了方便观察遍历的结果，我们可以编写打印函数 `print` 来输出遍历的序列：

void print(Tree root) {
    if (root != NULL) {
        printf("%c", root->data);   // 先根遍历
        print(root->firstChild);
        print(root->nextSibling);
        // printf("%c", root->data); // 后根遍历
    }
}

最后，我们在主函数中调用以上函数进行遍历操作：

int main() {
    Tree root;

    printf("请输入树的结构：\n");
    root = createTree();

    printf("先根遍历结果：\n");
    print(root);
    printf("\n");

    // printf("后根遍历结果：\n");
    // print(root);
    // printf("\n");

    return 0;
}

通过以上代码，我们可以从键盘读入字符建立一个深度不小于3层的树的孩子兄弟表存储结构，并分别递归进行先根、后根遍历，并输出相应的遍历结果。

### 回答3：
首先，我们需要定义一个树的孩子兄弟表存储结构的数据类型。可以使用以下结构体来表示一个树节点：

typedef struct TreeNode {
    char data;                  // 节点的数据
    struct TreeNode *firstChild;    // 指向第一个孩子节点
    struct TreeNode *nextSibling;   // 指向下一个兄弟节点
} TreeNode;

接下来，可以编写一个函数来递归建立树的孩子兄弟表存储结构。该函数的逻辑如下：

1. 从键盘读入一个字符。
2. 如果读入的字符为换行符，则返回NULL。
3. 创建一个新的节点，并将读入的字符赋值给节点的data。
4. 使用递归调用来建立节点的孩子和兄弟节点。
5. 返回当前节点。

TreeNode *createTree() {
    char c = getchar();
    if (c == '\n') {
        return NULL;
    }
    
    TreeNode *node = (TreeNode *)malloc(sizeof(TreeNode));
    node->data = c;
    node->firstChild = createTree();
    node->nextSibling = createTree();
    
    return node;
}

有了一个树的孩子兄弟表存储结构后，可以编写递归的先根遍历函数。先根遍历的逻辑如下：

1. 如果当前节点为空，则返回。
2. 输出当前节点的数据。
3. 递归遍历当前节点的孩子节点。
4. 递归遍历当前节点的兄弟节点。

void preOrder(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    
    printf("%c ", root->data);
    preOrder(root->firstChild);
    preOrder(root->nextSibling);
}

类似地，可以编写递归的后根遍历函数。后根遍历的逻辑如下：

1. 如果当前节点为空，则返回。
2. 递归遍历当前节点的孩子节点。
3. 输出当前节点的数据。
4. 递归遍历当前节点的兄弟节点。

void postOrder(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    
    postOrder(root->firstChild);
    printf("%c ", root->data);
    postOrder(root->nextSibling);
}

最后，调用以上函数即可完成先根和后根遍历，并输出相应遍历树节点序列。

int main() {
    printf("请输入树的节点序列：\n");
    TreeNode *root = createTree();
    
    printf("先根遍历的结果为：");
    preOrder(root);
    printf("\n");
    
    printf("后根遍历的结果为：");
    postOrder(root);
    printf("\n");
    
    return 0;
}