线性表练习之Example039-删除循环单链表中的所有最小值节点直至链表为空

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

Example039

原文链接：Example039

题目

设有一个带头节点的循环单链表，其节点值均为正整数。设计一个算法，反复找出单链表中节点值最小的节点并输出，然后将该节点从中删除，直到单链表空为止，再删除表头节点。

分析

本题考查的知识点：

  • 循环单链表
  • 循环单链表删除节点
  • 单链表寻找最小值节点

算法思想：对于循环单链表，在链表不为空时进行循环：每循环一次就查找一个链表中的最小值节点，但注意让 minNode 指向最小值节点，让 minPreNode 指向最小值节点的前驱节点，然后删除它。直到链表为空，当链表为空后释放链表的头结点。

注意：

  • 循环单链表的循环结束条件是节点不等于头结点。
  • 本题不难，着重考查删除链表的最小值节点，而删除所有的最小值节点，不过是添加一个循环而已。

图解

请添加图片描述

C实现

核心代码：

/**
 * @param list 循环单链表，因为要修改循环单链表，所以是双指针 **list
 */
void deleteAllMin(CLNode **list) {
    // 一直循环删除最小节点，直到链表为空链表，其中 (*list)->next==*list 表示是空链表，结束循环
    while ((*list)->next != *list) {
        // 局部变量，记录最小节点
        CLNode *minNode = (*list)->next;
        // 局部变量，记录最小节点的前驱节点
        CLNode *minPreNode = *list;

        // 局部变量，记录链表中的每个节点，初始为链表的第一个节点
        CLNode *node = (*list)->next;
        // 局部变量，记录 node 节点的前驱节点
        CLNode *pre = *list;

        // 从头到尾扫描循环单链表，寻找最小节点及其前驱节点
        while (node != *list) {
            // 如果当前节点比最小节点元素值还小，则更新 minNode 和 minPreNode
            if (node->data < minNode->data) {
                minPreNode = pre;
                minNode = node;
            }
            pre = node;
            node = node->next;
        }

        // 找到最小值节点之后，删除最小值节点
        printf("最小节点：%d\n", minNode->data);
        minPreNode->next = minNode->next;
        free(minNode);// 释放最小值节点的空间

        // 打印一下删除最小节点之后的链表
        print(*list);
    }
    // 释放头节点
    free(*list);
}

完整代码：

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

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

/**
 * 通过尾插法创建循环单链表
 * @param list  循环单链表
 * @param nums 待插入到单链表中的数据数组
 * @param n 数组长度
 * @return 创建成功的循环单链表
 */
CLNode *createByTail(CLNode **list, int nums[], int n) {
    // 1.初始化循环单链表，即创建循环单链表的头结点。也可以直接调用 init 函数来初始化
    // 1.1 为头结点分配空间
    *list = (CLNode *) malloc(sizeof(CLNode));
    // 1.2 修改头结点的 next 指针，将其指向自己，而普通单链表是指向 null
    (*list)->next = *list;// 注意，指向头结点本身

    // 保存链表的尾节点，初始为链表的头节点，即空链表的尾节点就是链表的头节点
    CLNode *tailNode = *list;

    // 2.循环数组 nums 中所有数据，插入到单链表中
    for (int i = 0; i < n; i++) {
        // 2.1 创建新节点
        // 2.1.1 给新节点分配空间
        CLNode *newNode = (CLNode *) malloc(sizeof(CLNode));
        // 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 然后将新节点（即链表新的尾节点）指向链表的头节点
        newNode->next = *list;
        // 2.2.3 然后将 tailNode 指向新节点（即新的尾节点）
        tailNode = newNode;
    }

    // 3.返回创建成功的链表
    return *list;
}

/**
 * 打印循环单链表
 * @param list 待打印的循环单链表
 */
void print(CLNode *list) {
    printf("[");
    CLNode *node = list->next;
    while (node != list) {
        printf("%d", node->data);
        if (node->next != list) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

/**
 * @param list 循环单链表，因为要修改循环单链表，所以是双指针 **list
 */
void deleteAllMin(CLNode **list) {
    // 一直循环删除最小节点，直到链表为空链表，其中 (*list)->next==*list 表示是空链表，结束循环
    while ((*list)->next != *list) {
        // 局部变量，记录最小节点
        CLNode *minNode = (*list)->next;
        // 局部变量，记录最小节点的前驱节点
        CLNode *minPreNode = *list;

        // 局部变量，记录链表中的每个节点，初始为链表的第一个节点
        CLNode *node = (*list)->next;
        // 局部变量，记录 node 节点的前驱节点
        CLNode *pre = *list;

        // 从头到尾扫描循环单链表，寻找最小节点及其前驱节点
        while (node != *list) {
            // 如果当前节点比最小节点元素值还小，则更新 minNode 和 minPreNode
            if (node->data < minNode->data) {
                minPreNode = pre;
                minNode = node;
            }
            pre = node;
            node = node->next;
        }

        // 找到最小值节点之后，删除最小值节点
        printf("最小节点：%d\n", minNode->data);
        minPreNode->next = minNode->next;
        free(minNode);// 释放最小值节点的空间

        // 打印一下删除最小节点之后的链表
        print(*list);
    }
    // 释放头节点
    free(*list);
}

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

    // 调用函数，删除所有的最小节点，直到链表为空
    deleteAllMin(&list);
}

执行结果：

[5, 2, 3, -3, 1, 4]
最小节点：-3
[5, 2, 3, 1, 4]
最小节点：1
[5, 2, 3, 4]
最小节点：2
[5, 3, 4]
最小节点：3
[5, 4]
最小节点：4
[5]
最小节点：5
[]

Java实现

核心代码：

    /**
     * 删除循环单链表中所有最小值节点，直到链表为空，最后释放头节点
     */
    public void deleteAllMin() {
        // 一直循环删除最小节点，直到链表为空链表，其中 list.next==list 表示是空链表，结束循环
        while (list.next != list) {
            // 局部变量，记录最小节点
            CLNode minNode = list.next;
            // 局部变量，记录最小节点的前驱节点，因为单链表要删除一个节点，必须知道它的前驱节点，所以需要记录
            CLNode minPreNode = list;

            // 局部变量，记录链表中的每个节点，初始为链表的第一个节点，为了遍历单链表使用
            CLNode node = list.next;
            // 局部变量，记录 node 节点的前驱节点，记录前驱节点是为了提供给 minPreNode 使用
            CLNode pre = list;

            // 从头到尾扫描循环单链表，寻找最小节点及其前驱节点
            while (node != list) {
                // 如果当前节点比最小节点元素值还小，则更新 minNode 和 minPreNode
                if (node.data < minNode.data) {
                    minNode = node;
                    minPreNode = pre;
                }
                pre = node;
                node = node.next;
            }

            // 找到最小值节点之后，删除最小值节点
            System.out.println("最小节点：" + minNode.data);
            minPreNode.next = minNode.next;
            minNode.next = null;// 释放最小值节点的空间
            minNode = null;

            // 打印一下删除最小节点之后的链表
            print();
        }
        // 释放头节点
        list.next = null;
        list = null;
    }

完整代码：

public class CircularLinkedList {
    private CLNode list;

    /**
     * 通过尾插法创建循环单链表
     *
     * @param nums 待插入到单链表中的数据数组
     * @return 创建成功的循环单链表
     */
    public CLNode createByTail(int... nums) {
        // 1.初始化循环单链表，即创建循环单链表的头结点。也可以直接调用 init 函数来初始化
        // 1.1 为头结点分配空间
        list = new CLNode();
        // 1.2 修改头结点的 next 指针，将其指向自己，而普通单链表是指向 null
        list.next = list;// 注意，这里同单链表不同的是，指向了自己

        // 保存链表的尾节点，初始为链表的头节点，即空链表的尾节点就是链表的头节点
        CLNode tailNode = list;

        // 2.循环数组 nums 中所有数据，插入到单链表中
        for (int i = 0; i < nums.length; i++) {
            // 2.1 创建新节点
            // 2.1.1 给新节点分配空间
            CLNode newNode = new CLNode();
            // 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 然后将新节点（即链表新的尾节点）指向链表的头节点
            newNode.next = list;
            // 2.2.3 然后将 tailNode 指向新节点（即新的尾节点）
            tailNode = newNode;
        }

        // 3.返回创建成功的链表
        return list;
    }

    /**
     * 删除循环单链表中所有最小值节点，直到链表为空，最后释放头节点
     */
    public void deleteAllMin() {
        // 一直循环删除最小节点，直到链表为空链表，其中 list.next==list 表示是空链表，结束循环
        while (list.next != list) {
            // 局部变量，记录最小节点
            CLNode minNode = list.next;
            // 局部变量，记录最小节点的前驱节点，因为单链表要删除一个节点，必须知道它的前驱节点，所以需要记录
            CLNode minPreNode = list;

            // 局部变量，记录链表中的每个节点，初始为链表的第一个节点，为了遍历单链表使用
            CLNode node = list.next;
            // 局部变量，记录 node 节点的前驱节点，记录前驱节点是为了提供给 minPreNode 使用
            CLNode pre = list;

            // 从头到尾扫描循环单链表，寻找最小节点及其前驱节点
            while (node != list) {
                // 如果当前节点比最小节点元素值还小，则更新 minNode 和 minPreNode
                if (node.data < minNode.data) {
                    minNode = node;
                    minPreNode = pre;
                }
                pre = node;
                node = node.next;
            }

            // 找到最小值节点之后，删除最小值节点
            System.out.println("最小节点：" + minNode.data);
            minPreNode.next = minNode.next;
            minNode.next = null;// 释放最小值节点的空间
            minNode = null;

            // 打印一下删除最小节点之后的链表
            print();
        }
        // 释放头节点
        list.next = null;
        list = null;
    }

    /**
     * 打印循环单链表
     */
    public void print() {
        // 链表的第一个节点
        CLNode node = list.next;
        // 循环单链表，打印单链表的每个节点的数据值
        String str = "[";
        while (node != list) {
            str += node.data;
            if (node.next != list) {
                str += ", ";
            }
            node = node.next;
        }
        str += "]";
        // 打印结果
        System.out.println(str);
    }
}

/**
 * 循环单链表节点
 */
class CLNode {
    /**
     * 节点的数据域
     */
    int data;
    /**
     * 节点的指针域，指向后继节点
     */
    CLNode next;
}

测试代码：

public class CircularLinkedListTest {
    public static void main(String[] args) {
        // 实例化循环单链表对象
        CircularLinkedList list = new CircularLinkedList();
        list.createByTail(3, 4, 2, 5, 1);
        list.print();

        // 调用函数删除所有最小值节点
        list.deleteAllMin();
    }
}

执行结果：

[3, 4, 2, 5, 1]
最小节点：1
[3, 4, 2, 5]
最小节点：2
[3, 4, 5]
最小节点：3
[4, 5]
最小节点：4
[5]
最小节点：5
[]
二木成林
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构代码
weixin_44749480的博客
10-25 1304
数据结构代码
数据结构与算法 学习笔记（陈越）
sangkun
10-17 4105
数据机构c语言版本-陈越笔记*第一章*（数据结构和算法）数据结构算法 第一章（数据结构和算法） 数据结构 官方定义-没有统一 解决问题的方法效率，跟数据的组织方式有关 空间的使用 解决问题的方法效率，跟空间的利用率有关 算法的效率 解决问题的方法效率，跟算法的巧妙程度有关 抽象数据类型 算法 定义 1.一个有限指令集 2.接收一些输入 3.产生输出 4.在一定有限步骤后结束 5.每一条指令必须有充分明确的目标，不可以有歧义，在计算机处理范围内，描述不依赖于任何一种计算机语言以及具体的实现手段 算法的
反复找出循环单链表中的最小结点，打印并删除，直到表空为止
zhaoxk88的博客
05-20 500
个人代码如下，欢迎大佬指正 #include<stdio.h> #include<stdlib.h> typedef struct LNode { int data; struct LNode* next; }Node,*Link; void Func(Link& link) { Node* p, *pre,*q; //循环每次找到一个最小的结点，然后删掉，故这里只要判断是不是空表 while (link->next !=
(转)问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。
zhaozhanyong的专栏
02-14 6487
问题：假设一个没有头指针的单链表。一个指针指向此单链表中间的一个节点（既不是第一个，也不是最后一个节点），请将该节点从单链表中删除。链表结点定义如下： struct ListNode {          int       m_nKey;          ListNode* m_pNext; }; 解答：假设给定的指针为pCurrent，ListNode* pNext = pCurrent->m_pNext； 由题意知，pCurrent指向链表的某一个中间节点，因此pCurr
C语言 反复寻找链表最小结点输出并删除,直到链表为空
qq_41740162的博客
04-12 584
文章目录C语言 反复寻找链表最小结点输出并删除,直到链表为空算法思想 C语言 反复寻找链表最小结点输出并删除,直到链表为空 算法思想 首先把第一个节点P摘下来,依次与其他结点进行比较,若遇到比P小的节点Q摘下来,让P进入链表替补Q的位置如图 ...
带头节点，输出循环单链表中的最小值并删除节点，直至空链表，删除队头
越过山丘
02-28 293
typedef struct node { int data; struct node *next; } LNode, *LinkList; void DelAll(LinkList L) { LNode *p, *minp, *minPre, *pre; int min; while (L->next != L) { p = L->next; minPre = L; minp = p;
王道数据结构2.3.7——19、反复找出并删除循环单链表的最小值，直到表为空
Hillbox
10-12 375
思路 与单链表比，结尾不一样了。 代码 void del_min(LinkList &L){ LNode *pre=L,*p=L->next,*r; while(p->next!=L){ if(p->next->data<pre->next->data) pre=p; else p=p-&gt...
数据结构与算法：线性表操作与应用
# 1. 引言 ## 1.1 数据结构与算法的基本概念简介 在计算机科学中，数据结构和算法是构建程序和解决问题的基础。数据结构指的是组织和存储数据的方式，而算法...线性表是数据结构中最基本、最常用的一种结构。它是具有
索引原理与慢查询优化
qq_39280718的博客
04-15 127
文章目录一、初识索引二、索引的原理1 索引原理2 磁盘IO与预读三、索引的数据结构1 树2 B+树四、聚集索引与辅助索引1 聚集索引2 辅助索引3 聚集索引和非聚集索引的区别五、MySQL索引管理1 功能2 MySQL常用的索引3 索引的两大类型hash与btree4 创建/删除索引的语法六、测试索引七、正确使用索引八、联合索引与覆盖索引1 联合索引2 覆盖索引九、执行计划explain十、慢查询优化的基本步骤十一、慢日志管理十二、limit分页十三、相关面试题 一、初识索引 为什么要有索引? 一般的
考研笔记——王道C语言
My博客
03-19 3568
写在前面的话 基于王道龙哥的代码写的笔记，为了加深印象，同时也为了后期复习。 初级阶段太简单了，中级阶段其实也简单，但以前没有写结构体的习惯，习惯直接把结构体拆成数组写，现在觉得还是挺方便的，主要也是为了这个才做的笔记，把一堆数据结构放在一起便于对比。高级阶段的什么文件、OS那块还没看，如果后期写了笔记还会补。 主要是面向我自己写的，不为教学也不为扩列，所以别指指点点，有哪里写的不对可以说，别在那balabala什么写的太浅，就是复制代码什么的。我完全为了自己，只是觉得发博客就是顺手的事。 主要就是将龙哥的
不带头结点的单链表的创建、插入、删除。
baijiaozhan8157的博客
01-03 5984
不带头结点的单链表的创建、插入、删除。 #include<stdio.h>#include<stdlib.h>typedef struct node{ int data; node *next;}node;//创建不带头结点的单链...
链表-删除最小值结点
qq_61706112的博客
09-10 267
/*试编写在带头结点的单链表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).
删除单链表中值最小的结点
qq_43648337的博客
07-21 2231
要求：删除单链表中值最小的结点 算法思想：用p从头至尾扫描，minp指向当前最小值所在结点，q用来指向最小值结点的前驱结点。边扫描边比较，将最小值放到min中。 void deletemin(LNode *L) { LNode *p,*q,*minp; int min = L->next->data;//首先把第一个结点的值作为最小值 p = L->next;//p指向第一个结点 while(p->next != NULL)//从第二个结点开始比较 { if(mi
C语言删除单向链表中最小值,C语言删除单链表中的项目
weixin_30935475的博客
05-16 129
#include #include struct node {int data;struct node *next;};struct node *head = NULL;struct node *current = NULL;struct node *prev = NULL;//Create Linked Listvoid insert(int data) {// Allocate memory ...
关于循环链表的查早最小元素然后输出删除--直至删完
weixin_53094331的博客
09-24 114
#include <stdio.h> #include <malloc.h> typedef struct Node { int data; struct Node *next; }Node; Node *first; void List() { first = (struct Node *)malloc(sizeof(struct Node)); first->next = first; } void Insert(int val) { No.
第二章 链表 删除值最小节点
Cgxxxxxxxxxxxxxx的博客
01-20 340
#include <stdio.h> #include <stdlib.h> using namespace std; #define Min 0x7fffffff; typedef struct LinkedList{ int data; struct LinkedList *next; }LinkedList,*List; int a[5]={5,4,3,1,2}; int n=5; void build(List &L){ L=(Lis...
数据结构天勤练习题（三）—— 删除单链表中的最小值结点
索半斤的博客
08-19 704
一、问题描述 设计一个算法删除单链表L（有头结点）中的一个最小值结点。 二、思路分析 设置三个结点，一个用来指向最小值结点的前一个结点（pre），一个指向最小值结点（min），一个用来遍历结点（temp），当遍历结点遇到比最小值结点小的结点时，使最小值结点指向遍历结点，同时使用pre结点遍历链表，直到pre->next的值为min。 三、代码实现 #include<stdio.h> typedef struct Node{ int data; struct Node *next; }*
C语言删除单向链表中最小值,C语言之单链表的插入、删除与查找
weixin_30658759的博客
05-16 359
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。要实现对单链表中节点的插入、删除与查找的功能，就要先进行的单链表的初始化、创建和遍历，进而实现各功能，以下是对单链表节点的插入、删除、查找功能的具体实现：#include#include#includetypedef int ElemType;/***链表通用类型*ElemType 代表自定义的数据类型*struct ...
循环单链表 | 循环删除表中所有最小值并输出
weixin_30896825的博客
02-18 250
王道P38T19 代码： void del_min(LinkList& L){ LNode*p=L,*mp=L; while(p->next!=p){ if(p->next==L){ //进行了一轮 LNode*del=mp->next; mp->next=de...
线性表与链式存储：单链表、循环链表与双向链表解析
本文档主要讲解了线性表的不同链式表示和实现，包括单链表、循环链表和双向链表。其中，线性表是一种基本的数据结构，由相同类型的元素构成，按照线性顺序排列。链表作为线性表的链式存储方式，允许逻辑上相邻的元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值