学习笔记-数据结构-线性表（2024-04-18）- 单向链表选择排序

已于 2024-04-21 00:44:25 修改
阅读量725 收藏 7
点赞数 5
分类专栏： 数据结构学习笔记 文章标签： 数据结构 学习 笔记
于 2024-04-20 21:55:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41755616/article/details/137942792
版权
本文详细介绍了如何利用单向链表的特性，遵循选择排序思想，通过节点移动和连接操作实现链表的排序过程，包括C和Java语言的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

试以单向链表为存储结构实现简单选择排序的算法。

实现递增排序，首先选择一个元素作为第一个比较值，遍历其他所有的元素，如果发现其他元素中有比它小的元素，则交换两个元素，这样每一趟都能找到符合要求的最小值

正经的单向链表排序，不是换数据的那种！
思想是选择排序的思想，但问题在于单链表结构不同于数组的直接交换，需要断链和重新成链等各种操作，稍不留神就直接G了

具体实现步骤如下：

  • 初始化指针变量a和b，它们都指向链表的头节点。
  • 外层循环遍历链表，直到节点b是链表中的最后一个节点。
  • 内层循环遍历以节点b为起始的子链表，寻找其中最小的节点d。
  • 如果节点b的值大于节点d的值，说明需要将节点d插入到节点b之前。
  • 根据不同情况进行节点的移动和连接操作：
    • 如果节点d紧跟在节点b后面，分为两种情况：
      • 如果节点b是链表的头节点，则直接将节点d移动到节点b之前，并调整头节点的指针。
      • 如果节点b不是链表的头节点，则将节点d移动到节点b之前，并更新a的next指针。
    • 如果节点b和节点d之间有其他节点，也分为两种情况：
      • 如果节点b是链表的头节点，则将节点d移动到节点b之前，并更新头节点的指针。
      • 如果节点b不是链表的头节点，则将节点d移动到节点b之前，并更新a的next指针。
  • 完成内层循环后，更新a和b的指针，继续下一轮循环，直到整个链表都被排序完成。
  • 最后返回排序后的链表头节点。

下面是C语言写法：

typedef struct Node
{
    int data;
    struct Node *next;
}LinkNode;


LinkNode* selectionSort(LinkNode* head) 
{ 
    LinkNode *a, *b, *c, *d, *r; // 声明指针变量 a, b, c, d, r

    a = b = head; // 初始化指针变量 a, b，它们指向链表头部

    // 当 b 不是最后一个节点时执行循环
    while (b->next) { 

        c = d = b->next; // 初始化指针变量 c, d，它们指向 b 的下一个节点

        // 当 d 指向一个有效节点时执行循环
        while (d) { 

            if (b->data > d->data) { // 如果 b 的值大于 d 的值

                if (b->next == d) { // 如果 d 紧跟在 b 后面

                    if (b == head) { // 如果 b 是链表的头节点

                        // 将 d 移动到 b 的前面
                        b->next = d->next; 
                        d->next = b; 

                        // 交换 b 和 d 的指针
                        r = b; 
                        b = d; 
                        d = r; 

                        c = d; // 更新 c

                        // 更新链表头部
                        head = b; 

                        // 跳到下一个元素，因为它已经是有序的
                        d = d->next; 
                    } 
                    else { // 如果 b 不是链表的头节点

                        // 将 d 移动到 b 的前面
                        b->next = d->next; 
                        d->next = b; 
                        a->next = d; 

                        // 交换 b 和 d 的指针
                        r = b; 
                        b = d; 
                        d = r; 

                        c = d; // 更新 c

                        // 跳到下一个元素，因为它已经是有序的
                        d = d->next; 
                    } 
                } 
                else { // 如果 b 和 d 之间有一些非零节点

                    if (b == head) { // 如果 b 是链表的头节点

                        // 交换 b->next 和 d->next
                        r = b->next; 
                        b->next = d->next; 
                        d->next = r; 
                        c->next = b; 

                        // 交换 b 和 d 的指针
                        r = b; 
                        b = d; 
                        d = r; 

                        c = d; // 更新 c

                        // 跳到下一个元素，因为它已经是有序的
                        d = d->next; 

                        // 更新链表头部
                        head = b; 
                    } 
                    else { // 如果 b 不是链表的头节点

                        // 交换 b->next 和 d->next
                        r = b->next; 
                        b->next = d->next; 
                        d->next = r; 
                        c->next = b; 
                        a->next = d; 

                        // 交换 b 和 d 的指针
                        r = b; 
                        b = d; 
                        d = r; 

                        c = d; // 更新 c

                        // 跳到下一个元素，因为它已经是有序的
                        d = d->next; 
                    } 
                } 
            } 
            else { // 如果 b 的值不大于 d 的值

                // 更新 c 并跳到下一个元素，因为它已经是有序的
                c = d; 
                d = d->next; 
            } 
        } 

        a = b; // 更新 a
        b = b->next; // 更新 b
    } 

    return head; // 返回排序后的链表头部
}

下面是Java语言写法：


public class Main {
  
    public static class Node {
        int data; 
        Node next; 
    };

    public static Node selectionSort(Node head)
    {
        Node a, b, c, d, r;
        a = b = head;
        while (b.next != null) {
            c = d = b.next;
            while (d != null) {
                if (b.data > d.data) {
                    if (b.next == d) {
                        if (b == head) {
                            b.next = d.next;
                            d.next = b;
                            r = b;
                            b = d;
                            d = r;
                            c = d;
                            head = b;
                            d = d.next;
                        }
                        else {
                            b.next = d.next;
                            d.next = b;
                            a.next = d;
                            r = b;
                            b = d;
                            d = r;
                            c = d;
                            d = d.next;
                        }
                    }
                    else {
                        if (b == head) {
                            r = b.next;
                            b.next = d.next;
                            d.next = r;
                            c.next = b;
                            r = b;
                            b = d;
                            d = r;
                            c = d;
                            d = d.next;
                            head = b;
                        }
                        else {
                            r = b.next;
                            b.next = d.next;
                            d.next = r;
                            c.next = b;
                            a.next = d;
                            r = b;
                            b = d;
                            d = r;
                            c = d;
                            d = d.next;
                        }
                    }
                }
                else {
                    c = d;
                    d = d.next;
                }
            }
            a = b;
            b = b.next;
        }
        return head;
    }

	// 新建Node节点
    static Node newNode(int val)
    { 
        Node temp = new Node(); 
  
        temp.data = val; 
  
        temp.next = null; 
  
        return temp; 
    } 
}

示例

以 -2-0-0-3-5-1- 单链表为例
由于动态演示图较大，csdn无法上传，请移步至 https://gitee.com/xjk2000/image-storage/blob/master/1.gif
Java代码测试执行：
测试代码
执行结果：
在这里插入图片描述

BJFU_数据结构习题_294基于链表的简单选择排序
雪地行进
11-26 2409
294基于链表的简单选择排序 描述 试以单链表为存储结构，实现简单选择排序算法。 输入 多组数据，每组数据两行。第一行为序列的长度n，第二行为序列的n个元素（元素之间用空格分隔，元素都为正整数）。当n等于0时，输入结束。 输出 每组数据输出一行，为从小到大排序后的序列。每两个元素之间用空格隔开。 输入样例 1 5 4 5 3 2 9 6 1 3 5 7 9 2 0 输出样例 1 2 3 4 5 9...
试以单链表为存储结构实现简单选择排序的算法
m0_57180439的博客
12-14 1374
以单链表为存储结构，实现简单选择排序
以单链表为储存结构实现简单选择排序的算法。
weixin_44659084的博客
04-05 1万+
//以单链表为储存结构实现简单选择排序的算法。 void Algo(LinkList *L) { LinkList r,s,pre,p; s=(*L)->next; //s 指向链表第一个结点 (*L)->next=NULL; while(s) { SelectMinPtr(s,&pre,&p); if(p==s) s=s->next; ...
C语言代码：基于单链表的简单选择排序算法
m0_58464499的博客
12-31 1849
这段代码定义了一个 `ListNode` 结构体表示链表节点，以及相应的创建节点、插入节点、交换节点值等函数。然后，我们定义了 `selectionSort` 函数，它使用简单选择排序算法对链表进行排序。然后，我们打印排序前的链表，调用 `selectionSort` 函数对链表进行排序，并打印排序后的链表。// 链表为空或只有一个节点，无需排序。// 使用简单选择排序算法对链表进行排序。// 使用简单选择排序算法对链表进行排序。// 在链表末尾插入节点。// 交换链表节点的值。
试以单链表为存储结构，实现简单选择排序算法。
weixin_56508665的博客
05-30 8572
3.（1） #include <stdio.h> #include <stdlib.h> typedef int status; typedef int elemtype; typedef struct lnode{ elemtype data; struct lnode *link; }lnode,*linknode; typedef struct{ linknode head,rear; int len;}linklist; void init_linkl
C语言数据结构-链表
最新发布
2302_81072215的博客
11-26 1792
图中指针变量plist保存的是第一个结点的地址，我们称plist此时“指向”第一个结点，如果我们希望plist“指向”第二个结点时，只需要修改plist保存的内容为0x0012FFA0.在前面说的单链表中的“头结点”，该头结点是链表的首节点（第一个结点），实际这样的称呼是错误的，因为链表中存在一种链表叫做带头链表（不是指链表里第一个有效的结点），这里的头结点指的是，在这里直接使用plist来遍历结果也是一样的，重新创建个pcur指针，是为了避免由于指针指向的改变，导致无法重新找到链表的首结点。
【数据结构学习笔记】二、线性表---链表篇（2）
大家好我叫张同学
01-07 1274
文章目录链表概念:链表分类：单链表的实现： 链表概念: 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 注意: 1.从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续 2.现实中的结点一般都是从堆上申请出来的 3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续 链表分类： 单向 双向 带头 不带头 循环 非循环 单向..
【数据结构学习笔记】二、线性表---顺序表篇（1）（画图详解+代码实现）
大家好我叫张同学
12-29 3588
数据结构、算法图解、线性表、顺序表、链表
2024年数据结构与算法——线性表（链表篇）_线性链表，我的阿里春招之路分享
2301_82243558的博客
05-05 683
以上就是线性表中链表的相关知识整理，配合代码是实例讲解链表的基本操作，相对于顺序表来说，链表的分类较为多一些，且操作也较为复杂一些，但只要认真看完本篇文章，你会对链表有更为详细的认知和理解，文章内容很多，知识点也很全面，一如既往希望我的文章能给各位小伙伴们带来帮助，数据结构与算法专栏也在持续更细中！！！！🎨😀别忘了给我关注~~😀网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化资料的朋友，可以戳这里获取。
数据结构与算法笔记（三）线性表 定义线性表节点的结构.pdf
04-18
线性表是一种基础而重要的数据结构，它是由n（n>=0...总的来说，线性表和链表是数据结构的基础，它们的理解和熟练应用是学习更高级算法和数据结构的前提。无论是面试还是实际开发，掌握好这些基础知识都是非常关键的。
单链表上的简单选择排序算法
06-04
以单链表为存储结构实现简单选择排序的算法
单链表实现简单选择排序
精神小伙的博客
10-21 4178
不是所有的排序算法都可以用单链表来实现，比如快速排序和堆排序，由于单链表不具有随机访问的特性，所以也受限制 本题中的简单选择排序，在单链表中实现的思路：每次遍历链表中的剩余部分，每一趟将剩余部分中最大结点插到表头，最后即可得一条由小到大的单链表，思路很简单，具体还得落实到代码上，你会了，不代表你的手也会了 #include<iostream> using namespace std; typedef struct Node{ int val; Node*next; }Node,*
链表-单链表的选择排序
六月二十七的博客
03-12 514
//单链表的选择排序 public static Node selectSort(Node head){ Node tail=null;//排序部分尾部 Node cur=head;//未排序部分头部 Node smallPre=null;//最小节点的前一个节点 Node small=null;//最小的节点 while(cur!=null){ ...
使用单链表的简单选择排序
热门推荐
weixin_43823538的博客
04-11 1万+
单链表简单选择排序算法 单链表的存储结构和创建单链表 1、 单链表的结构： typedef struct list { int data; struct list * next; }list,*linklist; 2、 单链表的创建： void create(linklist &L,int n) { int i; linklist p; L = (linklist)ma...
【数据结构】-排序-基于单链表的简单选择排序
vector的博客
07-12 1万+
方法一：不进行任何断链插入操作，找到目标节点之后，只是交换data值，这个思路很简单，与简单选择排序的思路一摸一样。 编程注意事项： min不能标记最小值，应该要标记最小值对应的链表节点 LinkList createLink(LinkList L) { cout << "尾插法创建单链表:"<<endl; int a; L = (LinkList)malloc(sizeof(LinkNode)); L->next = NULL; LinkNode *p=L,
4022基于链表的简单选择排序
qq_51135645的博客
12-01 647
描述 试以单链表为存储结构，实现简单选择排序算法。 输入 多组数据，每组数据两行。第一行为序列的长度n，第二行为序列的n个元素（元素之间用空格分隔，元素都为正整数）。当n等于0时，输入结束。 输出 每组数据输出一行，为从小到大排序后的序列。每两个元素之间用空格隔开。 输入样例 1 5 4 5 3 2 9 6 1 3 5 7 9 2 0 输出样例 1 2 3 4 5 9 1 2 3 5 7 9 //基于链表的简单选择排序 #include <iostream> #de.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值