描述\n请你实现一个链表。\n操作：\ninsert x y：将yy加入链表，插入在第一个值为xx的结点之前。若链表中不存在值为xx的结点，则插入在链表末尾。保证xx,yy为int型整数。\ndelete x

### 回答1：
请实现一个链表。操作：insert x y：将yy加入链表，插入在第一个值为xx的节点之前。若链表中不存在值为xx的结点，则插入在链表末尾。保证xx,yy为int类型整数。delete x：删除链表中所有值为x的节点。

### 回答2：
链表是一种非常常见的数据结构，可以用来存储一连串的数据，并且支持插入、删除等操作。

首先，我们需要定义链表的节点结构体，它包括一个整数值和一个指向下一个节点的指针，如下所示：

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(NULL) {}
};

其中，val是节点存储的整数值，next是指向下一个节点的指针。

接下来，我们可以定义链表类，其中包含插入和删除操作。插入操作会将一个新节点插入到链表中，如果链表中已经有值为x的节点，则将新节点插入到该节点之前，否则将新节点插入到链表末尾。删除操作会删除值为x的节点，如果链表中没有值为x的节点，则不做任何操作。

具体代码实现如下：

class MyLinkedList {
public:
    /** Initialize your data structure here. */
    MyLinkedList() {
        head = NULL;
    }
    
    /** Insert a node of value val before the first element
     *  of the list whose node value equals to key.
     *  If there is no such node, append val to the back of the list.
     */
    void insert(int key, int val) {
        if (head == NULL) {
            head = new ListNode(val);
            return;
        }
        
        ListNode* cur = head;
        ListNode* pre = NULL;
        
        while (cur != NULL) {
            if (cur->val == key) {
                ListNode* newNode = new ListNode(val);
                if (pre == NULL) {
                    newNode->next = head;
                    head = newNode;
                } else {
                    newNode->next = pre->next;
                    pre->next = newNode;
                }
                return;
            }
            
            pre = cur;
            cur = cur->next;
        }
        
        pre->next = new ListNode(val);
    }
    
    /** Delete the node that has value x. */
    void deleteNode(int x) {
        if (head == NULL) {
            return;
        }
        
        if (head->val == x) {
            ListNode* tmp = head;
            head = head->next;
            delete tmp;
            return;
        }
        
        ListNode* pre = head;
        ListNode* cur = pre->next;
        
        while (cur != NULL) {
            if (cur->val == x) {
                pre->next = cur->next;
                delete cur;
                return;
            }
            pre = cur;
            cur = cur->next;
        }
    }
    
private:
    ListNode* head;
};

在这里，我们使用了一个指针来指向链表的头节点。插入操作和删除操作都需要遍历链表，找到对应的节点进行操作。在插入节点时，需要注意如果新节点插入到链表开头，则需要更新head指针。

以上就是实现链表的基本操作，包括插入和删除。链表是非常常见的数据结构，在很多算法和编程题中都有使用。掌握链表的基本操作，可以帮助我们更好地理解一些算法和数据结构的内容。

### 回答3：
链表（Linked list）是一种数据结构，它由一系列结点组成，每个结点包含数据域和指向下一个结点的指针。链表中的元素通过指针进行连接，因此它不要求存储空间连续，插入和删除操作也相对容易，但是访问元素时需要遍历链表。

以下是链表的实现，包括插入和删除操作：

首先定义一个结构体来表示链表的结点：

struct Node {
    int val;
    Node* next;
    Node(int x) : val(x), next(NULL) {}
};

链表操作函数：

class LinkedList {
private:
    Node* head;
public:
    LinkedList() { head = nullptr; }
    // 插入
    void insert(int x, int y) {
        if (head == nullptr) {
            head = new Node(y);
            return;
        }
        Node* node = head;
        while (node->next != nullptr && node->next->val != x) {
            node = node->next;
        }
        Node* new_node = new Node(y);
        if (node->next == nullptr) {
            node->next = new_node;
        } else {
            new_node->next = node->next;
            node->next = new_node;
        }
    }
    // 删除
    void remove(int x) {
        if (head == nullptr) return;
        if (head->val == x) {
            head = head->next;
            return;
        }
        Node* node = head;
        while (node->next != nullptr && node->next->val != x) {
            node = node->next;
        }
        if (node->next != nullptr) {
            node->next = node->next->next;
        }
    }
};

在插入操作中，从头结点开始遍历链表，当找到值为 xx 的结点或者链表遍历结束时，将新结点插入到当前结点之前。

在删除操作中，同样从头结点开始遍历链表，当找到值为 xx 的结点或者链表遍历结束时，将当前结点指向下下个结点，即删除当前结点。

该链表的时间复杂度为 O(n)，其中n为链表长度，插入和删除操作的平均时间复杂度为 O(n/2)。