第1章第2节练习题3 删除最小值结点

问题描写叙述

试编写在带头结点的单链表L中删除一个最小值结点的高效算法(如果最小值结点是唯一的)

算法思想

在链表中删除最小值的前提是必须找到最小值元素是哪个结点,因此设置指针p对全部结点进行遍历,使用指针min指向最小值结点。可是由于涉及到删除操作,明显在仅仅有指针min和指针p的条件下删除操作是极为不方便的。

若单纯的删除指针p指向的结点会造成断链。若採用2.5.2删除自身结点的方法,又会出现多次赋值操作。

因此直接引入两个分别指向其前驱结点的指针pre和premin,如此。删除操作过程会更加通俗易懂。

算法描写叙述

void DelMin(LNode *head)
{
    LNode *pre=head,*p=head->next;
    LNode *premin=pre,*min=p;
    while(p){
        if(min->data>p->data){
            premin=pre;
            min=p;
        }
        pre=p;
        p=p->next;
    }
    printf("Deleted Node: %4d\n",min->data);
    premin->next=min->next;
    free(min);
}

详细代码见附件。


附件

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

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

LinkList CreatList(LNode*);
void DelMin(LNode*);
void Print(LNode*);


int main(int argc, char* argv[])
{
    LNode *head;
    head=(LNode*)malloc(sizeof(LNode));
    head->next=NULL;

    head=CreatList(head);
    Print(head);
    DelMin(head);
    Print(head);

    return 0;
}
//头插法创建单链表
LinkList CreatList(LNode *head)
{
    LNode *s;
    ElemType x;
    scanf("%d",&x);
    while(x!=999){
        s=(LNode*)malloc(sizeof(LNode));
        s->data=x;

        s->next=head->next;
        head->next=s;

        scanf("%d",&x);
    }
    return head;
}
//查找并删除最小值结点
void DelMin(LNode *head)
{
    LNode *pre=head,*p=head->next;
    LNode *premin=pre,*min=p;
    while(p){
        if(min->data>p->data){
            premin=pre;
            min=p;
        }
        pre=p;
        p=p->next;
    }
    printf("Deleted Node: %4d\n",min->data);
    premin->next=min->next;
    free(min);
}
//打印全部结点
void Print(LNode *head)
{
    LNode *p=head->next;
    while(p){
        printf("%4d",p->data);
        p=p->next;
    }
    printf("\n");
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 以下是删除单链表中第一个最小值结点的代码: ```c void deleteMinNode(ListNode* head) { if (head == NULL || head->next == NULL) { return; } ListNode* pre = head; ListNode* cur = head->next; ListNode* minPre = pre; ListNode* minNode = cur; while (cur != NULL) { if (cur->val < minNode->val) { minNode = cur; minPre = pre; } pre = cur; cur = cur->next; } minPre->next = minNode->next; free(minNode); } ``` 希望能够帮到你! ### 回答2: 删除单链表中第一个最小值结点的代码可以分为以下几个步骤: 1. 首先,需要判断链表是否为空。如果链表为空,则直接返回,无需删除任何结点。 2. 定义两个指针变量cur和pre,分别指向当前结点和当前结点的前一个结点。初始化时,cur指向头结点的下一个结点,pre指向头结点。 3. 定义一个变量minValue,用来保存当前找到的最小值。 4. 遍历链表,找到最小值结点的过程如下: a. 如果当前结点的值小于minValue,则更新minValue为当前结点的值。 b. 如果当前结点的值等于minValue,则将cur指向的结点从链表中删除,即令pre的next指针指向cur的next指针所指向的结点。 c. 否则,将pre指向cur,再将cur指向下一个结点。 5. 返回链表头结点。 下面是使用C语言描述的删除单链表中第一个最小值结点的代码: ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node *next; } Node; Node* deleteMinNode(Node* head) { if (head->next == NULL) { return head; } Node *pre = head; Node *cur = head->next; int minValue = cur->data; while (cur != NULL) { if (cur->data < minValue) { minValue = cur->data; } cur = cur->next; } cur = head->next; while (cur != NULL) { if (cur->data == minValue) { pre->next = cur->next; free(cur); break; } pre = cur; cur = cur->next; } return head; } int main() { // 创建链表 Node *head = (Node *)malloc(sizeof(Node)); head->next = NULL; Node *p = head; int n; printf("输入链表长度:"); scanf("%d", &n); printf("输入链表元素:"); for (int i = 0; i < n; i++) { Node *newNode = (Node *)malloc(sizeof(Node)); scanf("%d", &(newNode->data)); newNode->next = NULL; p->next = newNode; p = p->next; } // 调用删除最小值结点函数 head = deleteMinNode(head); // 输出链表 printf("删除最小值结点后的链表:"); p = head->next; while (p != NULL) { printf("%d ", p->data); p = p->next; } // 释放链表内存 p = head; while (p != NULL) { Node *temp = p; p = p->next; free(temp); } return 0; } ``` 注意: 该代码中假设链表的元素都是整数。 ### 回答3: 要删除单链表中第一个最小值结点,可以按照以下步骤编写代码: 1. 定义一个指针p,初始指向头结点的下一个结点,即第一个数据结点。 2. 定义两个辅助指针,minPrev和minNode,初始值都指向头结点。 3. 通过遍历链表,找到第一个最小值结点,并记录其前一个结点。 4. 如果找到最小值结点,则将其前一个结点的next指针指向最小值结点的下一个结点。 5. 释放最小值结点的内存空间,防止内存泄露。 6. 返回删除后的链表头结点。 以下是代码实现: ```c++ #include <iostream> using namespace std; struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(nullptr) {} }; ListNode* deleteMinNode(ListNode* head) { if (!head || !head->next) { return head; } ListNode* p = head->next; ListNode* minPrev = head; ListNode* minNode = head->next; while (p) { if (p->val < minNode->val) { minPrev = p; minNode = p; } else { p = p->next; } } if (minNode != nullptr) { minPrev->next = minNode->next; delete minNode; } return head; } int main() { ListNode* head = new ListNode(-1); head->next = new ListNode(2); head->next->next = new ListNode(-3); head->next->next->next = new ListNode(4); head->next->next->next->next = new ListNode(0); ListNode* updatedHead = deleteMinNode(head); // 遍历输出链表的元素 ListNode* p = updatedHead->next; while (p) { cout << p->val << " "; p = p->next; } // 释放链表的内存空间 p = updatedHead; while (p) { ListNode* temp = p; p = p->next; delete temp; } return 0; } ``` 上述代码首先定义了一个单链表的结构体ListNode,每个结点包含一个整数值和一个指向下一个结点的指针。函数deleteMinNode的参数为头结点,返回删除第一个最小值结点后的链表头结点。在主函数中创建一个带头结点的单链表的示例,然后调用deleteMinNode函数删除单链表中第一个最小值结点,并输出删除后的链表元素。最后需要释放链表的内存空间,以防止内存泄露。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值