1、运行时从键盘输入先序序列，创建对应二叉树t，然后对t进行非递归中序遍历、递归后序遍历和层序遍历。

### 回答1：
首先，我们需要了解一下二叉树的基本概念。二叉树是一种树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树的遍历方式有三种：前序遍历、中序遍历和后序遍历。

1、从键盘输入先序序列，创建对应二叉树t

我们可以通过递归的方式来创建二叉树。具体步骤如下：

1）从键盘输入一个字符，如果该字符为#，则表示该节点为空，返回NULL；否则，创建一个新节点，并将该字符存储在节点中。

2）递归创建左子树，将返回的节点作为当前节点的左子节点。

3）递归创建右子树，将返回的节点作为当前节点的右子节点。

4）返回当前节点。

代码如下：

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

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

TreeNode* createTree() {
    char c;
    scanf("%c", &c);
    if (c == '#') {
        return NULL;
    }
    TreeNode *root = (TreeNode*)malloc(sizeof(TreeNode));
    root->data = c;
    root->left = createTree();
    root->right = createTree();
    return root;
}

2、对t进行非递归中序遍历

非递归中序遍历需要借助栈来实现。具体步骤如下：

1）从根节点开始，将其所有左子节点依次入栈。

2）弹出栈顶节点，访问该节点。

3）如果该节点存在右子节点，则将其右子节点入栈。

4）重复步骤2和3，直到栈为空。

代码如下：

void inorderTraversal(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    TreeNode *stack[100];
    int top = -1;
    TreeNode *p = root;
    while (p != NULL || top != -1) {
        while (p != NULL) {
            stack[++top] = p;
            p = p->left;
        }
        if (top != -1) {
            p = stack[top--];
            printf("%c ", p->data);
            p = p->right;
        }
    }
}

3、递归后序遍历

递归后序遍历的顺序是先访问左子树，再访问右子树，最后访问根节点。代码如下：

void postorderTraversal(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    printf("%c ", root->data);
}

4、层序遍历

层序遍历需要借助队列来实现。具体步骤如下：

1）将根节点入队。

2）从队列中取出一个节点，访问该节点。

3）将该节点的左子节点和右子节点依次入队。

4）重复步骤2和3，直到队列为空。

代码如下：

void levelTraversal(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    TreeNode *queue[100];
    int front = , rear = ;
    queue[rear++] = root;
    while (front != rear) {
        TreeNode *p = queue[front++];
        printf("%c ", p->data);
        if (p->left != NULL) {
            queue[rear++] = p->left;
        }
        if (p->right != NULL) {
            queue[rear++] = p->right;
        }
    }
}

完整代码如下：

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

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

TreeNode* createTree() {
    char c;
    scanf("%c", &c);
    if (c == '#') {
        return NULL;
    }
    TreeNode *root = (TreeNode*)malloc(sizeof(TreeNode));
    root->data = c;
    root->left = createTree();
    root->right = createTree();
    return root;
}

void inorderTraversal(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    TreeNode *stack[100];
    int top = -1;
    TreeNode *p = root;
    while (p != NULL || top != -1) {
        while (p != NULL) {
            stack[++top] = p;
            p = p->left;
        }
        if (top != -1) {
            p = stack[top--];
            printf("%c ", p->data);
            p = p->right;
        }
    }
}

void postorderTraversal(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    printf("%c ", root->data);
}

void levelTraversal(TreeNode *root) {
    if (root == NULL) {
        return;
    }
    TreeNode *queue[100];
    int front = , rear = ;
    queue[rear++] = root;
    while (front != rear) {
        TreeNode *p = queue[front++];
        printf("%c ", p->data);
        if (p->left != NULL) {
            queue[rear++] = p->left;
        }
        if (p->right != NULL) {
            queue[rear++] = p->right;
        }
    }
}

int main() {
    TreeNode *root = createTree();
    printf("非递归中序遍历：");
    inorderTraversal(root);
    printf("\n");
    printf("递归后序遍历：");
    postorderTraversal(root);
    printf("\n");
    printf("层序遍历：");
    levelTraversal(root);
    printf("\n");
    return ;
}

### 回答2：
运行时从键盘输入先序序列，创建对应二叉树t，可以使用递归方法，也可以使用非递归方法。

先以递归方法为例，实现创建二叉树的过程：

1. 从输入读取先序序列，如果输入字符为“#”，说明该节点为空，返回NULL。
2. 否则，新建一个节点，将输入字符存储在该节点中，然后递归调用创建左子树，再递归调用创建右子树。
3. 返回新建的节点。

代码实现如下：

#include<iostream>
using namespace std;
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
TreeNode* createTree() {
    char ch;
    cin >> ch;
    if (ch == '#') return NULL;
    TreeNode* root = new TreeNode(ch - '0');
    root->left = createTree();
    root->right = createTree();
    return root;
}

然后，针对创建好的二叉树t，实现非递归中序遍历、递归后序遍历和层序遍历。

首先，非递归中序遍历采用栈来辅助实现，遍历过程如下：

1. 从根节点开始，将节点压入栈中。
2. 循环执行以下操作：如果当前节点不为空，将其左子树节点压入栈中，否则弹出栈顶元素并输出，并将当前节点切换为栈顶元素的右子树节点。
3. 当栈为空时，遍历结束。

代码实现如下：

void inorderTraversal(TreeNode* root) {
    stack<TreeNode*> stk;
    while (!stk.empty() || root != NULL) {
        if (root != NULL) {
            stk.push(root);
            root = root->left;
        }
        else {
            root = stk.top();
            stk.pop();
            cout << root->val << " ";
            root = root->right;
        }
    }
    cout << endl;
}

其次，递归后序遍历的过程较为简单，代码实现如下：

void postorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    cout << root->val << " ";
    return;
}

最后，层序遍历采用队列来辅助实现，遍历过程如下：

1. 从根节点开始，将节点加入队列中。
2. 循环执行以下操作，直到队列为空：弹出队首元素，将节点值输出，然后将其左、右子节点加入队列。

代码实现如下：

void levelOrderTraversal(TreeNode* root) {
    queue<TreeNode*> q;
    if (root) q.push(root);
    while (!q.empty()) {
        TreeNode* cur = q.front();
        q.pop();
        cout << cur->val << " ";
        if (cur->left) q.push(cur->left);
        if (cur->right) q.push(cur->right);
    }
    cout << endl;
}

这样，就实现了对创建好的二叉树t的非递归中序遍历、递归后序遍历和层序遍历。

### 回答3：
题目要求实现对二叉树的非递归中序遍历、递归后序遍历和层序遍历，而二叉树的建立需要先根据先序序列构建出对应的二叉树t，因此进入问题的对下一步操作将是基于已经成功构建的二叉树t来实现的。

1、根据先序序列构建二叉树

先序遍历的顺序是：根节点-左子树-右子树。因此，我们可以首先读取根节点的值，然后判断是否为叶子节点。如果不是，则继续读取下一个值作为根节点的左子节点，并同样递归构建左子树。如果左子树构建完成，则根据刚才的方法递归右子树。最终构建完成整个二叉树。

2、非递归中序遍历

中序遍历的顺序是：左子树-根节点-右子树。我们可以采用栈这种数据结构来实现非递归中序遍历，具体实现方法如下：

- 将根节点加入栈中，并将其左子树遍历的左儿子加入栈中（整个根节点的左子树都会被依次压入栈中）
- 依次弹出栈中的元素，输出其值。若该节点存在右子树，则将其右子节点压入栈中。

因为左子树的所有元素都会先被压入栈中，因此弹出的顺序就是中序遍历的顺序。

3、递归后序遍历

后序遍历的顺序是：左子树-右子树-根节点。在递归后序遍历时，我们可以先对左子树进行递归，再对右子树进行递归，最后再输出根节点。因此，递归函数应当具有如下形式：

void PostorderTraversal(TreeNode* root){
if(!root) return;

PostorderTraversal(root -> left);
PostorderTraversal(root -> right);
cout << root -> val << " ";
}

其中，root即为当前节点。

4、层序遍历

层序遍历的顺序是：按照层次依次输出节点的值。我们可以使用队列这种数据结构来实现层序遍历，具体实现方法如下：

- 将根节点加入队列中
- 依次读取队列中的元素，输出其值，并将其左子树和右子树加入队尾。

由于队列的先进先出特点，因此元素的访问顺序就是按照层次逐一访问的。