【数据结构】删除单链表（带头结点）的最小值

最新推荐文章于 2022-05-31 19:55:52 发布
最新推荐文章于 2022-05-31 19:55:52 发布
阅读量4.9k 收藏 28
点赞数 4
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_35564841/article/details/81209637
本文介绍了一种在链表中查找并删除最小值的方法。通过一次遍历找到最小值节点的前驱节点，随后进行删除操作。这种方法适用于单链表，并保持了原有链表结构的完整性。

思路：先遍历一遍链表，确定最小值的前驱节点，然后进行删除操作。

void deleteMin(LinkList List)
{
	LinkList L = List;//头节点
	LinkList Min = L;//用于存放最小节点的前一个节点
	while (List->next != NULL)
	{
		if (List->next->data < Min->next->data)//如果下一个节点的数据小于Min
		{
			Min = List;//更新Min为当前节点
		}
		List = List->next;//比较结束后，前进一格
	}
	LinkList temp = Min->next;//指向删除节点
	Min->next = temp->next;
	free(temp);
}

 

少年朱
关注
C语言实现单链表节点的删除（带头结点）
乞力马扎罗的雪CYF的博客
03-01 1万+
我在之前一篇博客《C语言实现单链表节点的删除（不带头结点）》中详细实现了如何在一个不带头结点的单链表的删除一个节点，在这一篇博客中我改成了带头结点的单链表。代码示例上传至 https://github.com/chenyufeng1991/DeleteLinkedList_HeadNode。删除类型有两种：（1）删除某个位置pos的节点；（2）判断x值是否在链表中，若存在则删除该节点；核心代码如下
单链表第一题（递归删除不带头节点链表中指定值）
loveajiao的博客
06-27 421
1.设计一个递归算法，删除不带头节点的单链表L中所有值为X的节点。
删除带头结点链表中最小值的结点
zillll的博客
04-20 1300
删除带头结点链表中最小值的结点 deletemin.c #include<stdio.h> #include<stdlib.h> #include"deletemin.h" LinkedList *create(void) { LinkedList *l = malloc(sizeof(*l)); l->first = NULL; l->last = NULL; element x; printf("请输入数据，以0结尾\n"
单链表-在带头结点的单链表L中删除一个最小值结点（四指针）
muyu_muyu的博客
12-16 2121
单链表的存储结构： typedef struct LinkList{ int data; LinkList * next; } 分析： 要删除一个链表的最小值节点，首先想到的是肯定是要定义两个指针，但是 ，这里首先要找到最小。 所以两个指针变量肯定不够。 肯定是先要找出最小值。 那么如何找出最小值呢？ 这里先定义pre 和p指针,然后定义minp保存最小节点指针（初值为p）,minpre指向*minp节点的前驱节点（初值为pre）。 思路: 1.定义四个指针变量
在带头结点的单链表中删除最小值结点
weixin_46390041的博客
03-10 5939
题目：试编写在带头结点的单链表中删除（一个）最小值结点的（高效）算法。void delete （Linklist &L）。 提示：假设第一个结点就是最小的，要高效，只能遍历一次，单链表中删除结点，必须知道待删除的最小结点的前一个结点，才能用前一个结点删掉它后一个结点，所以要定义一个指针。首先，本身就有一个头结点，假设有p,q,pre，p作为工作指针，q作为最小值的结点的指向，pre指向最小结点的前驱结点。 LinkList Delete (LinkList L){ LinkList p
删除链表最小值
北街lhy的博客
03-16 864
题目：删除链表中唯一的最小值 分析： 目前能想到的就是遍历整个链表，记录下最小节点的指针，然后进行删除，时间复杂度为O(n). 代码： struct Link { int data; struct Link* next; }; #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> void deleteMin(Link *p) { struct Link *preMi...
删除单链表（带头结点）的最小值结点
happy_bigqiang的博客
11-14 6042
题目：如题； 结果： ———-代码区#include <stdio.h> #include <stdlib.h>#define ERROR NULL typedef enum {false, true} bool; typedef int ElementType; typedef struct LNode *PtrToLNode; struct LNode { ElementType D
【数据结构】（单链表）带头结点删除最小值元素
你好丶下一秒
08-17 4518
算法思想：while 循环 找出最小节点的前驱节点 以及最小值节点 之后删除即可 void Delete_Min(LNode *&head ){ if(head ->next==NULL) return; LNode *pre=head ; //前驱结点 LNode *current=head ->next; //游标指针 LNode *min=head...
4·试编写在带头结点的单链表1中删除一个最小值结点的高效算法(假设最小值结点是唯一的)。
Anthony_4926
06-26 3839
4·试编写在带头结点的单链表1中删除一个最小值结点的高效算法(假设最小值结点是唯一的)。 #include<iostream> #include<algorithm> #include<cstdio> #include<cstring> #include<cmath> #include<map> #include<vector> #include<queue> #include<set> #inc
单链表：删除带头节点单链表中最小值所有在的节点
乐行僧的博客
11-08 1125
思路：用两对前驱和后继节点，分别比较当前节点的前驱和后继以及最小值界定啊的前驱和后继。 遍历完整个链表，删除最小值节点即可。 struct node { int val; node *next; }; void deleteMin(node *head) { node *p = head, *q = head->next; node *premin = head, *pmin =...
(转)问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。
zhaozhanyong的专栏
02-14 6601
问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。链表结点定义如下： struct ListNode {          int       m_nKey;          ListNode* m_pNext; }; 解答：假设给定的指针为pCurrent，ListNode* pNext = pCurrent->m_pNext； 由题意知，pCurrent指向链表的某一个中间节点，因此pCurr
删除链表中的最小值
R的博客
08-22 776
1.用一个保存最小值，一个保存最小值的前驱 #include <stdio.h> #include <stdlib.h> typedef struct LNode { int data; struct LNode* next; }LNode,*LinkList; LinkList CreateList() { LinkList L; L = (LinkLis...
删除带头结点的单链表最小值结点
嘻嘻呵呵的博客
08-29 4813
删除带头结点的单链表最小值结点 王道19数据结构 P44 删除带头结点的单链表最小值结点（假设最小值结点唯一） 书上给的答案无法应对单链表为空的情况 课本代码 LinkList DelMin(LinkList &amp;amp;amp;amp;amp;L){ LNode *pre = L, *p=pre-&amp;amp;amp;amp;gt;next; LNode *minpre = pre, *min = p; whi..
删除含有头结点的单链表中的最小值的结点
qq_42169456的博客
10-30 422
删除有头节点的单链表中的最小值的结点 #include <iostream> using namespace std; typedef struct node { int data; struct node *next; } LNode; void Del_minNode(LNode *L); LNode *CreateLink(const int data[], int n); void PrtLink(LNode *L); int main() { int
单链表-删除最小值
weixin_49229860的博客
05-31 852
单链表-删除最小值 题目 算法思想 遍历：两个指针：pre、p 删除：两个指针：minpre、minp 代码 typedef struct LNode{ ElemType data; struct Lnode* next; //指向下一个结点 }LNode, *LinkList; LinkList DeleteMin(LinkList& L) { Lnode* pre=L, * p=pre->next; Lnode* minpre=pre, * minp=p; while (
链表-删除最小值结点
qq_61706112的博客
09-10 298
/*试编写在带头结点的单链表L中删除一个最小值结点的高效算法(假设最小值结点是唯一的)*/ #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; LinkList TailCreateList(LinkList &L) { L = (LinkList).
删除链表中最小值的点
shouwang666666的博客
10-28 232
LinkList Select_Min(LinkList &L) { LNode *pre=L,*p=L->next; LNode *minPre=pre,*minP=p; while(p!=NULL){ if(p->data<minP->data){ minP=p; minPre=pre; } pre=p; p=p->next; .
删除单链表中最小的数
浮生未歇
03-20 2361
删除单链表中最小的值
数据结构：设有一个不带头结点的单链表L,设计两个递归算法，del(L,x)删除单链表L中第一个值为x的节点，delall(L,x)删除单链表L中的最小节点值。
热门推荐
Rivival_S 的博客
01-23 1万+
#include #include typedef struct Lnode //单链表结构体 { int data; struct Lnode* next; } LinkNode; void DispList(LinkNode*L) //输出函数 { LinkNode*p=L; while(p!=NULL) { printf("%d ",p->data); p=p
数据结构中 ，带头结点单链表查找最大或最小值并在之前或之后插入指定的值
最新发布
07-01
<think>首先，用户的问题是关于在带头结点的单链表中查找最大值或最小值，并在其之前或之后插入指定的值。我需要基于系统级指令来构建我的回答。系统级指令要求：-所有行内数学表达式使用$...$格式。-独立公式使用 $$...$$格式并单独成段。 -LaTeX语法正确。-使用中文回答。-生成相关问题。 -在回答中引用的段落末尾自然地添加引用标识，如[^1]。用户可见层要求： -回答结构清晰，帮助用户逐步解决问题。-尽量保证回答真实可靠。参考站内引用： -[^1]:关于HashMap的实现原理。 -[^2]:在带头结点单链表中查找最大值，将其与最后一个元素交换。 -[^3]:关于for循环在链表遍历中的使用。 用户的问题是基于引用[2]，因为它提到了在带头结点单链表中查找最大值。我需要参考这些引用，但用户的问题是插入值，而不是交换。用户的具体查询："我想在带头结点的单链表中查找最大值或最小值，并在其之前或之后插入指定的值"所以，我需要解释如何在带头结点的单链表中实现这个功能。步骤：1.**理解带头结点的单链表**：带头结点的单链表有一个头结点，它不存储数据，只指向第一个实际节点。这简化了操作，如插入和删除。2.**查找最大值或最小值**：遍历链表，找到最大或最小值的节点。 3. **插入指定值**：在找到的节点之前或之后插入新节点。在插入时： -**在之前插入**：需要找到目标节点的前驱节点。- **在之后插入**：直接插入在目标节点之后。由于链表是单向的，插入在之前需要遍历到前驱节点。现在，构建回答结构： -**介绍**：简要解释带头结点的单链表和操作。- **步骤分解**：-步骤1:定义链表结构。-步骤2:查找最大值或最小值。-步骤3:在之前或之后插入值。 -**代码示例**：提供伪代码或代码片段来展示实现。 -**注意事项**：讨论边界情况，如空链表、最大值在头结点后等。 -**生成相关问题**：在末尾添加相关问题。 使用中文回答。 生成相关问题：-基于用户的问题，生成一些相关问题，如优化、应用等。 引用标识：在回答中引用参考段落时添加。例如，引用[2]讨论了查找最大值，所以我可以引用它。参考引用：- [^2]描述了查找最大值和交换操作。 -[^3]描述了for循环遍历链表。我可以引用这些来支持我的解释。 代码示例：用户提供了引用中的代码片段，我应该提供相关的代码。在用户的问题中，没有提供具体代码，所以我需要创建代码示例。 最终回答结构：1.**开头**：解释操作。 2. **详细步骤**：分步说明。3.**代码实现**：用伪代码或C语言展示（因为引用[2]和[^3]使用C-like代码）。 4. **注意事项**。 5. **相关问题**。 确保数学表达式正确：在这个上下文中，可能没有太多数学，但如果有，比如时间复杂度，使用$O(n)$等。例如，查找最大值的时间复杂度是 $O(n)$，因为需要遍历链表。 在插入操作中，时间复杂度也是$O(n)$。现在，草拟回答。**回答草稿：** 在带头结点的单链表中查找最大值或最小值并在其之前或之后插入指定值，可以通过以下步骤实现。带头结点的单链表有一个头结点，它不存储数据，只指向第一个实际节点，这简化了插入和删除操作[^2]。 ###步骤分解1. **定义链表结构**：首先，定义一个节点结构体，包含数据域和指向下一个节点的指针。-例如：`struct Node{ intdata;struct Node*next;};`-头结点初始化：`structNode *head =(structNode*)malloc(sizeof(struct Node)); head->next= NULL;`2.**查找最大值或最小值**：遍历整个链表，找到具有最大或最小值的节点。-使用一个指针遍历链表，从第一个实际节点开始（`head->next`）。-初始化一个变量存储当前最大或最小值，并记录该节点。-遍历过程：`for(structNode *p =head->next;p !=NULL;p =p->next){ //比较数据}`-时间复杂度为$O(n)$，其中$n$是链表长度[^2]。 3. **插入指定值**：- **在之前插入**：找到目标节点的前驱节点。因为链表是单向的，需要从头结点开始遍历，找到目标节点的前一个节点。-然后，创建新节点，插入在目标节点之前。- **在之后插入**：直接创建新节点，插入在目标节点之后。-插入操作包括：创建新节点、调整指针。4.**处理边界情况**：-如果链表为空，插入操作需要特殊处理。-如果最大值是第一个节点，在之前插入需要修改头结点的指针。-如果最大值是最后一个节点，在之后插入需要处理NULL指针。###代码示例以下是伪代码实现：```c//定义节点结构structNode {intdata;structNode *next;}; //函数：在链表中查找最大值并在其之前插入新值voidinsertBeforeMax(structNode *head,int newValue){if (head ==NULL ||head->next ==NULL){//链表为空，直接插入新节点作为第一个节点structNode *newNode= (struct Node*)malloc(sizeof(structNode));newNode->data= newValue;newNode->next= head->next;head->next= newNode;return;}//查找最大值节点及其前驱struct Node*maxNode =head->next;//假设第一个节点是最大值structNode *prevMax= head;//最大值节点的前驱struct Node*current= head->next;structNode *prev =head;while(current!= NULL) {if(current->data> maxNode->data){maxNode= current;prevMax= prev;}prev =current;current= current->next;}//在最大值节点之前插入新节点struct Node*newNode =(structNode*)malloc(sizeof(struct Node));newNode->data =newValue;newNode->next =maxNode;prevMax->next= newNode; }//类似地，可以实现在最小值之后插入等函数```###注意事项-在插入之前，确保链表初始化正确。-遍历时，注意头结点的处理；头结点不存储数据，所以遍历从`head->next`开始。-时间复杂度：查找最大值$O(n)$，插入$O(1)$，但找到位置需要 $O(n)$，所以总复杂度 $O(n)$。-如果最大值有多个，此代码只处理第一个出现的最大值；如果需要处理所有，需要修改。###相关问题1.如何优化在链表中查找最大值并插入的操作？ 2.带头结点的单链表与不带头结点的链表在插入操作中有何区别？ 3.在实际应用中，这种操作有哪些使用场景？</think>### 在带头结点的单链表中查找最大值/最小值并插入指定值 在带头结点的单链表中实现查找最大值或最小值并在其前后插入指定值，需结合链表遍历、值比较和插入操作。以下是基于引用[2]和[^3]的逐步实现方法（带头结点的单链表头结点不存储数据，仅作为哨兵节点简化操作）[^2]。 #### 核心步骤分解 1. **定义链表结构** 使用结构体定义节点，包含数据域和指针域： ```c struct Node { int data; // 存储数据 struct Node *next; // 指向下一个节点 }; struct Node *head; // 头结点指针 ``` 初始化头结点：`head = (struct Node*)malloc(sizeof(struct Node)); head->next = NULL;`。 2. **查找最大值或最小值** - 遍历链表（从第一个实际节点开始），记录目标节点及其前驱节点（用于"之前插入"）。 - 使用 for 循环遍历（引用[^3]）： ```c struct Node *p = head->next; // 指向第一个实际节点 struct Node *target = p; // 目标节点（最大/最小值） struct Node *prevTarget = head; // 目标节点的前驱（初始为头结点） // 查找最大值示例（最小值只需将 > 改为 <） for (; p != NULL; p = p->next) { // 遍历至链表末尾 if (p->data > target->data) { target = p; // 更新目标节点 prevTarget = prev; // 更新前驱节点 } prev = p; // 记录当前节点为下一次的前驱 } ``` - 时间复杂度：$O(n)$（需遍历所有节点）[^2]。 3. **插入指定值** - **在目标节点之前插入**： 通过 `prevTarget` 直接插入（因单链表需前驱节点）： ```c struct Node *newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = newValue; // 设置新值 newNode->next = target; // 新节点指向目标节点 prevTarget->next = newNode; // 前驱节点指向新节点 ``` - **在目标节点之后插入**： 直接修改目标节点的指针： ```c struct Node *newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = newValue; newNode->next = target->next; // 新节点指向原后继 target->next = newNode; // 目标节点指向新节点 ``` #### 完整代码示例（在最大值之前插入） ```c #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node *next; }; // 在最大值之前插入新值 void insertBeforeMax(struct Node *head, int newValue) { if (head->next == NULL) { // 链表为空 struct Node *newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = newValue; newNode->next = NULL; head->next = newNode; return; } struct Node *p = head->next; // 第一个实际节点 struct Node *target = p; // 最大值节点 struct Node *prevTarget = head; // 最大值节点的前驱（初始为头结点） struct Node *prev = head; // 当前节点的前驱 // 遍历查找最大值及其前驱 for (; p != NULL; p = p->next) { if (p->data > target->data) { target = p; prevTarget = prev; } prev = p; // 更新前驱指针 } // 在最大值之前插入新节点 struct Node *newNode = (struct Node*)malloc(sizeof(struct Node)); newNode->data = newValue; newNode->next = target; // 新节点指向最大值节点 prevTarget->next = newNode; // 前驱指向新节点 } // 打印链表 void printList(struct Node *head) { for (struct Node *p = head->next; p != NULL; p = p->next) { printf("%d ", p->data); } printf("\n"); } int main() { // 初始化链表：头结点 → 3 → 5 → 2 struct Node *head = (struct Node*)malloc(sizeof(struct Node)); head->next = NULL; // 添加节点示例（省略添加代码） // 调用插入：在最大值5之前插入10 insertBeforeMax(head, 10); printList(head); // 输出：3 10 5 2 return 0; } ``` #### 关键注意事项 1. **边界处理**： - 空链表：直接插入新节点作为第一个节点。 - 目标节点是首节点：`prevTarget` 为头结点，插入后新节点成为首节点。 - 目标节点是尾节点：在之后插入时，新节点的 `next` 设为 `NULL`。 2. **时间复杂度**： - 查找最大值/最小值：$O(n)$（遍历整个链表）[^2]。 - 插入操作：$O(1)$（指针修改），但总体为 $O(n)$ 因需先查找。 3. **多极值处理**： 上述代码处理第一个出现的最大值；若需处理所有极值，需在遍历中保存多个节点或多次扫描。 #### 相关问题 1. 如何优化在链表中查找极值并插入的操作以减少时间复杂度？ 2. 带头结点的单链表与不带头结点的链表在插入操作中有哪些性能差异？ 3. 在实际应用中，这种插入操作有哪些典型使用场景（如数据过滤或优先级调整）？ [^1]: HashMap 的实现原理强调链表性能对操作效率的影响，类似地，链表遍历效率直接影响插入操作的时间复杂度。 [^2]: 引用[2]提供了查找最大值和链表遍历的基础方法，本方案在其基础上扩展插入逻辑。 [^3]: 引用[^3]的 for 循环用于遍历链表，本方案采用 `for (p = head->next; p != NULL; p = p->next)` 确保从头结点后的第一个节点开始扫描。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值