建立一棵用二叉链表方式存储的二叉树，并对其进行遍历（先序、中序和后序），打印输出遍历结果。

### 回答1：
建立二叉链表方式存储的二叉树，需要定义一个二叉树节点结构体，包含数据域和左右子树指针域。然后按照二叉树的特点，递归地创建左右子树，直到叶子节点。

遍历二叉树有三种方式：先序遍历、中序遍历和后序遍历。先序遍历是先访问根节点，再访问左子树和右子树；中序遍历是先访问左子树，再访问根节点和右子树；后序遍历是先访问左子树和右子树，再访问根节点。

以下是建立二叉链表方式存储的二叉树，并对其进行先序、中序和后序遍历的示例代码：

#include <iostream>
using namespace std;

// 二叉树节点结构体
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 创建二叉树
TreeNode* createTree() {
    int val;
    cin >> val;
    if (val == -1) {  // -1表示空节点
        return NULL;
    }
    TreeNode* root = new TreeNode(val);
    root->left = createTree();
    root->right = createTree();
    return root;
}

// 先序遍历
void preOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    cout << root->val << " ";
    preOrder(root->left);
    preOrder(root->right);
}

// 中序遍历
void inOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inOrder(root->left);
    cout << root->val << " ";
    inOrder(root->right);
}

// 后序遍历
void postOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postOrder(root->left);
    postOrder(root->right);
    cout << root->val << " ";
}

int main() {
    TreeNode* root = createTree();
    cout << "先序遍历结果：";
    preOrder(root);
    cout << endl;
    cout << "中序遍历结果：";
    inOrder(root);
    cout << endl;
    cout << "后序遍历结果：";
    postOrder(root);
    cout << endl;
    return 0;
}

输入样例：

1 2 -1 -1 3 4 -1 -1 5 -1 -1

输出样例：

先序遍历结果：1 2 3 4 5 
中序遍历结果：2 1 4 3 5 
后序遍历结果：2 4 5 3 1 

### 回答2：
二叉树是一种重要的数据结构，广泛应用于各种常见算法中。在计算机科学中，我们通常使用二叉链表来存储二叉树。这种存储方式需要为每个节点定义两个指针，一个指向左子树，一个指向右子树。

要建立一个二叉树，我们可以通过以下步骤来实现：

1. 定义二叉树节点数据结构，包括节点值以及左右子节点指针。

2. 初始化二叉树根节点，将其置为空。

3. 依次插入每个节点，将其添加到二叉树中。

4. 对二叉树进行遍历，输出所得的节点值。

具体的建立二叉树的过程涉及到对节点指针的操作，需要使用递归算法。在递归过程中，我们首先判断当前节点是否为空，如果为空，则将新节点插入到该位置；否则，如果新节点的值小于当前节点的值，就插入到当前节点的左子树中；否则，插入到当前节点的右子树中。经过递归操作，最终可以建立一棵完整的二叉树。

接下来，对该二叉树进行遍历。树的遍历就是按照一定顺序依次访问二叉树中的每个节点。遍历可以分为先序遍历、中序遍历和后序遍历三种方式：

1. 先序遍历：首先访问根节点，然后递归遍历左子树，最后递归遍历右子树。

2. 中序遍历：先递归遍历左子树，然后访问根节点，最后递归遍历右子树。

3. 后序遍历：先递归遍历左子树，然后递归遍历右子树，最后访问根节点。

通过以上遍历方式，输出的结果就是在遍历过程中得到的节点值。

综上所述，建立一棵用二叉链表方式存储的二叉树，可以通过递归算法来实现，然后使用先序、中序和后序三种方式对其进行遍历。这样我们就可以完成二叉树的建立与遍历输出。

### 回答3：
二叉树是一种重要的数据结构，它在计算机科学中有着广泛的应用。存储二叉树的方式有很多种，其中二叉链表方式是一种比较常见的存储方法。本文将介绍如何用二叉链表方式实现二叉树，并对其进行遍历。

二叉链表方式存储二叉树的结构

用二叉链表方式存储二叉树，需要定义一个二叉树结点的结构体，该结构体有三个成员变量：

1. data：存储结点的数据
2. left：指向左子树的指针
3. right：指向右子树的指针

当一个结点没有子树时，对应的指针为空。

定义结构体如下：

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

用二叉链表方式存储二叉树时，需要定义一个根结点指针，指向根节点，根节点不包含任何数据。

TreeNode* root = new TreeNode();

创建二叉树

创建二叉树的过程就是不断在二叉树中插入结点的过程。假设我们要构建如下的二叉树：

       1
     /   \
    2     3
   / \   / \
  4   5 6   7

首先，创建根结点，并将根结点指针指向根节点。

TreeNode* root = new TreeNode();

然后，依次插入其他结点，使它们成为根结点的左子树或右子树。具体做法是：

- 遍历二叉树，找到一个结点的左子树（或右子树）为空时，插入结点到该位置

插入结点的过程，可以用递归的方法，从根结点开始递归向下查找。具体代码如下：

void insert(TreeNode* node, int val) {
    if (node->data == NULL) {
        node->data = val;
    } else if (val < node->data) {
        if (node->left == NULL) {
            node->left = new TreeNode();
        }
        insert(node->left, val);
    } else {
        if (node->right == NULL) {
            node->right = new TreeNode();
        }
        insert(node->right, val);
    }
}

最终，实现如下：

int main() {
    TreeNode* root = new TreeNode();
    insert(root, 1);
    insert(root, 2);
    insert(root, 3);
    insert(root, 4);
    insert(root, 5);
    insert(root, 6);
    insert(root, 7);
    ...

遍历二叉树

遍历二叉树是指按照一定的顺序，依次访问树中的每个结点。二叉树的遍历方式有三种：先序遍历、中序遍历和后序遍历。

先序遍历

先序遍历的顺序是：根结点 -> 左子树 -> 右子树。具体做法是：

- 先访问根结点
- 递归遍历左子树
- 递归遍历右子树

递归的终止条件是：遇到空结点时，返回。

代码如下：

void preorder(TreeNode* node) {
    if (node == NULL) {
        return;
    }
    cout << node->data << " ";
    preorder(node->left);
    preorder(node->right);
}

中序遍历

中序遍历的顺序是：左子树 -> 根结点 -> 右子树。具体做法是：

- 递归遍历左子树
- 访问根结点
- 递归遍历右子树

递归的终止条件是：遇到空结点时，返回。

代码如下：

void inorder(TreeNode* node) {
    if (node == NULL) {
        return;
    }
    inorder(node->left);
    cout << node->data << " ";
    inorder(node->right);
}

后序遍历

后序遍历的顺序是：左子树 -> 右子树 -> 根结点。具体做法是：

- 递归遍历左子树
- 递归遍历右子树
- 访问根结点

递归的终止条件是：遇到空结点时，返回。

代码如下：

void postorder(TreeNode* node) {
    if (node == NULL) {
        return;
    }
    postorder(node->left);
    postorder(node->right);
    cout << node->data << " ";
}

打印输出遍历结果

最终的完整代码如下：

#include <iostream>

using namespace std;

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

void insert(TreeNode* node, int val) {
    if (node->data == NULL) {
        node->data = val;
    } else if (val < node->data) {
        if (node->left == NULL) {
            node->left = new TreeNode();
        }
        insert(node->left, val);
    } else {
        if (node->right == NULL) {
            node->right = new TreeNode();
        }
        insert(node->right, val);
    }
}

void preorder(TreeNode* node) {
    if (node == NULL) {
        return;
    }
    cout << node->data << " ";
    preorder(node->left);
    preorder(node->right);
}

void inorder(TreeNode* node) {
    if (node == NULL) {
        return;
    }
    inorder(node->left);
    cout << node->data << " ";
    inorder(node->right);
}

void postorder(TreeNode* node) {
    if (node == NULL) {
        return;
    }
    postorder(node->left);
    postorder(node->right);
    cout << node->data << " ";
}

int main() {
    TreeNode* root = new TreeNode();
    insert(root, 1);
    insert(root, 2);
    insert(root, 3);
    insert(root, 4);
    insert(root, 5);
    insert(root, 6);
    insert(root, 7);

    cout << "先序遍历结果：" << endl;
    preorder(root);
    cout << endl;

    cout << "中序遍历结果：" << endl;
    inorder(root);
    cout << endl;

    cout << "后序遍历结果：" << endl;
    postorder(root);
    cout << endl;

    return 0;
}

其中，insert()函数用来插入结点，preorder()、inorder()、postorder()函数分别用来进行先序遍历、中序遍历和后序遍历。输出结果如下：

先序遍历结果：
1 2 4 5 3 6 7 
中序遍历结果：
4 2 5 1 6 3 7 
后序遍历结果：
4 5 2 6 7 3 1 

可以看到，先序遍历结果为：1->2->4->5->3->6->7；中序遍历结果为：4->2->5->1->6->3->7；后序遍历结果为：4->5->2->6->7->3->1。通过遍历，我们可以访问并处理二叉树中的所有结点，从而实现各种算法和应用。