（图解）单链表删除结点值为x的结点算法

已于 2022-10-13 19:46:54 修改
阅读量6k 收藏 140
点赞数 12
分类专栏： 数据结构 文章标签： 算法 链表 数据结构
于 2022-10-11 20:37:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61959780/article/details/127260745
版权

目录

一、非递归的算法

第一种算法思路如下：

第二种算法思路如下：

二、递归的算法

一、非递归的算法

第一种算法思路如下：

  1. 先判断链表L是否为空，空链表退出程序；
  2. 用p利用while循环从头到尾扫描单链表，pre指向 *p 结点的前驱；
  3. 在while循环中，用 if 语句判断是结点是否是要删除的结点，是的话就删除此结点并且pre->next指向p结点的后驱，否则让pre、p指向同步后移个结点。

时间复杂度：O(n)                空间复杂度：O(1)

// 单链表的结点存储结构

typedef struct LNode{
    ElemType data;           // 数据域
    struct LNode *next;      // 结点域
} LNode, *LinkList;

算法实现：

void Del_x(LinkList L, ElemType x){
    // L为带头结点的链表
    LinkList p = L->next, pre = L, q;
    if (p == NULL)
    {
        printf("链表为空！\n");
        return;
    }
    while(p){
        if (p->data == x) {
            q = p;           // q指向要删除的结点
            p = p->next;     // p->指向要删除结点的后驱
            pre->next = p;   // q的前驱指向q的后驱
            free(q);         // 释放q（需要删除的结点）
        }
        else{
            pre = p;        // pre向下后移
            p = p->next;    // p与pre同步向后移，这两步不能调换顺序
        }
    }
    return;
}

图解算法：

先看下面这个链表，咱们要删除 x = 2 的结点

 L指向头结点

pre开始指向头结点，p指向链表的第一个结点，通过while循环中的 if 语句判断，p->data \neq 2，故pre和q同步后移。

后移后p->data = 2，因此要删除这个结点，即指行while循环里面的 if 语句，q指向要删除的结点，

p指向要删除结点的后驱，pre不要移动。

 然后通过free()函数将 q 指向的空间释放，并且pre的后驱指向 p（即pre->next = p），此时链表没有 q指向的结点。

 然后再通过 if 语句判断，p->data \neq 2，pre 和 q 同步后移。

然后p->data = 2即要删除这个结点，p的后驱是空指针NULL，故最后 p = NULL，通过free()函数释放此结点，然后pre的后驱指向 p，即 pre->next = NULL。

然后p = NULL，循环结束，链表中无结点数据域等于2的结点，任务完成。

第二种算法思路如下：

  1. 利用尾插法建立单链表；
  2. p用来扫描L的所有结点，当其值不为x时，将其链接到L之后，否则将其释放。

时间复杂度：O(n)                空间复杂度：O(1)

算法实现：

void Del_x(LinkList L, ElemType x){
    LinkList p = L->next, r = L, q;
    if ( p == NULL)
    {
        printf("链表为空！\n");
        return;
    }
    while(p){
        if (p->data != x){
            r->next = p;  // p结点的值不为x，链接到L的尾部
            r = p;        // 方便下次链接
            p = p->next;   
        }
        else{
            q = p;      // 保存要删除的结点
            p = p->next;    // 指向要删除结点的后驱，继续扫描
            free(q);       // 释放结点
        }    
    }
    r->next = NULL;   // 插入结束后，尾结点的next域为NULL
    return;
}

图解算法：

 这个算法咱们可以这么理解，类似创建了新链表（在原链表上创建），然后往新链表插入结点的值不为x的结点，用的内存还是原来结点的内存（即指向的内存和原结点的地址一致），并不是新的分配的内存。和实际创建新链表（不在原链表上创建），通过复制结点后插入不同，复制插入的结点的地址不是原结点的地址（即指向的内存地址与原结点不一致），而是新分配的内存。

先看这个链表的初始情况

咱们为了更好的理解，可以将这个链表分为两个链表，一个为L指向头结点的链表，一个为p指向除头结点所有结点组成的链表 。

根据while循环的的 if 语句判断，p所指向的结点并不是要删除的结点，故p指向下一个节点，而刚才p指向的结点被链接到L所指向的链表上。

 r->next = p;  // p结点的值不为x，链接到L的尾部

 现在p指向的是要删除的结点，执行 if 语句的else部分，用q指向它，而p指向要删除结点的后驱。

 然后通过free()函数释放q所指向的结点。

此时p指向的结点不是要删除的结点，p后移，p之前的结点链接到L指向的链表。

 r->next = p;  // p结点的值不为x，链接到L的尾部

此时p指向的是要删除的结点，p向后移，并且q指向此结点。

通过free()函数释放q结点，此时p指向NULL，while循环结束，将L指向的链表最后结点的next指向NULL。

总结来说，就是把结点不是删除结点，就链接到L指向的链表，是要删除的结点通过free()函数释放。

二、递归的算法

算法思路如下：

  1. 找到基线条件（就是递归中止的条件），即链表为空，
  2. 找到递归条件，即每次递归离空链表更进一点
  3. 所以若链表L为空，递归函数 Del_x(L,x)什么也不做
  4. 若L->data = x, f(L,x)删除结点L，并且执行函数 Del_x(L->next, x)，进行下次递归。
  5. 若L->data \neq x，执行函数 Del_x(L->next, x)，进行下次递归。

算法实现：

1、C++代码实现

// C++代码 LinkList &L，是一个引用
void Del_x(LinkList &L, ElemType x){
    // L是不带头结点的链表
    LinkList p;
    if (L == NULL)        // 递归出口
        return;
    if (L->data == x){
        p = L;                // 删除L，并让L指向下一个结点
        L = L->next;
        free(p);
        Del_x(L, x);  // 递归调用
    }
    else            // 若L指向的结点不为x
        Del_x(L->next, x); // 递归调用
    return; 
}

2、C语言代码实现

void Del_x(LinkList* head, ElemType x)
{
    // head为指向不带头结点链表的第一个结点的指针的指针
    // head为二级指针，需要修改内存上保存的指向LinkList的地址
    LinkList p;   // 保存要删除的结点地址
    if (*head == NULL) 
        return;        // 空链表，退出程序
    if ((*head)->data == x) // 判断结点的值是否为x
    {
        p = *head;  // 保存要删除的结点
        *head = p->next;   // 保存要删除的结点后驱地址
        Del_x(head, x);    // 递归函数
    }
    else
    {
        head = &((*head)->next);    // 指向下一个结点的地址的地址
        Del_x(head, x);
    }
}

这个算法要区分结构体指针和指向结构体指针的指针，可以看看我写的博客来了解结构体指针和指向结构体指针的区别。

结构体指针与指向结构体指针的区别

算法需要一个递归工作栈，深度为O(n)，时间复杂度为O(n)。

 测试程序：

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

#define FLAG  -1

typedef int ElemType;
typedef struct Node
{
    ElemType data;
    struct Node* next;
}LinkNode, * LinkList;

LinkList AddHead2(int flag);
void ShowLinkList(LinkList head);
int ListLength(LinkList head);
bool Insert(LinkList head, ElemType x, int i, int ListLength);
bool Delete(LinkList head, int i, int ListLength);
int ShowMeanu();
//void Del_x(ElemType x, LinkList head);
void Del_x(LinkList* head, ElemType x);

int main(void)
{
    int choice;
    LinkList head = (LinkList)malloc(sizeof(LinkNode));
    head->next = NULL;
    while (true)
    {
        choice = ShowMeanu();
        switch (choice)
        {
        case 0:    exit(0);
            break;
        case 1:    head = AddHead2(FLAG);
            break;
        case 2:    ShowLinkList(head);
            break;
        case 3: {
            int i, x;
            printf("请输入你要插入结点的位置：");
            scanf("%d", &i);
            printf("请输入你要插入结点的数据域的值：");
            scanf("%d", &x);
            int length = ListLength(head);
            Insert(head, x, i, length);
        }
              break;
        case 4: {
            int i;
            printf("请输入你要插入结点的位置：");
            scanf("%d", &i);
            Delete(head, i, ListLength(head));
        }
              break;
        case 5: {
            int length;
            length = ListLength(head);
            printf("链表的长度为：%d\n");
        }
              break;
        case 6: {
            int x;
            printf("请输入要删除所有结点为x的值：");
            scanf("%d", &x);
            LinkList p = &(head->next);
            //Del_x(head, x);
            Del_x(p, x);
        }
              break;
        default:   printf("请输入恰当的值!!!!\n");
        }
    }
    return 0;
}

int ShowMeanu()
{
    int choice;
    printf("欢迎来到链表测试功能！！！！！！\n");
    printf("1.创建单链表              2.显示单链表中的结点\n");
    printf("3.在链表i位置插入节点      4.删除链表第i个结点\n");
    printf("5.单链表的表长            6.删除链表为x的所有结点\n");
    printf("0.退出程序\n");
    printf("请输入你想测试的功能序号：");
    scanf("%d", &choice);
    return choice;
}

LinkList AddHead2(int flag)
{
    printf(" 输入 -1 停止创建单链表\n");
    LinkList head, p, q;
    head = (LinkList)malloc(sizeof(LinkNode));
    head->next = NULL;
    p = head;
    ElemType x;
    scanf("%d", &x);
    while (x != flag)
    {
        q = (LinkList)malloc(sizeof(LinkNode));
        q->data = x;
        if (head->next == NULL)
            head->next = q;
        else
            p->next = q;
        p = q;
        scanf("%d", &x);
    }
    if (p != NULL)
        p->next = NULL;
    return head;
}

void ShowLinkList(LinkList head)
{
    LinkList p = head->next;
    while (p != NULL)
    {
        printf("%d", p->data);
        p = p->next;
    }
    printf("\n");
}

int ListLength(LinkList head)
{
    int len = 0;
    LinkList p = head;
    while (p->next != NULL)
    {
        len++;
        p = p->next;
    }
    return len;
}

bool Insert(LinkList head, ElemType x, int i, int ListLength)
{
    LinkList p = head;
    if (i > ListLength || p->next == NULL)
        return false;
    while (--i)
        p = p->next;
    LinkList q = (LinkList)malloc(sizeof(LinkNode));
    q->data = x;
    q->next = p->next;
    p->next = q;
    return true;
}

bool Delete(LinkList head, int i, int ListLength)
{
    LinkList p = head;
    if (i > ListLength || p->next == NULL)
        return false;
    while (--i)
        p = p->next;
    LinkList q = p->next;
    p->next = q->next;
    free(q);
    return false;
}

/*void Del_x(ElemType x, LinkList head)
{
    LinkList p = head->next, pre = head, q;
    if (p == NULL)
    {
        printf("链表为空\n");
        return;
    }
    while (p)
    {
        if (p->data == x)
        {
            q = p;
            p = q->next;
            pre->next = p;
            free(q);
        }
        else
        {
            pre = p;
            p = p->next;
        }
    }
    return;
}*/

/*void Del_x(ElemType x, LinkList L) {
    LinkList p = L->next, r = L, q;
    if (p == NULL)
    {
        printf("链表为空！\n");
        return;
    }
    while (p) {
        if (p->data != x) {
            r->next = p;  // p结点的值不为x，链接到L的尾部
            r = p;        // 方便下次链接
            p = p->next;
        }
        else {
            q = p;      // 保存要删除的结点
            p = p->next;    // 指向要删除结点的后驱，继续扫描
            free(q);       // 释放结点
        }
    }
    r->next = NULL;   // 插入结束后，尾结点的next域为NULL
    return;
}*/

void Del_x(LinkList* head, ElemType x)
{
    LinkList p;
    if (*head == NULL)
        return;
    if ((*head)->data == x)
    {
        p = *head;
        *head = p->next;
        Del_x(head, x);
    }
    else
    {
        head = &((*head)->next);
        Del_x(head, x);
    }
}

黑夜里的小夜莺
关注
  • 12
    点赞
  • 踩
  • 140
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
编写算法删除单链表L中所有值为e的数据元素。
04-10
编写算法删除单链表L中所有值为e的数据元素。
在单链表中删除值为x的节点
我要好好当个计院狗
10-03 6070
一、题目 再带头节点的单链表L中，删除所有值为x的节点，并释放其空间，假设值为x的节点不唯一，试编写算法以实现上述操作。 二、分析 题目非常简单，只要熟悉单链表的基本操作就可以很快解决这个问题。 三、代码 #include<stdio.h> #include<stdlib.h> //对单链表的定义 typedef struct LinkNode{ int data; LinkNode *next; }LinkNode,*LinkList; //对单链..
数据结构（C语言）：删除单链表中值为x的所有结点
lbcbjtlhmjq的博客
04-15 1351
有些应用中允许线性表中存在有值相同的数据元素，本题所使用的数据结构定义如下：typedef int ElemType;
数据结构【链表01】----删除单链表中所有值为x的节点
realttr的博客
03-07 7695
问题描述： 在带头结点的单链表L中，删除所有值为x的节点，并释放其内存空间，假设值为x的节点不唯一，试编写算法实现上述代码。 问题分析 使用pre指针指向头节点，用pre->next逐个扫描，如果pre->next节点的值为x，pre指针指向pre->next->next，删除pre->next指针，然后释放pre->next这个节点。如果pre->next的值不为x则pre往后移动一个节点 为了简化算法，可以引用p指针表示pre节点的后继指针，为了释放p指针的内存
在带头结点的单链表中删除所有值为x的结点
zhaoxk88的博客
05-13 6706
个人代码如下所示，欢迎大佬指正。 #include<stdio.h> #include<stdlib.h> typedef struct LNode { int data; struct LNode* next; }Node,*Link; //删除值为x的结点 void Delete(Link& link, int x) { Node* p = link,*q; while (p->next!=NULL) {
算法图解读书笔记.pdf
11-02
适合想了解基础算法的前端开发人员
算法的动画图解
11-11
《算法的动画图解》是针对安卓手机系统设计的一款学习应用，主要目的是通过生动的动画形式，帮助用户直观地理解各种算法的工作原理。这个1.2.7版本为简体中文解锁版，确保了国内用户可以无障碍地进行学习，无需担心...
算法图解_算法_
09-30
通过阅读《算法图解》，读者不仅可以学习到具体的算法知识，还能培养解决问题的思维习惯，提升编程能力，为未来的学习和工作打下坚实的基础。这本书适合初学者入门，同时也对有一定经验的开发者有着很好的复习和巩固...
算法图解笔记以及代码文件.zip
08-09
《算法图解笔记以及代码文件.zip》是一个包含算法学习资源的压缩包，主要针对初学者或希望巩固算法基础的人群。这个压缩包里的内容涵盖了算法的基础理论和实践应用，通过笔记的形式帮助读者理解和掌握各种常见算法。...
对象检测（objectdetection）算法图解
01-27
本文来自于10tiao，文章介绍了图像检测中常用的深度学习方法—RCNN家族系列算法，以图像讲解形式，便于理解。在生活中，经常会遇到这样的一种情况，上班要出门的时候，突然找不到一件东西了，比如钥匙、手机或者手表...
删除单链表中节点值为x的节点
Forrit的博客
10-19 1991
这里用了两种方式实现： //这一种方式用来三个指针，一个用来遍历的p指针，一个指向p的前驱的pre指针，还有一个标识目标节点的q指针 while(p!=null) { if(p->data==x) { q=p; p=p->next; pre->next=p; free(q); } else { pre=p; p=p->next; } } //这一种方式用来两个指针，一个用来遍历的p指针，一
数据结构-链表-删除所有值为x的结点
Xulidanga的博客
09-28 4217
一.算法思想 算法中共需要用到3个指针变量，分别为p，pre，temp。这三个指针变量代表的分别是：指向当前结点指针变量，当前结点的前一个结点的指针变量，辅助指针变量(用于删除值为x的结点) 二.源代码 void Delete_x(List list,ElementType x) { Node p,pre,temp; p = list->Next; pre = list; while (p!=NULL) { //若当前结点值等于x if (p->Data==x) { t
每日一题———5.删除单链表中数据为x的节点（x不唯一）
而塞过的学习之旅
05-26 139
前言 数据结构每日一题 声明：因个人能力有限，本文仅是个人的学习记录笔记，有错误之处还望指出 要点 链表的删除 思想 需要借助三个指针，一个用作遍历的推行(比较指针)，一个用作暂时保存要被删除的数据（删除指针），一个用作删除遍历节点的前驱节点（前驱指针） void deleteAll(LinkList &L,ElemType x){ LinkNode *p,*q,*pre; p=L->next; pre=L; while(p != NULL){ if(p->.
递归算法删除所有值为x的结点
qq_61706112的博客
09-10 335
/*在带头结点的单链表L中，删除所有值为x的结点，并释放其空间，假设值为x的结点不唯一 ，试编写算法以实现上述操作*/ #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; LinkList TailCreateList(LinkList &L) { .
设计一个递归算法，删除不带头节点的单链表L中所有值为x的结点
byuvyh的博客
03-28 2700
算法思想：首先知道什么是递归，递归就是函数在原来的函数基础上进行下一次的调用 直到不满住条件有一个初始值结束递归 #include<stdio.h> #include<stdlib.h> typedef struct Lnode{ int data;//数据域 struct Lnode *next;//指针域 }Lnode,*LinkList; int a[4]={1,2,3,4}; int n=4; //这里使用尾插法，把数据放在L中 void InitList(L
设计一个递归算法，删除带头结点的单链表L中所有值为x的结点
Xuan_m_o的博客
04-25 7151
这个算法对于不带头结点的，如果首元结点的数据域为X的话，则无法适用。 /*设计一个递归算法，删除带头结点的单链表L中所有值为x的结点*/ #include <stdio.h> #include <stdlib.h> typedef struct Link{ int data;//代表数据域 struct Link* next;// 代表指针域，指向直接后继元素 ...
设计一个递归算法，删除不带头结点的单链表L中的所有值为x的结点
qq_44750091的博客
08-14 813
设计一个递归算法，删除不带头结点的单链表L中的所有值为x的结点。
删除顺序表中所有值为x的结点
weixin_54842359的博客
03-28 3353
删除顺序表中所有值为x的结点
数据结构 删除链表中值为x的节点.
lqw121314的博客
10-20 3597
题目：删除链表中值为x的节点. 核心代码： 删除三个元素中间的一个节点，先用p指向前一个节点的next（也就是中间的那个节点），用u=p-&gt;next, p-&gt;next=p-&gt;next-&gt;next; ...
请给我RCU删除结点和添加结点的图解
最新发布
06-06
下面是RCU添加节点和删除节点的图解。 1. RCU添加节点的图解 ``` +-----------+ +-----------+ | Read Side | | Update | | | | Side | +-----------+ +-----------+ | | | | | | | | | | | | | | | | | | | | | +---------+ | +---->|Add Node |<---+ +---------+ ``` 在添加节点时，读取操作和更新操作是并行的。读取操作可以继续访问旧的节点，更新操作先创建一个新的节点，然后将新节点添加到数据结构中。最后，更新操作完成后，读取操作就可以切换到新的节点。 2. RCU删除节点的图解 ``` +-----------+ +-----------+ | Read Side | | Update | | | | Side | +-----------+ +-----------+ | | | | | | | | | | | | | | | | | | | | | +---------+ | +---->|Mark |<---+ |Deleted | +---------+ ``` 在删除节点时，更新操作先将节点标记为已删除，然后等待一段时间（Grace Period），以确保所有读取操作都已经完成。在Grace Period结束后，更新操作再真正删除节点。这样，读取操作可以继续访问旧的节点，直到Grace Period结束后，才切换到新的节点。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值