以二叉链表表示二叉树，建立一颗二叉树

### 回答1：
建立二叉树的步骤如下：

1. 定义二叉链表结构体，包括数据域和左右子树指针。

2. 创建根节点，并为其赋值。

3. 创建左子树和右子树，分别为其赋值，并将其指针赋给根节点的左右子树指针。

4. 对左子树和右子树进行递归操作，直到所有节点都创建完毕。

5. 最后返回根节点即可。

示例代码如下：

#include <iostream>
using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* buildTree() {
    int val;
    cin >> val;
    if (val == -1) { // 如果输入-1，表示该节点为空
        return NULL;
    }
    TreeNode* root = new TreeNode(val); // 创建根节点
    root->left = buildTree(); // 创建左子树
    root->right = buildTree(); // 创建右子树
    return root;
}

int main() {
    TreeNode* root = buildTree(); // 建立二叉树
    return ;
}

### 回答2：
首先，我们需要明确二叉链表是用链表的形式来表示二叉树的数据结构。每个节点分别有三个指针，左子节点指针、右子节点指针和父节点指针。通过这种方式，可以非常方便地对二叉树进行增删改查等操作。

建立一颗二叉树的过程可分为以下几个步骤：

1. 定义节点结构体

我们需要定义一个二叉树节点的结构体，包含节点值、左子节点指针、右子节点指针和父节点指针等信息。如下所示：

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

2. 定义根节点

我们需要定义一颗空树，即根节点为空指针。如下所示：

Node *root = NULL;

3. 添加节点

通过递归的方式添加节点，对于每一个要插入的节点，首先需要检查根节点是否为空，如果为空则将根节点指向新节点；否则，判断当前节点值和根节点值的大小关系，并决定将该节点添加到左子树还是右子树中。代码如下：

void insert(Node *&root, int data) {
    if (root == NULL) {
        root = new Node();
        root->data = data;
        root->left = NULL;
        root->right = NULL;
        root->parent = NULL;
        return;
    }
 
    if (data < root->data) {
        if (root->left == NULL) {
            Node *p = new Node();
            p->data = data;
            p->left = NULL;
            p->right = NULL;
            p->parent = root;
            root->left = p;
            return;
        } else {
            insert(root->left, data);
        }
    } else if (data > root->data) {
        if (root->right == NULL) {
            Node *p = new Node();
            p->data = data;
            p->left = NULL;
            p->right = NULL;
            p->parent = root;
            root->right = p;
            return;
        } else {
            insert(root->right, data);
        }
    }
}

4. 遍历二叉树

二叉树有三种遍历方式，包括前序遍历、中序遍历和后序遍历。以下是各种遍历方式的代码实现：

前序遍历：

void preOrder(Node *root) {
    if (root == NULL) {
        return;
    }
 
    cout << root->data << " ";
    preOrder(root->left);
    preOrder(root->right);
}

中序遍历：

void inOrder(Node *root) {
    if (root == NULL) {
        return;
    }
 
    inOrder(root->left);
    cout << root->data << " ";
    inOrder(root->right);
}

后序遍历：

void postOrder(Node *root) {
    if (root == NULL) {
        return;
    }
 
    postOrder(root->left);
    postOrder(root->right);
    cout << root->data << " ";
}

至此，我们已经成功地建立了一颗二叉树，并且完成了对二叉树的插入和遍历等操作。

### 回答3：
二叉链表表示二叉树是一种常用的数据结构。它是一种链式存储结构，每个节点有三个指针域，其中一个指向它的左子树，一个指向它的右子树，另一个指向它的父节点。这种数据结构可以方便地描述二叉树的结构，同时支持常见的二叉树操作，如遍历和查找。

建立一个二叉树，首先需要确定二叉树的结构和节点关系。对于一个给定的二叉树，可以通过以下步骤建立它的二叉链表表示：

1. 定义二叉链表节点结构

二叉链表的节点结构包括三个指针域，分别指向左子树、右子树和父节点。同时还包括一个数据域，用于存储节点的值。

typedef struct BinaryTreeNode
{
int data; // 数据域
struct BinaryTreeNode *left; // 左子树指针
struct BinaryTreeNode *right; // 右子树指针
struct BinaryTreeNode *parent; // 父节点指针
} BinaryTreeNode, *BinaryTree;

2. 建立二叉树

建立二叉树的方法有很多种，例如前序遍历、中序遍历和后序遍历等。这里以前序遍历为例，例如下面的二叉树：

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

先序遍历的序列为：1, 2, 4, 5, 7, 3, 6。

通过前序遍历的序列可以建立二叉树。从序列的第一个元素开始，若当前元素不为 NULL，则新建一个节点并将当前元素放入节点中。然后递归调用建树函数建立左子树和右子树，直到序列中元素全部用完或遇到 NULL。

BinaryTreeNode *create_binary_tree(int *preorder, int n)
{
static int i = 0; // 静态变量，记录遍历到的序列下标
BinaryTreeNode *root = NULL;
if (i < n && preorder[i] != -1) // 若当前元素不为空
{
root = (BinaryTreeNode *) malloc(sizeof(BinaryTreeNode));
root->data = preorder[i++];
root->left = create_binary_tree(preorder, n);
if (root->left != NULL)
{
root->left->parent = root; // 左子树指向父节点
}
root->right = create_binary_tree(preorder, n);
if (root->right != NULL)
{
root->right->parent = root; // 右子树指向父节点
}
}
else
{
i++; // 当前节点为空，跳过
}
return root;
}

3. 遍历二叉树

由于二叉树的每个节点都有左子树和右子树指针，因此可以使用递归的方法遍历整个二叉树。遍历的顺序有三种：前序遍历、中序遍历和后序遍历。这里以前序遍历为例，遍历整个二叉树，并输出每个节点的值。

void pre_order_traversal(BinaryTreeNode *root)
{
if (root != NULL)
{
printf("%d ", root->data); // 输出根节点
pre_order_traversal(root->left); // 遍历左子树
pre_order_traversal(root->right); // 遍历右子树
}
}

综上所述，使用二叉链表表示二叉树可以方便地描述二叉树的结构，并支持常见的二叉树操作。建立二叉树的过程可以通过递归的方法实现，遍历二叉树也可以使用递归实现，使程序结构清晰、逻辑严谨。