【华为机试ACM基础#02】从单向链表中删除指定值的节点、输出单向链表中倒数第k个节点（熟悉链表的输入方式）
从单向链表中删除指定值的节点
输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。
链表的值不能重复。
构造过程，例如输入一行数据为:
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≤�≤1000 1≤n≤1000 ，节点中的值满足 0≤���≤10000 0≤val≤10000
测试用例保证输入合法
输入描述：
输入一行，有以下4个部分：
1 输入链表结点个数
2 输入头结点的值
3 按照格式插入各个结点
4 输入要删除的结点的值
输出描述：
输出一行
输出删除结点后的序列，每个数后都要加空格
思路
如果这题是在LeetCode用核心代码模式做的话，是一道很常规的题目，只需要遍历单向链表，找到与目标值匹配的节点后删除即可
在ACM模式下，输入输出就成了大问题
为了理顺逻辑，最好将删除功能单独写成一个函数
那么，整体逻辑就是：从输入数据中拿到头节点，遍历输入数据，将链表构建好，然后调用删除函数将指定节点删除，最后再把链表的值打印出来
#include<iostream>
using namespace std;
struct ListNode{
};
ListNode* deleteNode(ListNode* head, int val) {//删除链表中值为val的节点
}
int main(){
}
定义结构体
先定义一个结构体作为链表节点(详见：构造链表)
struct ListNode{
int val;
ListNode* next;
ListNode(int x):val(x), next(nullptr){}
};
删除函数
使用dummy进行删除（注意，这里和设计链表中的删除函数还不太一样，这里需要根据节点值进行删除而不是索引值）
ListNode* deleteNode(ListNode* head, int val) {//删除链表中值为val的节点
if(head == nullptr) return nullptr;//特判：如果头结点为空，返回空指针
if(head->val == val) return head->next;//特判：如果头结点的值等于val，直接返回头结点的下一个节点
ListNode* dummy = new ListNode(0);//创建dummy节点,接在头节点之前
dummy->next = head;
ListNode* cur = dummy;
while(cur->next != nullptr){
if(cur->next->val == val){//处理被删除的节点
ListNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
}else{
cur = cur->next;
}
}
return dummy->next;
}
主函数
在主函数里，我们需要接受一行输入数据，例如：
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】
接下来取2、3，表示3要接在2后面【链表为2->3->1】
然后取5、1，表示5要接在1后面【链表为2->3->1->5】
取4、5，表示5要接在4后面【链表为2->3->1->5->4】...
实际上题目除了要我们从单向链表中删除指定值的节点，还需要我们根据输入数据按照规则来先构建链表
int main(){
//定义几个变量分别接收：链表节点数量（例子中的6）、头节点的值（例子中的2）、待删除节点的值
int n, head_val, val;
cin >> n >> head_val;
ListNode* head = new ListNode(head_val); //创建头结点
for(int i = 0; i < n-1; i++){ //循环插入剩余的n-1个节点
int pre_val, cur_val;//取两个值（如例子中的1、2）
cin >> cur_val >> pre_val; //输入当前节点的值和需要插入的位置的节点的值
ListNode* pre = head;
while(pre != NULL && pre->val != pre_val) //遍历链表，找到需要插入的节点
pre = pre->next;
ListNode* cur = new ListNode(cur_val); //创建当前节点
cur->next = pre->next; //将当前节点插入至链表中
pre->next = cur;
}
}
然后再从输入中获取待删除值，调用删除函数，之后遍历打印链表即可
cin >> val; //输入需要删除的节点的值
head = deleteNode(head, val); //删除节点
while(head != NULL){ //遍历打印链表
cout << head->val << " ";
head = head->next;
}
代码
#include<iostream>
using namespace std;
struct ListNode{
int val;
ListNode* next;
ListNode(int x) : val(x), next(NULL) {}
};
ListNode* deleteNode(ListNode* head, int val) {//删除链表中值为val的节点
if(head == nullptr) return nullptr;//特判：如果头结点为空，返回空指针
if(head->val == val) return head->next;//特判：如果头结点的值等于val，直接返回头结点的下一个节点
ListNode* dummy = new ListNode(0);//创建dummy节点,接在头节点之前
dummy->next = head;
ListNode* cur = dummy;
while(cur->next != nullptr){
if(cur->next->val == val){//处理被删除的节点
ListNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
}else{
cur = cur->next;
}
}
return dummy->next;
}
int main(){
int n, head_val, val;
cin >> n >> head_val;
ListNode* head = new ListNode(head_val); //创建头结点
for(int i = 0; i < n-1; i++){ //循环插入剩余的n-1个节点
int cur_val, pre_val;//取两个值（如例子中的1、2）
cin >> cur_val >> pre_val; //输入当前节点的值和需要插入的位置的节点的值
ListNode* pre = head;
while(pre != NULL && pre->val != pre_val) //遍历链表，找到需要插入的节点
pre = pre->next;
ListNode* cur = new ListNode(cur_val); //创建当前节点
cur->next = pre->next; //将当前节点插入至链表中
pre->next = cur;
}
cin >> val; //输入需要删除的节点的值
head = deleteNode(head, val); //删除节点
while(head != NULL){ //遍历打印链表
cout << head->val << " ";
head = head->next;
}
return 0;
}
输入输出总结
其实也没啥好总结的这题，本来以为可以用来当做ACM下链表输入的参考的，结果使用的还是cin
但是观察这题可以发现：ACM下，题目要求的输入有可能不是一次性输入完成的
例如本题，题目举的例子是6 2 1 2 3 2 5 1 4 5 7 2 2，如果一开始没明白题意的话很容易以为输入数据的形式就是这个，导致后续处理很困难
还有就是复习了一下删除指定节点值的操作，练习了链表的构造
输出单向链表中倒数第k个结点（构造链表、输入tips）
输入一个单向链表，输出该链表中倒数第k个结点，链表的倒数第1个结点为链表的尾指针。
链表结点定义如下：
struct ListNode
{
int m_nKey;
ListNode* m_pNext;
};
正常返回倒数第k个结点指针，异常返回空指针.
要求：
(1)正序构建链表;
(2)构建后要忘记链表长度。
数据范围：链表长度满足 1≤�≤1000 1≤n≤1000 ， �≤� k≤n ，链表中数据满足 0≤���≤10000 0≤val≤10000
本题有多组样例输入。
输入描述：
输入说明
1 输入链表结点个数
2 输入链表的值
3 输入k的值
输出说明：输出一个整数
输入：
8
1 2 3 4 5 6 7 8
4
输出：5
思路
参考删除链表倒数第N个节点，使用快慢双指针即可找出本题中倒数第K个节点
但是要注意，本题不是要删除该节点，因此要和上述题目作区分
在本题中，快指针只需要比慢指针先走k步就行，不用k+1
剩下的问题还有两个：数据输入、正向链表构造
数据输入
虽然还是用cin来获取用户的输入数据，但是这里有个使用技巧，即cin与while配合使用
形式如下：
int main() {
int nodeNums;//节点个数
while(cin >> nodeNums){
}
return 0;
}
由题意，我们需要先输入链表的节点个数，此时可以将接收的代码写在while里面
这样当用户（这里其实是OJ）输入8，循环开始，我们可以在循环内处理其他逻辑
当本次循环结束，若用户没有输入，则退出循环，程序结束。
OJ会不断输入测试用例直到测试完毕才会停止输入，那时候正好跳出循环，程序结束
链表构造
和上题不同，本题是要求我们按规定的顺序构建链表，不涉及穿插节点，因此适用性更广
int main() {
int nodeNums;//节点个数
while(cin >> nodeNums){
int nodeVal;//接收用户输入的节点值
ListNode* dummy = new ListNode(0);
ListNode* cur = dummy;
for(int i = 1; i <= nodeNums; ++i){//正序构建链表
cin >> nodeVal;
ListNode* node4add = new ListNode(nodeVal);
cur->next = node4add;
cur = cur->next;
}
}
return 0;
}
进入循环后，继续接收用户输入的值作为节点的值
创建dummy和cur指针，在遍历过程中不断接收节点值，用于构造临时节点node4add，该节点被连接到cur后
随着cur的移动，链表构造完毕
后面只需要根据输入的k值，找到对应节点并返回其值即可
注意！！！使用快慢指针时，快指针只需要提前k步
注意！！！使用快慢指针时，快指针只需要提前k步
注意！！！使用快慢指针时，快指针只需要提前k步
代码
#include <iostream>
using namespace std;
struct ListNode{
int val;
ListNode* next;
ListNode(int x): val(x), next(nullptr){}
};
int main() {
int nodeNums;//节点个数
while(cin >> nodeNums){
int nodeVal;
ListNode* dummy = new ListNode(0);
ListNode* cur = dummy;
for(int i = 1; i <= nodeNums; ++i){//正序构建链表
cin >> nodeVal;
ListNode* node4add = new ListNode(nodeVal);
cur->next = node4add;
cur = cur->next;
}
int k;
cin >> k;
//使用双指针寻找倒数第k个节点
ListNode* fast = dummy;
ListNode* slow = dummy;
// k--;//fast指针不用从k+1开始走，因为本题不是要删除倒数第k个节点，而是要返回其值
for(int i = k; i > 0; --i){//fast指针先走k步
if(fast == nullptr) break;
fast = fast->next;
}
while(fast != nullptr){//同时走，直到fast为nullptr
fast = fast->next;
slow = slow->next;
}
cout << slow->val << endl;
}
return 0;
}
