建立一棵用二叉链表方式存储的二叉树，并实现对其进行先序、中序、后序三种方法遍历，输出遍历结果。

### 回答1：
题目要求我们实现对一个二叉树的前序、中序、后序三种遍历方式，并输出其遍历结果。

实现方法如下：

1. 前序遍历：遍历根节点，然后递归遍历左子树，最后递归遍历右子树。输出的结果即为先遍历根节点，再遍历左子树，最后遍历右子树的顺序。

2. 中序遍历：先递归遍历左子树，然后遍历根节点，最后递归遍历右子树。输出的结果即为先遍历左子树，再遍历根节点，最后遍历右子树的顺序。

3. 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后遍历根节点。输出的结果即为先遍历左子树，再遍历右子树，最后遍历根节点的顺序。

代码实现如下：

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

class Solution:
    def __init__(self):
        self.res = []

    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        self.res.append(root.val)
        self.preorderTraversal(root.left)
        self.preorderTraversal(root.right)
        return self.res
    
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        self.inorderTraversal(root.left)
        self.res.append(root.val)
        self.inorderTraversal(root.right)
        return self.res
    
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        self.postorderTraversal(root.left)
        self.postorderTraversal(root.right)
        self.res.append(root.val)
        return self.res

其中，TreeNode类是二叉树的节点定义，Solution类中的三个方法分别对应前序、中序、后序遍历方式。

至此，题目要求的要建立一棵用二叉链表方式存储的二叉树，并实现其前序遍历、中序遍历、后序遍历三种方式的遍历以及输出遍历结果的任务已经完成。

### 回答2：
要建立一棵用二叉链表方式存储的二叉树，我们需要定义一个节点结构体，包含节点的值、指向左子树的指针和指向右子树的指针。

然后，我们可以选择手动输入节点值或者通过随机生成数字实现节点值的赋值。接下来，我们需要通过读入的数据依次建立二叉树。对于每一个节点，我们需要判断其是否有左右子节点，有的话将其相应的指针指向新建的节点，没有则不进行改动。

建立好二叉树之后，我们需要实现三种方法遍历二叉树——先序遍历、中序遍历和后序遍历。这些遍历方式都是利用递归实现的。具体来说，先序遍历顺序为根节点、左子树、右子树；中序遍历顺序为左子树、根节点、右子树；后序遍历顺序为左子树、右子树、根节点。这些遍历方式可以用大致相同的代码框架实现，只是访问节点的顺序不同，具体代码如下：

//定义节点结构体
struct Node {
int data;
Node *left, *right;
};

//先序遍历
void preorderTraversal(Node* node) {
if (node) {
cout << node->data << " ";
preorderTraversal(node->left);
preorderTraversal(node->right);
}
}

//中序遍历
void inorderTraversal(Node* node) {
if (node) {
inorderTraversal(node->left);
cout << node->data << " ";
inorderTraversal(node->right);
}
}

//后序遍历
void postorderTraversal(Node* node) {
if (node) {
postorderTraversal(node->left);
postorderTraversal(node->right);
cout << node->data << " ";
}
}

最终，输出遍历结果即可完成程序运行。

### 回答3：
二叉树是一种非常重要的数据结构，我们可以用它表示各种各样的问题，例如数学表达式、文件系统、网络拓扑结构等等。在计算机科学中，通常用二叉链表的方式来存储二叉树。

二叉链表就是将二叉树的每一个节点都看作一个对象，该对象包含三个属性：data（存储节点的值）、left（存储节点的左孩子）、right（存储节点的右孩子）。这样，我们就通过对象之间的链接来建立二叉树的结构。

下面，让我们来建立一个用二叉链表方式存储的二叉树。我们先定义一个节点类：

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

接下来，我们来定义一个二叉树类：

class BinaryTree:
    def __init__(self):
        self.root = None  # 根节点初始化为None

    def insert(self, value):
        node = Node(value)

        if self.root is None:
            self.root = node  # 如果根节点为空，直接赋值为新节点
        else:
            queue = [self.root]
            while queue:
                curr = queue.pop(0)
                if curr.left is None:
                    curr.left = node
                    return
                elif curr.right is None:
                    curr.right = node
                    return
                else:
                    queue.append(curr.left)
                    queue.append(curr.right)

在上面的代码中，我们定义了一个insert方法用于向二叉树中插入节点。具体实现是，先创建一个新节点，然后遍历二叉树寻找空闲的位置插入新节点。我们使用一个队列来实现层次遍历（BFS）。

接下来，我们来实现三种不同的遍历算法。

先序遍历（Pre-order Traversal）

先序遍历的顺序是：先访问根节点，再分别访问左右子树。

def pre_order(self, node):
    if node is not None:
        print(node.data, end=" ")
        self.pre_order(node.left)
        self.pre_order(node.right)

中序遍历（In-order Traversal）

中序遍历的顺序是：先访问左子树，再访问根节点，最后访问右子树。

def in_order(self, node):
    if node is not None:
        self.in_order(node.left)
        print(node.data, end=" ")
        self.in_order(node.right)

后序遍历（Post-order Traversal）

后序遍历的顺序是：先访问左右子树，再访问根节点。

def post_order(self, node):
    if node is not None:
        self.post_order(node.left)
        self.post_order(node.right)
        print(node.data, end=" ")

最后，我们可以进行测试：

tree = BinaryTree()
tree.insert(1)
tree.insert(2)
tree.insert(3)
tree.insert(4)
tree.insert(5)
tree.insert(6)
tree.insert(7)

print("Pre-order Traversal:")
tree.pre_order(tree.root)

print("\nIn-order Traversal:")
tree.in_order(tree.root)

print("\nPost-order Traversal:")
tree.post_order(tree.root)

输出结果如下：

Pre-order Traversal:
1 2 4 5 3 6 7 
In-order Traversal:
4 2 5 1 6 3 7 
Post-order Traversal:
4 5 2 6 7 3 1 

可以看到，我们实现了三种不同的遍历算法，并输出了对应的遍历结果。这样，我们就建立了一个使用二叉链表存储的二叉树，并可以对其进行遍历。