Java程序练习-删除所有大于mink且小于maxk的元素

最新推荐文章于 2025-12-02 15:55:42 发布
最新推荐文章于 2025-12-02 15:55:42 发布 · 423 阅读 · 0
文章标签：

#java #数据结构与算法

本文介绍了一种算法，用于在递增有序的线性单链表中删除所有大于mink且小于maxk的元素。算法通过遍历链表并检查每个元素是否符合删除条件来实现。若链表中存在符合条件的元素，则输出修改后的链表；若不存在，则输出特殊标识。此过程展示了链表操作和条件判断的基本应用。
描述
已知线性单链表中的元素（整数）以递增有序排列(元素个数用户输入），编写算法删除表中所有大于mink且小于maxk的元素（若表中存在这样的元素）,不存在则输出单词Nobeing，如果没有元素了，则输出null
输入
6
1 2 3 4 5 6
2 5
输出
1 2 5 6
参考代码
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; public class Main { public static void main(String[] args) throws IOException { BufferedReader cin = new BufferedReader(new InputStreamReader(System.in)); int n = Integer.parseInt(cin.readLine()); String ds[] = cin.readLine().split(" "); List<Integer> list = new ArrayList<Integer>(); for(int i = 0;i < ds.length;i ++){ list.add(Integer.parseInt(ds[i])); } Collections.sort(list); String sn[] = cin.readLine().split(" "); int min = Integer.parseInt(sn[0]); int max = Integer.parseInt(sn[1]); Iterator<Integer> it = list.iterator(); boolean has = true; boolean flag = true; while(it.hasNext()){ int val = it.next(); if(!(val > min && val < max)){ flag = false; }else{ has = false; } } if(has){ System.out.println("Nobeing"); }else{ it = list.iterator(); while(it.hasNext()){ int val = it.next(); if(!(val > min && val < max)){ System.out.print(val+" "); flag = false; } } if(flag){ System.out.print("null"); } System.out.println(); } } }
iteye_2060
关注
递增有序的单链表中删除值介于MINK和MAXK之间的.cpp
11-28
递增有序的单链表中删除值介于MINK和MAXK之间的.cpp
带头结点的单循环链表,删除所有值大于min,小于max的结点的算法
04-12
一个带头结点的单循环链表，结点类型为(data.next),以haed为头指针，每个结点的data域存放的是一个整数，试构造一个删除所有值大于min,小于max的结点的算法
C语言：找出单链表的最大值MAX（随机输入）
weixin_55797565的博客
10-29 2225
#include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXSIZE 10 #define OK 1 #define ERROR 0 #define T 1 #define F -1 typedef int Status; struct Student { int id; }; typedef struct Dlist { Student data; struct Dlist* .
数据结构 :删除单链表中所有值大于mink且小于maxk的元素
匿名攻城狮
03-21 1万+
要求：设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。 [题目分析] 分别查找第一个值>mink的结点和第一个值 ≥maxk的结点，再修改指针，删除值大于mink且小于maxk的所有元素。 算法描述： void delete(LinkList &L, int mink, int ma...
数据结构 — 4.删除单链表中所有值大于mink且小于maxk的元素
PeersLee的博客
10-27 1万+
【问题描述】已知线性表中的元素以值非递减有序排列,并以单链表作为存储结构(含头结点),试写一高效的算法,删除 表中所有值大于mink且小于maxk的元素(若表中存在这样的元素),同时释放被删结点空间(注意:mink和maxk是给定 的两个参变量,它们的值可以和表中的元素相同,也可以不同.)   这里注意是大于且小于,没有等于. 【输入形式】第一行:非递减序列以-1结束 第二行为 mink
数据结构第二章线性表（三）①逆序打印单链表②删除单链表中大于minK且小于maxK的元素③双循环链表是否对称
Happy_change的博客
01-09 872
顺序表插入并递增有序 已知顺序表L中的元素递增有序排列，设计算法将元素x插入到表L中并保持表L仍递增有序。 /*顺序表插入并递增有序 已知顺序表L中的元素递增有序排列，设计算法将 元素x插入到表L中并保持表L仍递增有序。 */ #include <iostream> using namespace std; const int MaxSize=100; typedef int DataType; DataType data[MaxSize]; int length=0; void inser
数据结构：在单链表中删除mink～maxk之间的元素
三岁ღ的博客
03-24 3113
在单链表中删除mink～maxk之间的元素 前言 用于个人学习过程记录 题目 输入若干个值不超过1000的整数，建立递增有序的单链表，设计一个高效的算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素），mink和maxk可以与表中的元素相同，也可以不同。 测试数据不包含下面两种特殊情况： （1）mink大于最后一个数； （2）maxk小于第一个数。 输入格式: 首先输入一个整数T，表示测试数据的组数，然后是T组测试数据。每组测试数据首先在第一行上输入数据个数n及n个递增有序的整数，存
2.8设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素(mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同)。
m0_70061356的博客
10-01 642
【代码】2.8设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素(mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同)。
数据结构—习题2.8 删除递增有序链表中值大于mink且小于maxk的所有元素
热门推荐
小虾米编程
07-03 1万+
1.题目描述 设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。 2.题目分析 分别查找第一个值>mink的结点和第一个值 ≥maxk的结点，再修改指针，删除值大于mink且小于maxk的所有元素。 ​ void Delete(LinkList &L, int mink, int...
设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。
weixin_45672225的博客
11-03 1万+
题目：设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。 思路：题目所说链表是递增的，所以符合删除条件的结点必定连在一起，所以我们可以先找到待删除区间，之后把前后两部分接起来就好了。 代码如下: ```c void deletenode(Linklist& L, int mink, int maxk) { Linklist q, p = L->next; Linklist pre= (L.
C语言：删除有序链表大于mink小于maxk的数
weixin_55797565的博客
10-30 2160
将链表变成有序链表并定义mink和maxk，删除大于mink和小于maxk的数据，mink和maxk可不与链表数据相同。 //代码 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAXSIZE 10 #define OK 1 #define ERROR 0 #define T 1 #define F -1 typedef int Status; typedef struct Dli
（8）设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。
qq_47142993的博客
08-04 4921
（8）设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同 ）。 【算法思想】 用一个节点pre保存pa的前驱，方便删除。 具体流程完整代码运行结果 完整代码 #include <iostream> using namespace std; //定义存储 typedef struct LNode { int date; struct LNode *next; } Lnode, *Linkl
删除链表中满足区间值的结点
m0_53354306的博客
11-02 1076
描述 利用单链表表示一个递增的整数序列，删除链表中值大于等于mink且小于等于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同）。 输入 多组数据，每组数据有两行，第一行为链表的长度n，第二行为链表的n个元素（元素之间用空格分隔），第三行为给定的mink和maxk（用空格分隔）。当n=0时输入结束。 输出 对于每组数据分别输出一行，依次输出删除元素后的链表元素，元素之间用空格分隔。 输入样例 1 5 1 2 3 4 5 2 4 6 2 4...
通过一趟遍历确定单链表中值最大的结点
weixin_42048463的博客
05-21 3425
[程序代码] #include<stdio.h> #include<stdlib.h> short InitHeadNode(struct Node* &, struct Node* &); short Traversal(struct Node* &); short RearInsert(struct Node* &, struct Node* &, short); short GetListLength(struct Node* &a.
单链表删除节点值为mink和maxk之间的节点
EltonQu的博客
04-12 1649
#include<iostream> using namespace std; typedef struct Node { int data; struct Node *next; }Node; typedef struct Node* LinkList; //指针类型取别名 LinkList creatList(LinkList head, int n) { ...
设计一个算法，删除递增有序链表中值大于mink且小于maxk的所有元素（mink和maxk是给定的两个参数，其值可以和表中的元素相同，也可以不同）。
Carlos的博客
10-29 6066
语言：C++ #include &lt;iostream&gt; using namespace std; typedef struct LNode { int data; LNode *next; }LNode,*LinkList; //创建链表 int CreateList(LinkList &amp;L,int n) { LNode *p,*r;int i; L=new LN...
递增单链表删除所有大于mink且小于maxK的元素。
Rhythm_Lin的专栏
08-26 6601
Status ListDelete_L(LinkList &L,ElemType mink,ElemType maxk) {//这个算法实现了每移动一次辅助指针p,就释放空间。 LinkList p,q,prev=NULL; if(mink>maxk)return ERROR; p=L; prev=p; p=p->next; while(p&&p->data<maxk){ if(p
TensorRT笔记（5）：研究timingCache
最新发布
ouliten的博客
12-02 364
在里出现了大量的timingCache，但是当时没有取研究这是干啥的，本文就来解析一下。样例都基于上面的文章。
删除单链表中所有值大于mink且小于maxk的元素
06-28
### 回答1： 可以使用双指针法遍历单链表，找到需要删除的节点，然后删除即可。具体步骤如下： 1. 定义两个指针，分别指向单链表的头节点和前驱节点。 2. 遍历单链表，如果当前节点的值大于mink且小于maxk，则删除该节点，即将前驱节点的next指针指向当前节点的next指针。 3. 如果当前节点的值不满足条件，则将前驱节点指向当前节点，继续遍历下一个节点。 4. 最后返回单链表的头节点即可。 代码实现如下： ``` ListNode* deleteNodes(ListNode* head, int mink, int maxk) { ListNode* dummy = new ListNode(); dummy->next = head; ListNode* pre = dummy; ListNode* cur = head; while (cur) { if (cur->val > mink && cur->val < maxk) { pre->next = cur->next; cur = pre->next; } else { pre = cur; cur = cur->next; } } return dummy->next; } ``` ### 回答2： 单链表是由节点构成的一个链式结构，每个节点包含一个数据元素和一个指向下一个节点的指针。删除单链表中所有值大于mink且小于maxk的元素可以采用遍历单链表的方法，逐一检查每个节点的值并判断是否在范围内，如果是则删除该节点。 具体步骤如下： 1. 定义一个指针pre指向单链表的头结点，一个指针cur指向第一个节点，一个指针tmp用于存储需要删除的节点。 2. 从头结点开始遍历单链表，检查每个节点的值是否在范围内，如果是则将该节点从单链表中删除。 3. 如果节点的值符合要求，则将节点从单链表中删除，具体方法为将pre的指针指向cur的下一个节点，然后释放cur节点占用的空间。 4. 如果节点的值不符合要求，则将pre和cur指针分别后移，继续查找下一个节点。 5. 最后返回单链表的头结点即可。 删除节点的代码如下： ``` if (cur->data > mink && cur->data < maxk) { // 如果节点的值在范围内 pre->next = cur->next; // 将pre指向cur的下一个节点 tmp = cur; // 用tmp指针暂存需要删除的节点 cur = pre->next; // 将cur指针后移 free(tmp); // 释放节点占用的空间 } else { // 如果节点的值不在范围内 pre = cur; // 将pre指针后移 cur = cur->next; // 将cur指针后移 } ``` 完整代码如下： ```c struct ListNode* removeElements(struct ListNode* head, int mink, int maxk) { struct ListNode* pre = (struct ListNode*)malloc(sizeof(struct ListNode)); // 定义一个头结点 pre->next = head; // 将头结点指向原始链表 struct ListNode* cur = head; // 定义一个指针cur指向第一个节点 struct ListNode* tmp = NULL; // 定义一个指针tmp用于存储需要删除的节点 head = pre; // 将头指针指向头结点 while (cur != NULL) { // 遍历单链表 if (cur->data > mink && cur->data < maxk) { // 如果节点的值在范围内 pre->next = cur->next; // 将pre指向cur的下一个节点 tmp = cur; // 用tmp指针暂存需要删除的节点 cur = pre->next; // 将cur指针后移 free(tmp); // 释放节点占用的空间 } else { // 如果节点的值不在范围内 pre = cur; // 将pre指针后移 cur = cur->next; // 将cur指针后移 } } return head->next; // 返回单链表的头结点 } ``` 该算法的时间复杂度为O(n)，其中n为单链表的长度。删除单链表中所有值大于mink且小于maxk的元素可以有效地提高单链表的查询和操作效率，能满足实际应用的需求。 ### 回答3： 单链表是一种常见的数据结构，由许多节点构成，每个节点包含一个数据元素和一个指向下一个节点的指针。删除单链表中所有值大于mink且小于maxk的元素，需要遍历单链表，找到符合条件的节点并删除。 我们可以使用两个指针，一个指向当前节点，一个指向前一个节点，依次遍历单链表。对于当前节点，如果它的数据元素的值大于mink且小于maxk，那么将前一个节点的指针指向当前节点的下一个节点，即删除当前节点。否则，两个指针同时后移，继续遍历下一个节点。 需要注意的是，如果单链表的第一个节点符合条件，那么我们需要特殊处理，将头节点的指针指向第二个节点。另外，如果单链表的所有节点都符合条件，那么删除后会得到一个空链表。 时间复杂度为O(n)，其中n为单链表中元素的个数。以下是具体的实现代码： ```python class Node: def __init__(self, value): self.value = value self.next = None def delete_between(head, mink, maxk): while head and head.value > mink and head.value < maxk: head = head.next curr = head prev = None while curr: if curr.value > mink and curr.value < maxk: prev.next = curr.next curr = curr.next else: prev = curr curr = curr.next return head ``` 需要注意的是，以上代码中的return语句返回的是删除完成后的单链表的头节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值