首先看一下题

描述

输入一个单向链表和一个节点的值，从单向链表中删除等于该值的节点，删除后如果链表中无节点则返回空指针。

链表的值不能重复。

构造过程，例如输入一行数据为:

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.输入一个单向链表和一个节点的值

2.从单向链表中删除等于该值的节点

3.删除后如果链表中无节点则返回空指针。

4.链表的值不能重复。

5.构造过程，例如输入一行数据为：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

6.最后的链表的顺序为2 7 3 1 5 4

7.最后一个参数为2，表示要删掉节点为2的值

删除节点2 则结果为7 3 1 5 4

8.数据范围：链表长度满足n大于等于1小于等于1000，节点中的值满足val大于等于0小于等于10000

9.测试用例保证输入合法

10.输入描述：输入一行，有以下4个部分：

1 输入链表节点个数

2 输入头节点的值

3 按照格式插入各个节点

4 输入要删除的节点的值

11.输出描述：输出一行

输出删除节点后的序列，每个数后都要加空格

二、解题思路

1.首先#include <stdio.h>包含标准输入输出库的头文件，可以使用scanf和printf函数

2.#include <stdlib.h>引入标准库，以便使用动态内存分配函数malloc和free

3.我们定义链表，包含两个成员一个用来放节点值一个用来指向下一个节点

typedef struct linkedList {

int val;

struct linkedList *next;

} Node;

4.声明一个函数void insertNode，接受三个参数一个指向链表头节点的指针Node *head，一个整数int aim,一个整数int val,这个函数用于在链表中插入一个新节点

5.开始一个while循环条件是head != NULL(只要还没有遍历完链表）{

6.如果当前节点值等于我们的目标节点值if(head->val == aix){

7.我们定义一个Node *temp = (Node*)malloc(sizeof(Node));

8.设置新节点的值为temp->val = val;

9.将新节点的next指针指向当前节点的下一个节点

temp->next = head->next;

10.将当前节点的下一个节点变成temp，完成插入操作

head->next = temp;

11.然后返回return；

}

12.如果当前节点的值不是我们要找的我们移动到下一个节点继续寻找

head = head->next;}

13.然后我们声明一个void delNode(Node **head, int aim){函数

输入是指向链表的头节点的指针head和一个整数aim，用来查找链表，删除目标数值节点

14.如果我们链表的头节点值等于aim

if((*head)->val == aim) {

Node *temp = (*head)->next; //用一个临时节点指针指向下一个节点

free(*head); //将当前节点内存释放

*head = temp; //将当前节点变成原来的头节点的下一个节点

return;// 返回

}

15.如果头结点的值不等于aim，我们创建一个指针

Node *iter = *head; // 方便我们遍历链表

16.开始一个循环，只要iter的下一个节点不为NULL（没有遍历完）

while(iter->next != NULL){

17.如果找到目标节点if(iter->next->val == aim) {

18.我们对目标节点进行删除处理：

Node *temp = iter->next;

iter->next = temp->next;

free(temp);

return;

}

19.如果没有找到目标节点我们继续遍历iter = iter->next;

}

20.我们再声明一个printList函数,用来输出我们的链表

void printList(Node *head) {

while(head != NULL) {

printf("%d ", head->val);

head = head->next;

}

printf("\n");

}

21.最后我们再声明一个freeList函数，用来释放我们链表中所有节点的空间内存

void freeList(Node *head) {

22.循环遍历释放链表内存while(head != NULL) {

Node *next = head->next;

free(head);

head = next;

}

}

23.然后我们开始我们的主函数int main() {

我们声明三个整数int num, headVal, delVal;分别储存我们链表节点个数，头节点值，要删除的节点值

24.我们读取输入scanf("%d %d", &num, &headVal);

25.分配一个新的节点空间，并将其地址赋值给head指针，作为链表的头节点

Node *head = (Node *)malloc(sizeof(Node));

26.初始化头节点

head->next = NULL;

head->val = headVal;

27.我们将输入数据读取到我们的链表中

for(int i = 0; i < num - 1; i++) {

int aim = 0;

int val = 0;

scanf("%d %d", &val, &aim);

28.调用插入函数插入节点insertNode(head, aim, val);

}

29.读取完数据后还有一个要删除的节点的值需要读取

scanf("%d", &delVal);

30.调用delNode函数

Node *iter = head;

delNode(&head, delVal);

31.调用printList(head);打印删除节点后的链表

32.freeList(head);

33.返回return 0;

}

三、具体步骤

使用的语言是C

#include <stdio.h>
#include <stdlib.h>

typedef struct linkedList {
    int val;
    struct linkedList *next;
} Node;

void insertNode(Node *head, int val, int aim) {
    while(head != NULL) {
        if(head->val == aim) {
            Node *temp = (Node *)malloc(sizeof(Node));
            temp->val = val;
            temp->next = head->next;
            head->next = temp;
            return;
        }
        head = head->next;
    }
}

void delNode(Node **head, int aim) {
    if((*head)->val == aim) {
        Node *temp = (*head)->next;
        free(*head);
        *head = temp;
    }
    Node *iter = *head;
    while(iter->next != NULL) {
        if(iter->next->val == aim) {
            Node *temp = iter->next;
            iter->next = temp->next;
            free(temp);
            return;
        }
        iter = iter->next;
    }
}

void printList(Node *head) {
    while(head->next != NULL) {
        printf("%d ", head->val);
        head = head->next;
    }
    printf("%d\n", head->val);
}

void freeList(Node *head) {
    while(head != NULL) {
        Node *temp = head->next;
        free(head);
        head = temp;
    }
}

int main() {
    int num, headVal, delVal;
    // 读入输入中的节点数量注意数量包括头节点
    scanf("%d %d", &num, &headVal);
    // 定义头节点
    Node *head = (Node *)malloc(sizeof(Node));
    head->val = headVal;
    head->next = NULL;
    // 插入节点
    for(int i = 0; i < num - 1; i++) {
        int val;
        int aim;
        scanf("%d %d", &val, &aim);
        insertNode(head, val, aim);
    }
    // 删除节点
    scanf("%d", &delVal);
    delNode(&head, delVal);
    printList(head);
    freeList(head);
}