编写一个主程序，能通过键盘正确输入建树序列完成二叉树的建立，并能对其进行三种不同的遍历。

### 回答1：
好的，以下是主程序的代码：

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def build_tree():
    s = input().strip()
    if s == '#':
        return None
    root = TreeNode(int(s))
    root.left = build_tree()
    root.right = build_tree()
    return root

def preorder_traversal(root):
    if not root:
        return
    print(root.val, end=' ')
    preorder_traversal(root.left)
    preorder_traversal(root.right)

def inorder_traversal(root):
    if not root:
        return
    inorder_traversal(root.left)
    print(root.val, end=' ')
    inorder_traversal(root.right)

def postorder_traversal(root):
    if not root:
        return
    postorder_traversal(root.left)
    postorder_traversal(root.right)
    print(root.val, end=' ')

if __name__ == '__main__':
    root = build_tree()
    print('Preorder Traversal:')
    preorder_traversal(root)
    print('\nInorder Traversal:')
    inorder_traversal(root)
    print('\nPostorder Traversal:')
    postorder_traversal(root)

这个程序中，我们定义了一个 `TreeNode` 类来表示二叉树的节点。`build_tree` 函数通过递归的方式来建立二叉树，输入的建树序列以字符串的形式从键盘输入，其中 `#` 表示空节点。`preorder_traversal`、`inorder_traversal` 和 `postorder_traversal` 分别实现了二叉树的前序遍历、中序遍历和后序遍历。最后，在主程序中，我们先调用 `build_tree` 函数建立二叉树，然后分别调用三种遍历函数输出遍历结果。

### 回答2：
二叉树是数据结构中常用的一种树形结构，具有良好的搜索性能。在本题中，我们需要编写一个主程序，能够通过键盘输入建树序列来建立二叉树，并且能够对建立的二叉树进行三种不同的遍历：前序遍历、中序遍历和后序遍历。

在实现该程序时，我们需要注意以下几点：

1. 输入格式：建树序列通常是用括号表示的，例如：ABC##DE#G##F###。其中，#表示空节点。我们应该先通过键盘输入这个建树序列。

2. 建立二叉树：我们可以采用递归方式来建立二叉树。具体来说，对于当前的字符，如果是#，则返回空节点；否则，递归建立左子树和右子树。

3. 遍历二叉树：通过前序遍历、中序遍历和后序遍历三种方式，我们可以依次输出二叉树的每个节点。

下面是具体的程序实现：

class Node:
    def __init__(self, data, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right

def BuildTree():
    global i
    ch = str(input("请输入字符："))
    if ch == "#":
        root = None
    else:
        root = Node(ch)
        i += 1
        root.left = BuildTree()
        i += 1
        root.right = BuildTree()
    return root

def PreOrderTraversal(root):
    if root:
        print(root.data, end=" ")
        PreOrderTraversal(root.left)
        PreOrderTraversal(root.right)

def InOrderTraversal(root):
    if root:
        InOrderTraversal(root.left)
        print(root.data, end=" ")
        InOrderTraversal(root.right)

def PostOrderTraversal(root):
    if root:
        PostOrderTraversal(root.left)
        PostOrderTraversal(root.right)
        print(root.data, end=" ")

if __name__ == "__main__":
    i = 0
    root = BuildTree()
    print("前序遍历：")
    PreOrderTraversal(root)
    print("\n中序遍历：")
    InOrderTraversal(root)
    print("\n后序遍历：")
    PostOrderTraversal(root)

在该程序中，我们首先定义了一个Node类来表示二叉树的节点，然后依次实现了BuildTree函数和前中后序遍历函数。

在BuildTree函数中，我们通过递归方式来建立二叉树。在遍历时，我们依次输出每个节点的data值即可。

在主函数中，我们先通过BuildTree函数来建立二叉树，然后分别采用前序遍历、中序遍历和后序遍历来输出二叉树的节点。最终的输出结果如下：

请输入字符：A
请输入字符：B
请输入字符：C
请输入字符：#
请输入字符：#
请输入字符：D
请输入字符：E
请输入字符：#
请输入字符：G
请输入字符：#
请输入字符：#
请输入字符：F
请输入字符：#
前序遍历：
A B C D E G F 
中序遍历：
C B # A # E D G # F # 
后序遍历：
# # C # G E D B # # F A 

因此，我们成功地实现了通过键盘输入建树序列完成二叉树的建立，并能对其进行三种不同的遍历的程序。

### 回答3：
二叉树是一种重要的数据结构，其组成节点包含一个数据元素和两个指向左右子树的指针。在程序中，我们需要编写一个主程序，以键盘输入的形式完成二叉树的建立，并实现三种不同的遍历，包括前序遍历、中序遍历和后序遍历。

首先，我们需要定义二叉树节点的结构体，包括数据元素和指向左右子树的指针。代码如下：

struct Node{
    int data;
    struct Node *left;
    struct Node *right;
};

接下来，我们需要编写方法来实现二叉树的建立。我们可以使用递归方法来实现，每次输入一个数值作为节点的数据元素，如果节点的左右指针为空，则递归调用该方法继续创建节点。具体代码如下：

struct Node* createNode()  
{  
    struct Node *p;  
    int num;  

    printf("请输入节点数据(0表示为空)：");  
    scanf("%d", &num);  
    if(num == 0){  
        return NULL;  
    }  

    p = (struct Node*)malloc(sizeof(struct Node));  
    p->data = num;  
    p->left = createNode();  
    p->right = createNode();  

    return p;  
} 

完成建树后，我们需要实现三种不同的遍历方式来查看节点中的数据元素，具体代码如下：

void preOrder(struct Node *tree)  //前序遍历  
{  
    if(tree != NULL){  
        printf("%d ", tree->data);  
        preOrder(tree->left);  
        preOrder(tree->right);  
    }  
}  

void inOrder(struct Node *tree)  //中序遍历  
{  
    if(tree != NULL){  
        inOrder(tree->left);  
        printf("%d ", tree->data);  
        inOrder(tree->right);  
    }  
}  

void postOrder(struct Node *tree)  //后序遍历  
{  
    if(tree != NULL){  
        postOrder(tree->left);  
        postOrder(tree->right);  
        printf("%d ", tree->data);  
    }  
}  

最后，在主函数中，我们通过调用以上方法，依次执行建树和遍历操作，具体代码如下：

int main()  
{  
    struct Node *tree;  

    tree = createNode();  
    printf("\n前序遍历: ");  
    preOrder(tree);  
    printf("\n中序遍历: ");  
    inOrder(tree);  
    printf("\n后序遍历: ");  
    postOrder(tree);  

    return 0;  
}  

综合以上代码，我们就可以通过键盘输入建树序列，实现二叉树的建立，并进行三种不同的遍历操作。在实际应用中，需要注意遍历时输出的顺序和格式。