线性表练习之Example018-删除单链表中所有值为 x 的节点

最新推荐文章于 2023-12-02 23:41:16 发布
最新推荐文章于 2023-12-02 23:41:16 发布
阅读量2.5k 收藏 21
点赞数 1
分类专栏： 数据结构 文章标签： java c 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123805219
版权

Example018

原文链接：Example018

题目

在带头结点的单链表 L 中，删除所有值为 x 的结点，并释放其空间，假设值为 x 的结点不唯一，试编写算法实现上述操作。

分析

本题考查的知识点：

  • 单链表
  • 单链表删除节点

分析：

  • 用变量 node 从头到尾扫描单链表，而 preNode 指向 node 节点的前驱节点。
  • 若 node 节点的值是 x，则删除该节点，并让 node 移向下一个节点。
  • 否则 preNode 和 node 指针同步后移一个节点。

注意：

  • 上面的解法是原地修改单链表，我们还可以创建一条新的单链表，然后将那些不是 x 的元素插入到这个新单链表中。但注意采用尾插法，保持原结点顺序。

图解

请添加图片描述

C实现

解法一核心代码：

/**
 * 删除单链表中所有值为 x 的节点
 * @param list 单链表
 * @param x 指定值
 */
void deleteAllByEle(LNode **list, int x) {
    // 变量，记录链表的每个节点，从头到尾进行扫描
    LNode *node = (*list)->next;
    // 变量，记录 node 节点的前驱节点
    LNode *preNode = *list;

    // 从头到尾扫描单链表
    while (node != NULL) {
        // 判断当前节点的数据域是 x
        if (node->data == x) {
            // 保存待删除的节点，用于释放空间
            LNode *temp = node;
            // 删除 node 节点
            preNode->next = node->next;
            // 继续链表的下一个节点
            node = node->next;
            // 释放被删除节点的空间
            free(temp);
        }
        // 如果当前节点的数据域不是 x
        else {
            // 保存前驱节点
            preNode = node;
            // 继续链表的下一个节点
            node = node->next;
        }
    }
}

解法二核心代码：

/**
 * 删除单链表中所有值为 x 的节点
 * @param list 单链表
 * @param x 指定值
 */
void deleteAllByEle(LNode **list, int x) {
    // 单链表的第一个结点
    LNode *node = (*list)->next;

    // 初始化另外一个单链表
    (*list)->next = NULL;
    // 保存新链表的尾节点
    LNode *tailNode = *list;

    // 从头到尾遍历 node 所表示的单链表，然后将值不是 x 的结点插入到新链表中
    while (node != NULL) {
        // 如果当前节点的值不为 x 则插入到新链表中
        if (node->data != x) {
            // 临时保存当前节点的后继节点，用于继续遍历链表的下一个节点
            LNode *temp = node->next;

            // 创建新节点并指定数据域和指针域
            LNode *newNode = (LNode *) malloc(sizeof(LNode));
            newNode->next = NULL;
            newNode->data = node->data;
            // 将新节点插入到新链表的尾部
            tailNode->next = newNode;
            tailNode = newNode;// 将 tailNode 指向新节点，记录新节点才是链表的尾节点

            // 释放当前节点的空间
            free(node);
            // 继续链表的下一个节点
            node = temp;
        } else {
            // 继续链表的下一个节点
            node = node->next;
        }
    }
}

完整代码：

#include <stdio.h>
#include <malloc.h>

/**
 * 单链表节点
 */
typedef struct LNode {
    /**
     * 单链表节点的数据域
     */
    int data;
    /**
     * 单链表节点的的指针域，指向当前节点的后继节点
     */
    struct LNode *next;
} LNode;

/**
 * 通过尾插法创建单链表
 * @param list 单链表
 * @param nums 创建单链表时插入的数据数组
 * @param n 数组长度
 * @return 创建好的单链表
 */
LNode *createByTail(LNode **list, int nums[], int n) {
    // 1.初始化单链表
    // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
    *list = (LNode *) malloc(sizeof(LNode));
    (*list)->next = NULL;

    // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
    // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
    LNode *node = (*list);

    // 2.循环数组，将所有数依次插入到链表的尾部
    for (int i = 0; i < n; i++) {
        // 2.1 创建新节点，并指定数据域和指针域
        // 2.1.1 创建新节点，为其分配空间
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        // 2.1.2 为新节点指定数据域
        newNode->data = nums[i];
        // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
        newNode->next = NULL;

        // 2.2 将新节点插入到单链表的尾部
        // 2.2.1 将链表原尾节点的 next 指针指向新节点
        node->next = newNode;
        // 2.2.2 将新节点置为新的尾节点
        node = newNode;
    }
    return *list;
}

/**
 * 删除单链表中所有值为 x 的节点
 * @param list 单链表
 * @param x 指定值
 */
void deleteAllByEle(LNode **list, int x) {
    // 变量，记录链表的每个节点，从头到尾进行扫描
    LNode *node = (*list)->next;
    // 变量，记录 node 节点的前驱节点
    LNode *preNode = *list;

    // 从头到尾扫描单链表
    while (node != NULL) {
        // 判断当前节点的数据域是 x
        if (node->data == x) {
            // 保存待删除的节点，用于释放空间
            LNode *temp = node;
            // 删除 node 节点
            preNode->next = node->next;
            // 继续链表的下一个节点
            node = node->next;
            // 释放被删除节点的空间
            free(temp);
        }
            // 如果当前节点的数据域不是 x
        else {
            // 保存前驱节点
            preNode = node;
            // 继续链表的下一个节点
            node = node->next;
        }
    }
}

/**
 * 打印链表的所有节点
 * @param list 单链表
 */
void print(LNode *list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    // 声明单链表
    LNode *list;
    int nums[] = {1, 2, 2, 3, 2, 4, 2, 5};
    int n = 8;
    createByTail(&list, nums, n);
    print(list);

    // 调用函数，删除值为 x 的所有结点
    int x = 2;
    deleteAllByEle(&list, x);
    print(list);
}

执行结果：

[1, 2, 2, 3, 2, 4, 2, 5]
[1, 3, 4, 5]

注意：在数据结构题目中更倾向于使用 *& 引用来修改单链表，而不是使用指向指针的指针 **。尽管那属于 C++ 中的知识。

#include <stdio.h>
#include <malloc.h>

/**
 * 单链表节点
 */
typedef struct LNode {
    /**
     * 单链表节点的数据域
     */
    int data;
    /**
     * 单链表节点的的指针域，指向当前节点的后继节点
     */
    struct LNode *next;
} LNode;

/**
 * 通过尾插法创建单链表
 * @param list 单链表
 * @param nums 创建单链表时插入的数据数组
 * @param n 数组长度
 * @return 创建好的单链表
 */
LNode *createByTail(LNode *&list, int nums[], int n) {
    // 1.初始化单链表
    // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
    list = (LNode *) malloc(sizeof(LNode));
    list->next = NULL;

    // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
    // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
    LNode *node = list;

    // 2.循环数组，将所有数依次插入到链表的尾部
    for (int i = 0; i < n; i++) {
        // 2.1 创建新节点，并指定数据域和指针域
        // 2.1.1 创建新节点，为其分配空间
        LNode *newNode = (LNode *) malloc(sizeof(LNode));
        // 2.1.2 为新节点指定数据域
        newNode->data = nums[i];
        // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
        newNode->next = NULL;

        // 2.2 将新节点插入到单链表的尾部
        // 2.2.1 将链表原尾节点的 next 指针指向新节点
        node->next = newNode;
        // 2.2.2 将新节点置为新的尾节点
        node = newNode;
    }
    return list;
}

/**
 * 删除单链表中所有值为 x 的节点
 * @param list 单链表
 * @param x 指定值
 */
void deleteAllByEle(LNode *&list, int x) {
    // 变量，记录链表的每个节点，从头到尾进行扫描
    LNode *node = list->next;
    // 变量，记录 node 节点的前驱节点
    LNode *preNode = list;

    // 从头到尾扫描单链表
    while (node != NULL) {
        // 判断当前节点的数据域是 x
        if (node->data == x) {
            // 保存待删除的节点，用于释放空间
            LNode *temp = node;
            // 删除 node 节点
            preNode->next = node->next;
            // 继续链表的下一个节点
            node = node->next;
            // 释放被删除节点的空间
            free(temp);
        }
            // 如果当前节点的数据域不是 x
        else {
            // 保存前驱节点
            preNode = node;
            // 继续链表的下一个节点
            node = node->next;
        }
    }
}

/**
 * 打印链表的所有节点
 * @param list 单链表
 */
void print(LNode *list) {
    printf("[");
    // 链表的第一个节点
    LNode *node = list->next;
    // 循环单链表所有节点，打印值
    while (node != NULL) {
        printf("%d", node->data);
        if (node->next != NULL) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    // 声明单链表
    LNode *list;
    int nums[] = {1, 2, 2, 3, 2, 4, 2, 5};
    int n = 8;
    createByTail(list, nums, n);
    print(list);

    // 调用函数，删除值为 x 的所有结点
    int x = 2;
    deleteAllByEle(list, x);
    print(list);
}

Java实现

核心代码：

    /**
 * 删除单链表中所有值为 x 的节点
 *
 * @param x 指定值
 */
public void deleteAllByEle(int x){
        // 变量，记录链表的每一个节点，初始为链表的第一个节点
        LNode node=list.next;
        // 变量，记录前驱节点，初始为链表的头结点
        LNode preNode=list;

        // 循环单链表
        while(node!=null){
        // 找到值为 x 的节点
        if(node.data==x){
        // 保存待删除结点，用于释放空间
        LNode temp=node;
        // 删除节点
        preNode.next=node.next;
        // 继续链表的下一个节点
        node=node.next;
        // 释放被删除节点的空间
        temp.next=null;
        temp=null;
        }
        // 如果不是值为 x 的节点
        else{
        // 则保存前驱节点
        preNode=node;
        // 继续写链表的下一个节点
        node=node.next;
        }
        }
        }

完整代码：

/**
 * @author lcl100
 * @create 2022-03-01 21:32
 */
public class LinkedList {
    /**
     * 单链表
     */
    private LNode list;

    /**
     * 通过尾插法创建单链表
     *
     * @param nums 创建单链表时插入的数据
     * @return 创建好的单链表
     */
    public LNode createByTail(int... nums) {
        // 1.初始化单链表
        // 创建链表必须要先初始化链表，也可以选择直接调用 init() 函数
        list = new LNode();
        list.next = null;

        // 尾插法，必须知道链表的尾节点（即链表的最后一个节点），初始时，单链表的头结点就是尾节点
        // 因为在单链表中插入节点我们必须知道前驱节点，而头插法中的前驱节点一直是头节点，但尾插法中要在单链表的末尾插入新节点，所以前驱节点一直都是链表的最后一个节点，而链表的最后一个节点由于链表插入新节点会一直变化
        LNode tailNode = list;

        // 2.循环数组，将所有数依次插入到链表的尾部
        for (int i = 0; i < nums.length; i++) {
            // 2.1 创建新节点，并指定数据域和指针域
            // 2.1.1 创建新节点，为其分配空间
            LNode newNode = new LNode();
            // 2.1.2 为新节点指定数据域
            newNode.data = nums[i];
            // 2.1.3 为新节点指定指针域，新节点的指针域初始时设置为 null
            newNode.next = null;

            // 2.2 将新节点插入到单链表的尾部
            // 2.2.1 将链表原尾节点的 next 指针指向新节点
            tailNode.next = newNode;
            // 2.2.2 将新节点置为新的尾节点
            tailNode = newNode;
        }

        return list;
    }

    /**
     * 删除单链表中所有值为 x 的节点
     *
     * @param x 指定值
     */
    public void deleteAllByEle(int x) {
        // 变量，记录链表的每一个节点，初始为链表的第一个节点
        LNode node = list.next;
        // 变量，记录前驱节点，初始为链表的头结点
        LNode preNode = list;

        // 循环单链表
        while (node != null) {
            // 找到值为 x 的节点
            if (node.data == x) {
                // 保存待删除结点，用于释放空间
                LNode temp = node;
                // 删除节点
                preNode.next = node.next;
                // 继续链表的下一个节点
                node = node.next;
                // 释放被删除节点的空间
                temp.next = null;
                temp = null;
            }
            // 如果不是值为 x 的节点
            else {
                // 则保存前驱节点
                preNode = node;
                // 继续写链表的下一个节点
                node = node.next;
            }
        }
    }

    /**
     * 打印单链表所有节点
     */
    public void print() {
        // 链表的第一个节点
        LNode node = list.next;
        // 循环打印
        String str = "[";
        while (node != null) {
            // 拼接节点的数据域
            str += node.data;
            // 只要不是最后一个节点，那么就在每个节点的数据域后面添加一个分号，用于分隔字符串
            if (node.next != null) {
                str += ", ";
            }
            // 继续链表的下一个节点
            node = node.next;
        }
        str += "]";
        // 打印链表
        System.out.println(str);
    }
}

/**
 * 单链表的节点
 */
class LNode {
    /**
     * 链表的数据域，暂时指定为 int 类型，因为 Java 支持泛型，可以指定为泛型，就能支持更多的类型了
     */
    int data;
    /**
     * 链表的指针域，指向该节点的下一个节点
     */
    LNode next;
}

测试代码：

public class LinkedListTest {
    public static void main(String[] args) {
        // 创建单链表
        LinkedList list = new LinkedList();
        list.createByTail(1, 2, 2, 5, 2, 7, 2);
        list.print();

        // 删除链表中所有值为 x 的节点
        int x = 2;
        list.deleteAllByEle(x);
        list.print();
    }
}

执行结果：

[1, 2, 2, 5, 2, 7, 2]
[1, 5, 7]
二木成林
关注
  • 1
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表的链式实现-----单链表
07-02
6. 打印链表：输出链表中所有节点的值。 7. 销毁链表：释放链表及其所有节点的内存。 `LinkList.c`中的实现可能会包括这些函数的定义，例如： ```c // 初始化空链表 ListNode* createEmptyList() { return NULL; ...
数据结构【链表01】----删除单链表中所有值为x的节点
realttr的博客
03-07 7673
问题描述： 在带头结点的单链表L中，删除所有值为x的节点，并释放其内存空间，假设值为x的节点不唯一，试编写算法实现上述代码。 问题分析 使用pre指针指向头节点，用pre->next逐个扫描，如果pre->next节点的值为x，pre指针指向pre->next->next，删除pre->next指针，然后释放pre->next这个节点。如果pre->next的值不为x则pre往后移动一个节点 为了简化算法，可以引用p指针表示pre节点的后继指针，为了释放p指针的内存
王道考研408 数据结构 2.3 链表练习题
weixin_46524058的博客
09-28 1362
太长不看
王道：在带头结点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的结点不唯一，试编写算法以实现上述操作
江冷易水寒
08-05 2715
思路：设置两个节点pre和p，分别用来记录链表L的前驱节点和当前节点，当找到数据X时，将pre指向p的下一个节点,p移动到p的下一个节点（因为p将要被释放），如下图： 代码： void del_x(LinkList* L,int x){ LinkList* p = L->next; LinkList* pre = L; while(p != NULL){ if(p->data == x){ LinkList* q = p;
C语言(每日一题)——数据结构——在一条创建好的单链表中删除所有值为x的节点(详细过程)
yingyang20010112的博客
07-16 1290
代码】C语言(每日一题)——数据结构——在一条创建好的单链表中删除所有值为x的节点(详细过程)
在带头结点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的结点不唯一，试编写算法以实现上述操作
热门推荐
WANG的博客
06-30 1万+
标准答案有两种解法，解法一：    用p从头到尾扫描单链表，pre指向*p结点的前驱。若p所指结点的值为x，则删除，并让p指向下个结点，否则让pre和p指针同步后移一个结点。解法二：    采用尾插法建立单链表，用p指针扫描L的所有结点，当其值不为x时将其链接到L之后，否则将其释放。我个人的解法更偏向于使用p指针指向头指针，判断p-next是否为空或者值为x，如果为空则return，如果不为x则让...
删除线性表中所有值为X的元素
11-14
本人小白，所写东西完全为练习数据结构，欢迎批评指正，若转载请注明出处，还望各位大佬指教，共同学习进步
数据结构---线性表之单链表（C语言）
03-28
单链表是数据结构中的一种基础类型，尤其在C语言编程中经常被使用。它是一种线性的、非连续的数据组织形式，每个元素称为节点，每个节点包含数据和一个指向下一个节点的指针。本篇文章将深入探讨单链表的创建、插入...
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
5. 线性表的操作：对线性表的基本操作包括构造空表、销毁表、清空表、判断表是否为空、获取表的长度、获取表中的元素、查找表中的元素等。 6. 构造空表：使用C语言实现构造空表的函数InitList，包括产生头结点、...
数据结构—删除带头节点单链表中所有值为x的元素
最新发布
qq_55299191的博客
12-02 218
/递归执行下一个节点的操作。//递归继续执行操作。==null) //递归的出口。
（图解）单链表删除结点值为x的结点算法
在夜里行走的博客
10-11 6009
图解算法
在带头结点的单链表L中，删除所有值为x的结点，并释放空间，假设值为x的结点不唯一。
qq_30464221的博客
12-15 1497
算法思想：遍历单链表，遇到值为x的就删除。 Del_x(Linklist &L,Elemtype x){ Lnode *p=L->next,*pre=L,*q; while(p!=NULL){ if(p->data==x){ q=p; //q指向该结点 p=p->next; pre->next=p;//删除*q结点 free(p);//释放*q结点 } else{//否则，pre和p后移
在带头结点的单链表中删除所有值为x的结点
zhaoxk88的博客
05-13 6699
个人代码如下所示，欢迎大佬指正。 #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) {
算法-链表 在带头结点的单链表L中，删除所有值为X的结点，并释放其空间。
weixin_41263532的博客
12-08 2770
在带头结点的单链表L中，删除所有值为X的结点，并释放其空间，假设值为X的结点不唯一 //方法一：从头到尾扫描单链表 void delete(LinkList &L,Elemtype x) { //判断 //实现过程 LinkNode *p=L->next; LinkNode *pre=L; LinkNode *q; //前驱结点和当前结点一起出发 while(p) { if(p->data==x)
C语言：删除线性链表中数据域为 item 的所有结点
零小唬的博客
10-14 579
删除线性链表中数据域为 item 的所有结点
在单链表中删除值为x的节点
我要好好当个计院狗
10-03 6065
一、题目 再带头节点的单链表L中，删除所有值为x的节点，并释放其空间，假设值为x的节点不唯一，试编写算法以实现上述操作。 二、分析 题目非常简单，只要熟悉单链表的基本操作就可以很快解决这个问题。 三、代码 #include<stdio.h> #include<stdlib.h> //对单链表的定义 typedef struct LinkNode{ int data; LinkNode *next; }LinkNode,*LinkList; //对单链..
单链表删除值为x的结点
花间半盘棋
10-21 3916
01.单链表删除值为x的结点（代码题） 题目：在带头结点的单链表L中，删除所有值为x的结点，并释放其空间，假设值为x的结点不唯一，试编写算法实现上述操作。 算法思想：循环链表，标记待删除的结点x，并用p结点来覆盖标记x的结点，若循环到的结点不是x，则p和p的前驱结点分别向后移动一位，然后再次进行新的循环。 代码实现： void Del_x(Linklist &L, ElemType x){ LNode *p=L->next, *pre=L, *q; //p用来遍历链表 //pre指向前
删除单链表（带头结点）中值为x的结点
m0_64640755的博客
07-23 330
【代码】删除单链表（带头结点）中值为x的结点。
删除线性表中所有值为x的元素
03-26
算法思想：扫描线性表，若当前值不是x，则将其加入到新表中；若是x，则跳过，最终返回新表。 具体步骤： 1. 初始化一个新的线性表result，用来存储不是x的元素。 2. 从原线性表中循环扫描每个元素，如果它的值不是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值