请编写程序实现单链表插入、删除结点等基本算法。给定一个单链表和一系列插入、删除结点的操作序列，输出实施上述操作后的链表。单链表数据域值为整数

### 回答1：
很高兴为您提供单链表插入、删除结点等基本算法的代码实现。以下是示例代码：

// 定义单链表结点
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};

// 插入结点
void insertNode(ListNode* &head, int val) {
ListNode* newNode = new ListNode(val);
if (head == NULL) {
head = newNode;
} else {
ListNode* p = head;
while (p->next != NULL) {
p = p->next;
}
p->next = newNode;
}
}

// 删除结点
void deleteNode(ListNode* &head, int val) {
if (head == NULL) {
return;
}
if (head->val == val) {
ListNode* p = head;
head = head->next;
delete p;
} else {
ListNode* p = head;
while (p->next != NULL && p->next->val != val) {
p = p->next;
}
if (p->next != NULL) {
ListNode* q = p->next;
p->next = q->next;
delete q;
}
}
}

// 输出链表
void printList(ListNode* head) {
ListNode* p = head;
while (p != NULL) {
cout << p->val << " ";
p = p->next;
}
cout << endl;
}

// 示例代码
int main() {
ListNode* head = NULL;
insertNode(head, 1);
insertNode(head, 2);
insertNode(head, 3);
insertNode(head, 4);
printList(head);
deleteNode(head, 3);
printList(head);
deleteNode(head, 1);
printList(head);
return ;
}

### 回答2：
单链表是一种基本数据结构，它由多个节点组成，每个节点包含一个数据域和一个指针域，指向下一个节点。单链表的基本操作有插入、删除、查找等，实现这些操作的算法如下：

1. 单链表插入操作

单链表的插入操作可以分为以下几种情况：

（1）在表头插入新节点。

（2）在表尾插入新节点。

（3）在表中插入新节点。

具体的实现步骤如下：

（1）在表头插入新节点：

创建一个新节点p，将指针域指向原来的表头节点head，将head指向新节点p。

（2）在表尾插入新节点：

创建一个新节点p，找到链表的尾节点tail，将tail的指针域指向新节点p，将新节点p的指针域指向NULL。

（3）在表中插入新节点：

先找到要插入的位置，即要插入节点的前一个节点prev，创建一个新节点p，将p的指针域指向prev的下一个节点next，将prev的指针域指向新节点p。

2. 单链表删除操作

单链表的删除操作也可以分为以下几种情况：

（1）删除表头节点。

（2）删除表尾节点。

（3）删除表中的节点。

具体的实现步骤如下：

（1）删除表头节点：

将head指向head的下一个节点，释放原表头节点的空间。

（2）删除表尾节点：

找到倒数第二个节点prev，将prev的指针域指向NULL，释放原尾节点的空间。

（3）删除表中的节点：

先找到要删除的节点删除节点p的操作可以这样实现：
将prev的指针域指向节点p的下一个节点next，释放节点p的空间。

下面是C++代码示例：

#include <iostream>
using namespace std;

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

class LinkedList
{
public:

// 构造函数，初始化链表头结点
LinkedList() : head(NULL) {}

// 在表头插入新节点
void InsertAtHead(int x)
{
ListNode* p = new ListNode(x);
p->next = head;
head = p;
}

// 在表尾插入新节点
void InsertAtTail(int x)
{
ListNode* p = new ListNode(x);
if (head == NULL) {
head = p;
return;
}
ListNode* tail = head;
while (tail->next != NULL) {
tail = tail->next;
}
tail->next = p;
}

// 在表中插入新节点
void InsertAtPos(int x, int pos)
{
if (pos <= 0) {
cout << "Invalid position!" << endl;
return;
}
ListNode* prev = head;
for (int i = 1; i < pos - 1; i++) {
if (prev == NULL) {
cout << "Invalid position!" << endl;
return;
}
prev = prev->next;
}
if (prev == NULL) {
cout << "Invalid position!" << endl;
return;
}
ListNode* p = new ListNode(x);
p->next = prev->next;
prev->next = p;
}

// 删除表头节点
void DeleteAtHead()
{
if (head == NULL) {
return;
}
ListNode* p = head;
head = head->next;
delete p;
}

// 删除表尾节点
void DeleteAtTail()
{
if (head == NULL) {
return;
}
if (head->next == NULL) {
delete head;
head = NULL;
return;
}
ListNode* prev = head;
ListNode* p = head->next;
while (p->next != NULL) {
prev = p;
p = p->next;
}
prev->next = NULL;
delete p;
}

// 删除表中的节点
void DeleteAtPos(int pos)
{
if (pos <= 0 || head == NULL) {
return;
}
if (pos == 1) {
DeleteAtHead();
return;
}
ListNode* prev = head;
ListNode* p = head->next;
for (int i = 2; i < pos; i++) {
if (p == NULL) {
return;
}
prev = p;
p = p->next;
}
if (p == NULL) {
return;
}
prev->next = p->next;
delete p;
}

// 打印链表
void PrintList()
{
if (head == NULL) {
cout << "Empty List!" << endl;
return;
}
ListNode* p = head;
while (p != NULL) {
cout << p->val << " ";
p = p->next;
}
cout << endl;
}

private:
ListNode* head;
};

int main()
{
LinkedList list;
list.InsertAtHead(1);
list.InsertAtHead(2);
list.InsertAtTail(3);
list.InsertAtTail(4);
list.PrintList(); // 2 1 3 4
list.DeleteAtHead();
list.DeleteAtTail();
list.DeleteAtPos(2);
list.PrintList(); // 1
return 0;
}

### 回答3：
单链表是一种线性结构，其中的每个节点包含一个数据元素和一个指向下一个节点的指针。在单链表中，每个节点只能访问它的下一个节点，因此在对单链表进行操作时，需要设计一些基本算法来实现插入、删除等操作。

插入算法：
要在单链表中插入一个新节点，需要首先找到插入节点的前驱节点（即前一个节点的指针），然后将新节点的指针指向前驱节点的后继节点，再将前驱节点的指针指向新节点即可完成插入操作。

删除算法：
要在单链表中删除一个节点，需要首先找到要删除的节点的前驱节点，然后将前驱节点的指针指向要删除节点的后继节点即可完成删除操作。如果要删除的节点是第一个节点，则直接将头指针指向其后继节点即可。

欲实现上述算法，可以编写一个简单的单链表操作程序，其中包含插入、删除等基本操作方法：

// 定义单链表节点
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};

// 插入节点
ListNode* insertNode(ListNode* head, int val) {
ListNode *node = new ListNode(val);
if (!head) {
head = node;
} else {
node->next = head->next;
head->next = node;
}
return head;
}

// 删除节点
ListNode* deleteNode(ListNode* head, int val) {
if (!head) {
return head;
}
if (head->val == val) {
ListNode *node = head;
head = head->next;
delete node;
return head;
}
ListNode *pre = head;
ListNode *cur = head->next;
while (cur != NULL && cur->val != val) {
pre = cur;
cur = cur->next;
}
if (cur != NULL) {
pre->next = cur->next;
delete cur;
}
return head;
}

// 输出单链表
void printList(ListNode *head) {
while (head != NULL) {
cout << head->val << " -> ";
head = head->next;
}
cout << "NULL" << endl;
}

// 测试
int main() {
ListNode *head = NULL;
head = insertNode(head, 1);
head = insertNode(head, 2);
head = insertNode(head, 3);
head = insertNode(head, 4);
head = insertNode(head, 5);
printList(head);
head = deleteNode(head, 3);
head = deleteNode(head, 1);
printList(head);
return 0;
}

以上代码实现了单链表的插入、删除和输出操作，通过调用insertNode和deleteNode方法来实现插入和删除，通过printList方法来输出单链表的所有节点。