建立长度为n的单链表，n>0，删除单链表中等于给定值的元素。数据类型指定为整型。

### 回答1：
首先需要定义一个单链表的结构体，包含一个整型数据域和一个指向下一个节点的指针域。然后，可以通过循环创建一个长度为n的单链表，每次创建一个新节点并将其插入到链表的末尾。

接下来，可以遍历整个链表，查找并删除所有等于给定值的节点。具体实现可以使用两个指针，一个指向当前节点，另一个指向当前节点的前一个节点。如果当前节点的数据域等于给定值，则将前一个节点的指针指向当前节点的下一个节点，然后释放当前节点的内存空间。如果当前节点的数据域不等于给定值，则将两个指针都向后移动一个节点。

最后，需要记得释放链表的头节点的内存空间，并将头节点的指针设为NULL，以避免内存泄漏。

### 回答2：
1. 建立单链表

首先需要了解单链表的结构和建立方法。单链表由一个头结点和若干个数据结点组成，每个结点包含两部分信息：一部分是数据域，用来存储数据；另一部分是指针域，用来指向下一个结点。可以利用结构体来定义单链表的结点数据类型。

代码示例：

typedef struct ListNode {
    int val;
    struct ListNode* next;
} ListNode;

在建立单链表时需要考虑头结点和数据结点的区别。对于头结点来说，它本身不存储数据，只是一个指向第一个数据结点的指针。因此，在建立单链表时需要先创建一个头结点，并将它的指针域指向第一个数据结点。

代码示例：

ListNode* createList(int* nums, int n) {
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    head->next = NULL;
    ListNode* tail = head;
    for (int i = 0; i < n; i++) {
        ListNode* node = (ListNode*)malloc(sizeof(ListNode));
        node->val = nums[i];
        node->next = NULL;
        tail->next = node;
        tail = node;
    }
    return head;
}

在上述代码中，使用传入的数组nums和长度n建立单链表，首先创建一个头结点，然后依次创建数据结点，并将它们加入到链表中。

2. 删除指定元素

接下来考虑如何删除单链表中等于给定值的元素。由于单链表只能从头到尾依次遍历，因此需要遍历整个链表，寻找指定值的结点。

代码示例：

ListNode* removeElements(ListNode* head, int val) {
    ListNode* dummy = (ListNode*)malloc(sizeof(ListNode));
    dummy->next = head;
    ListNode* cur = dummy;

    while (cur->next != NULL) {
        ListNode* next = cur->next;
        if (next->val == val) {
            cur->next = next->next;
            free(next);
        } else {
            cur = cur->next;
        }
    }

    return dummy->next;
}

在上述代码中，首先创建一个虚拟头结点，它的指针域指向原来的头结点。然后创建一个游标指针cur，初始化为虚拟头结点。游标指针会一直遍历整个链表，寻找需要删除的结点。如果当前结点的值等于给定值，就删除该结点；否则就将游标指针向后移动。最后返回虚拟头结点的指针域，即原来的头结点。

3. 总结

建立长度为n的单链表，可以使用数组和循环来创建链表节点，并将它们相互链接起来。为了删除指定元素，可以利用游标指针和虚拟头结点来遍历整个链表，寻找指定值的结点并删除它。

### 回答3：
单链表是一种经典的数据结构，由若干个节点（Node）组成，每个节点包含两个部分，一个是存储数据的域（data），另一个是存储指向下一个节点的指针（next）。通过next指针，形成了一条链，使得节点之间形成了连接。

我们可以通过遍历单链表的方式，找到需要删除等于给定值的元素。具体的操作方法是，从单链表的第一个节点开始遍历，如果节点中存储的数据等于给定值，则删除该节点。如果删除的是第一个节点，需要特殊处理。如果删除的是中间或末尾节点，需要让上一个节点的next指针指向下一个节点。

下面是一个建立长度为n的单链表并删除指定值元素的实现方法：

1. 定义节点结构体

struct Node {
    int data;
    Node* next;
};

2. 建立长度为n的单链表

Node* createList(int n) {
    Node* head = new Node();
    Node* tail = head;
    for (int i = 0; i < n; ++i) {
        Node* node = new Node();
        cin >> node->data;
        tail->next = node;
        tail = node;
    }
    return head;
}

3. 删除指定值元素

void deleteValue(Node* head, int value) {
    Node* p = head;
    Node* q = p->next;
    while (q) {
        if (q->data == value) {
            p->next = q->next;
            delete q;
            q = p->next;
        } else {
            p = q;
            q = q->next;
        }
    }
}

完整代码如下：

#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* next;
};

Node* createList(int n) {
    Node* head = new Node();
    Node* tail = head;
    for (int i = 0; i < n; ++i) {
        Node* node = new Node();
        cin >> node->data;
        tail->next = node;
        tail = node;
    }
    return head;
}

void deleteValue(Node* head, int value) {
    Node* p = head;
    Node* q = p->next;
    while (q) {
        if (q->data == value) {
            p->next = q->next;
            delete q;
            q = p->next;
        } else {
            p = q;
            q = q->next;
        }
    }
}

void printList(Node* head) {
    Node* p = head->next;
    while (p) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

int main() {
    int n, value;
    cin >> n >> value;
    Node* head = createList(n);
    deleteValue(head, value);
    printList(head);
    return 0;
}

以上就是建立长度为n的单链表并删除指定值元素的实现方法。需要注意的是，如果单链表中存在重复的指定值元素，都会被删除。另外，该方法的时间复杂度为O(n)，空间复杂度为O(1)。