线性表练习之Example019-删除单链表中所有介于给定两个值之间的元素的元素

于 2022-03-28 20:41:31 发布
阅读量728 收藏 5
点赞数
分类专栏： 数据结构 文章标签： java c 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123805263
版权

Example019

原文链接：Example019

题目

设在一个带表头结点的单链表中所有元素结点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值（作为函数参数给出）之间的元素的元素（若存在）。

分析

本题考查的知识点：

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

分析：

  • 其实本题和删除单链表中所有等于指定值的节点的题目是一样的解法，只是本题中待删除的节点的数据域值在一个范围内，而非指定某个值。
  • 设定两个指针 node 和 preNode，其中 node 指向链表中的每个节点，preNode 指向 node 节点的前驱节点。
  • 从头到尾进行扫描单链表，判断正在迭代的节点的数据域值是否在指定范围内，如果是则删除该节点并且让 node 移到链表的下一个节点；如果不是则将 preNode 和 node 节点都向后移动一个节点。
  • 直至单链表被扫描完毕。

图解

请添加图片描述

C实现

核心代码：

/**
 * 删除链表中所有介于给定的两个值之间的元素
 * @param list 单链表
 * @param a 指定的第一个元素，不包含该元素本身
 * @param b 指定的第二个元素，不包含该元素本身
 */
void deleteByRange(LNode **list, int a, int b) {
    // 变量，记录链表的每一个节点，从头到尾扫描单链表，初始为链表的第一个节点
    LNode *node = (*list)->next;
    // 变量，记录链表节点的前驱节点，初始为链表的头结点
    LNode *preNode = (*list);

    // 从头到尾扫描单链表
    while (node != NULL) {
        // 如果是被删除节点则进行删除
        if (node->data > a && node->data < b) {
            // 局部变量，临时保存当前节点的后继节点
            LNode *temp = node->next;

            // 删除 node 节点
            preNode->next = node->next;
            // 释放结点空间
            free(node);

             // 继续链表的下一个节点
            node = temp;
        }
        // 如果不是被删除节点，则继续链表的下一个节点
        else {
            preNode = node;
            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;
}

/**
 * 删除链表中所有介于给定的两个值之间的元素
 * @param list 单链表
 * @param a 指定的第一个元素，不包含该元素本身
 * @param b 指定的第二个元素，不包含该元素本身
 */
void deleteByRange(LNode **list, int a, int b) {
    // 变量，记录链表的每一个节点，从头到尾扫描单链表，初始为链表的第一个节点
    LNode *node = (*list)->next;
    // 变量，记录链表节点的前驱节点，初始为链表的头结点
    LNode *preNode = (*list);

    // 从头到尾扫描单链表
    while (node != NULL) {
        // 如果是被删除节点则进行删除
        if (node->data > a && node->data < b) {
            // 局部变量，临时保存当前节点的后继节点
            LNode *temp = node->next;

            // 删除 node 节点
            preNode->next = node->next;
            // 释放结点空间
            free(node);

             // 继续链表的下一个节点
            node = temp;
        }
        // 如果不是被删除节点，则继续链表的下一个节点
        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);

    // 调用函数，删除指定范围内的所有结点
    deleteByRange(&list, 1, 3);
    print(list);
}

执行结果：

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

Java实现

核心代码：

    /**
     * 删除链表中所有介于给定的两个值之间的元素
     *
     * @param a 指定的第一个元素，不包含该元素本身
     * @param b 指定的第二个元素，不包含该元素本身
     */
    public void deleteByRange(int a, int b) {
        // 变量，记录链表的每一个节点，从头到尾扫描单链表，初始为链表的第一个节点
        LNode node = list.next;
        // 变量，记录链表节点的前驱节点，初始为链表的头结点
        LNode preNode = list;

        // 从头到尾扫描单链表
        while (node != null) {
            // 如果是被删除节点则进行删除
            if (node.data > a && node.data < b) {
                // 局部变量，临时保存当前节点的后继节点
                LNode temp = node.next;

                // 删除 node 节点
                preNode.next = node.next;
                // 释放节点空间
                node.next = null;

                // 继续链表的下一个节点
                node = temp;
            }
            // 如果不是被删除节点，则继续链表的下一个节点
            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;
    }

    /**
     * 删除链表中所有介于给定的两个值之间的元素
     *
     * @param a 指定的第一个元素，不包含该元素本身
     * @param b 指定的第二个元素，不包含该元素本身
     */
    public void deleteByRange(int a, int b) {
        // 变量，记录链表的每一个节点，从头到尾扫描单链表，初始为链表的第一个节点
        LNode node = list.next;
        // 变量，记录链表节点的前驱节点，初始为链表的头结点
        LNode preNode = list;

        // 从头到尾扫描单链表
        while (node != null) {
            // 如果是被删除节点则进行删除
            if (node.data > a && node.data < b) {
                // 局部变量，临时保存当前节点的后继节点
                LNode temp = node.next;

                // 删除 node 节点
                preNode.next = node.next;
                // 释放节点空间
                node.next = null;

                // 继续链表的下一个节点
                node = temp;
            }
            // 如果不是被删除节点，则继续链表的下一个节点
            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, 6, 5, 2, 7, 2);
        list.print();

        // 删除单链表中所有值在 (1, 6) 之间的元素
        list.deleteByRange(1, 6);
        list.print();
    }
}

执行结果：

[1, 2, 6, 5, 2, 7, 2]
[1, 6, 7]
二木成林
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】-单链表-删除链表中所有介于给定的两个值之间的节点
vector的博客
06-09 658
满足条件就删除，不满足就进入下一个节点 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; /*链表*/ LinkList List_TailInsert(LinkList L) { int x; L = (LinkList)malloc(sizeof(LNode)); L->next = NULL; LNode *s, *r = L; cout << "尾插法创建单链表："..
王道课后习题2.3.7：删除单链表中所有介于给定的两个值
qq_34941153的博客
08-21 449
题目描述： 设在一个带头结点的单链表中所有元素结点的数据值无序，删除表中所有介于给定的两个值（函数参数给出）之间的元素。 算法思想： 核心代码： void del_s_t(LNode* &L,int s,int t) { LNode* pre=L; LNode* p=L->next; while(p!=NULL) { if(p-&...
【数据结构】单链表—删除表中数值介于给定值之间的元素
qq_42000631的博客
09-23 1147
设在一个带头结点的单链表中所有元素结点的数据值无序，试编写一个函数，删除表中所有介于给定的两个值（作为函数参数给出）之间的元素的元素 //带头结点的单链表无序 //删除数比表中所有值介于在两个给定值（作为函数参数给出）之间的元素。 #include<stdio.h> #include<stdlib.h> struct Lnode { int data; Ln...
线性表删除 一个范围内的元素
weixin_44077170的博客
08-30 483
#include using namespace std; const int Max=50; typedef struct { int a[Max]; int length; }sqlist; void creat(sqlist &L,int n); void printlist(sqlist &L); void shanchu(sqlist &L,int x,int y...
c语言删除表中元素,线性表a中删除线性表b中出现的元素的c语言算法
weixin_39635130的博客
05-19 748
满意答案ooujfe2014.02.08采纳率：53%等级：12已帮助：40324人#include "windows.h"#include "stdio.h"#include "stdlib.h"#include "time.h"struct Node{int num;struct Node *next;};struct Node *CreateLink(int n){int i=0;s...
线性表的链式实现-----单链表
07-02
单链表的每个元素称为节点，每个节点包含两部分：数据域和指针域。数据域用于存储元素的值，而指针域则存储指向下一个节点的地址。链表的首节点称为头节点，最后一个节点的指针域通常为NULL，表示链表的结束。 在...
删除线性表中所有值为X的元素
11-14
本人小白，所写东西完全为练习数据结构，欢迎批评指正，若转载请注明出处，还望各位大佬指教，共同学习进步
数据结构C语言版-线性表的单链表存储结构表示和实现优质资料.doc
12-02
12. 查找表中的元素：使用C语言实现查找表中的元素的函数LocateElem，根据元素的值查找元素在表中的位置。 13. 获取元素的前驱：使用C语言实现获取元素的前驱的函数PriorElem，根据元素的值获取其前驱元素。 14. ...
有一个线性表(a1，a2，...，an)，它存储在有附加表头结点的单链表中，写一个算法，求出该线性表中值为x的元素的序号。如果x
09-27
有一个线性表(a1，a2，...，an)，它存储在有附加表头结点的单链表中，写一个算法，求出该线性表中值为x的元素的序号。如果x
递增有序的单链表中删除值介于MINK和MAXK之间的.cpp
11-28
递增有序的单链表中删除值介于MINK和MAXK之间的.cpp
删除单链表中介于 a 和 b 之间的所有节点 。。。此例与上一篇中删除单链表中所有值为x的类似，若要记住，只需改动 if 语句中的条件即可！
xinpx1457的博客
03-08 898
#include <stdio.h> #include <stdlib.h> typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList; LinkList L;//定义全局变量L， 可以省略参数传递； LinkList Head_insert() { LNo...
删除带头结点的单链表中所有介于给定两个值之间（作为函数参数给出）的元素（若存在），数据值无序。
qq_30464221的博客
12-16 370
算法：遍历后删除。 void RangeDelete(Linklist &L,int min,int max){ Lnode *p=L->next; Lnode *pre=L; while(p!=NUll){ if(p->data>min&&p->data<max){//寻找被删结点，删除 pre=p->next; free(p); p=pre->next; } else
无序链表删除介于给定两个值之间的元素
许你一片梁城的博客
09-18 212
无序链表删除介于给定两个值之间的元素 算法思路：三个指针，p：工作指针 pre：p的前驱指针 q：中间变量指针，用于删除节点 //无序链表删除介于给定两个值之间的元素 bool LinkList_DelA2B(LinkList &L,int A,int B){ if(A>B || L == NULL) return false; LNode *pre = L, *p = L->next, *q; while(p...
题目3  删除无序链表中，介于两值之间的节点
梦否
10-20 233
删除无序链表中，介于两值之间的节点 void del_between(Node*&amp; n, int a, int b){ //带头节点 Node *p, *q, *pre; pre=n; p=n-&gt;next; while(p!=NULL){ if(p-&gt;num&gt;=a and p-&gt;num&lt;=b){ q = p; p = p-&...
王道数据结构2.2.4——7、删除带头结点的无序单链表中大小介于给定两个值之间的元素
Hillbox
10-11 223
思路 边遍历，边删除 代码 void del_betw(LinkList &L, ElemType s, ElemType t){ LNode *p=L->next,*pre=L; while(p!=NULL){ if(p->data>s && p->data<t){ pre-&g...
删除单链表中所有值为x的元素
热门推荐
qq_31964815的博客
04-06 1万+
删除所有值为x的单链表中的元素 首先，我们先考虑第一种情况，就是说值删除第一个值为x的元素，这个比较简单， 只需要挨个比较x和链表节点的值，找到值相同的节点的前一个就可以删除这个节点了。 然后我们可以考虑两种办法第一种就是递归的去删除，这个比较简单，只需要删除第一个值和我们要删除的值一样的节点，然后把下一个节点当做头指针传先去就好了。 这个就不给与代码了。 那么，我们来考虑一下非递归
数据结构之删除线性表中的元素
weixin_30663391的博客
08-31 219
严蔚敏版教材，算法2.4，代码实现 #include <iostream> using namespace std; typedef int element; #define maxsize 100 typedef struct { element aa[maxsize]; int last; }sqlist; int main() { ...
线性表元素的区间删除
海马有力量的博客
04-05 794
给定一个顺序存储的线性表，请设计一个函数删除所有值大于min而且小于max的元素。删除后表中剩余元素保持顺序存储，并且相对位置不能改变。 函数接口定义： List Delete( List L, ElementType minD, ElementType maxD ); 其中List结构定义如下： typedef int Position; typedef struct LNode List; s...
利用C语言生成一个函数功能为删除线性表中介于a和b之间的所有元素
最新发布
05-27
下面是一个简单的C语言函数，可以实现删除线性表中介于a和b之间的所有元素的功能： ```c void delete_between_elements(int *list, int a, int b, int len) { int i, j; for (i = 0, j = 0; i ; i++) { if (list...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值