描述
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表的值不能重复。
构造过程，例如输入一行数据为:
6 2 1 2 3 2 5 1 4 5 7 2 2
则第一个参数6表示输入总共6个节点，第二个参数2表示头节点值为2，剩下的2个一组表示第2个节点值后面插入第1个节点值，为以下表示:
1 2 表示为
2->1
链表为2->1
3 2表示为
2->3
链表为2->3->1
5 1表示为
1->5
链表为2->3->1->5
4 5表示为
5->4
链表为2->3->1->5->4
7 2表示为
2->7
链表为2->7->3->1->5->4
最后的链表的顺序为 2 7 3 1 5 4
最后一个参数为2，表示要删掉节点为2的值
删除 结点 2
则结果为 7 3 1 5 4
数据范围：链表长度满足1≤n≤1000 ，节点中的值满足 0≤val≤10000
测试用例保证输入合法
输入描述：
输入一行，有以下4个部分：
1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值
输出描述：
输出一行
输出删除结点后的序列，每个数后都要加空格
示例1
输入：
5 2 3 2 4 3 5 2 1 4 3
输出：
2 5 4 1
说明：
形成的链表为 2->5->3->4->1
删掉节点3，返回的就是 2->5->4->1
示例2
输入：
6 2 1 2 3 2 5 1 4 5 7 2 2
输出：
7 3 1 5 4
实现1
#include<bits/stdc++.h>
//包含了目前c++所包含的所有头文件
using namespace std;
int main() {
int n, head;
cin >> n >> head;
forward_list<int> linklist;
linklist.push_front(head);
for (int i = 1; i < n; i++) {
int front, back;
cin >> back >> front;
auto it = find(linklist.begin(), linklist.end(), front);
linklist.insert_after(it, back);
}
int last;
cin >> last;
linklist.remove(last);
for (auto it = linklist.begin(); it != linklist.end(); it++) {
cout << *it << " ";
}
cout << endl;
return 0;
}
实现2 数组模拟
具体做法：
因为链表中的值互异，我们可以用数组来模拟链表进行增删。
首先数组添加第一个元素即表头，然后每次要添加元素我们都要用find函数找到它在哪个数字后面，即找到它前面那个数字的出现的位置，因为数字互异所以一定能找到唯一，如果是最后一个数字则将其加入数组末尾，如果是中间的则用insert函数插入相应位置。
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n, head;
while(cin >> n >> head){
vector<int> array; //用数组模拟链表
array.push_back(head);
for(int i = 1; i < n; i++){
int num, pos_num;
cin >> num >> pos_num; //输入要插入的数和它要插入哪个数字后面
auto iter = find(array.begin(), array.end(), pos_num); //找到要插入后面你的那个位置
if(iter == array.end()) //结尾push_back
array.push_back(num);
else //中间insert
array.insert(iter + 1, num);
}
int remove;
cin >> remove;
array.erase(find(array.begin(), array.end(), remove)); //找到要移除的数字的位置
for(int i = 0; i < array.size(); i++) //输出
cout << array[i] << " ";
cout << endl;
}
return 0;
}
复杂度分析：
- 时间复杂度：O(n²)，插入的时候遍历n−1个输入，每个输入调用find函数都是O(n)，删除和输出复杂度较低，舍去
- 空间复杂度：O(1)，数组属于必要空间，无额外空间
实现3 链表
具体做法：
我们也可以用正统的链表做法。构建链表，然后依次将结点插入。
插入的时候遍历链表找到插入结点的前序结点（因为表中元素互异），断开前序结点与后序结点的连接，插入结点连接后续结点，前序结点连接插入结点。
后续直接遍历链表输出，当遇到要删除的结点值时不输出即可。
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
struct node{ //链表结点
int val;
struct node* next = NULL;
};
int main(){
int n, val;
while(cin >> n >> val){
node* head = new node; //头结点
head->val = val;
for(int i = 1; i < n; i++){
int pre, cur;
cin >> cur >> pre;
node* p = new node; //添加这个结点
p->val = cur;
node* q = head;
while(q->val != pre) //找到前序结点
q = q->next;
p->next = q->next; //断开
q->next = p; //插入
}
int remove;
cin >> remove;
node* p = head;
while(p != NULL){
if(p->val != remove) //不输出remove，其他都输出
cout << p->val << " ";
p = p->next;
}
cout << endl;
}
return 0;
}
复杂度分析：
- 时间复杂度：O(n²)，插入的时候遍历n−1个输入，每个输入都要遍历链表找到插入位置
- 空间复杂度：O(1)，链表空间属于必要空间，不属于额外空间
