单链表排序方法

最新推荐文章于 2022-03-05 22:41:59 发布
最新推荐文章于 2022-03-05 22:41:59 发布
阅读量912 收藏
点赞数


单链表排序是单链表的常见编程任务之一，也是面试中经常出现的题目。单链表排序的关键是交换算法，需要额外考虑。选择排序是比较直观的排序算法之一，这里就使用选择排序实现单链表的排序。

如果需要对选择排序复习一下，传送门：算法导论：选择排序的原理与实现。

C实现代码如下：

01 LinkList SelectSort2(LinkList L)
02 {
03     LinkList p,q,small;
04     int temp;
05  
06     for(p = L->next; p->next != NULL; p = p->next)
07     {
08         small = p;
09         for(q = p->next; q; q = q->next)
10         {
11             if(q->data < small->data)
12             {
13                 small = q;
14             }
15         }
16         printf("循环后，获得最小值为:%d, 此时链表为:", small->data);
17         if(small != p)
18         {
19             temp = p->data;
20             p->data = small->data;
21             small->data = temp;
22         }
23         ListTraverse(L);
24     }
25     printf("输出排序后的数字:\n");
26     return L;
27 }

或者

01 LinkList SelectSort(LinkList L)
02 {
03     LinkList first;     /*排列后有序链的表头指针*/
04     LinkList tail;      /*排列后有序链的表尾指针*/
05     LinkList p_min;     /*保留键值更小的节点的前驱节点的指针*/
06     LinkList min;       /*存储最小节点*/
07     LinkList p;         /*当前比较的节点*/
08  
09     first = NULL;
10     while (L != NULL) /*在链表中找键值最小的节点。*/
11     {
12         /*注意：这里for语句就是体现选择排序思想的地方*/
13         for (p=L,min=L; p->next!=NULL; p=p->next) /*循环遍历链表中的节点，找出此时最小的节点。*/
14         {
15             if (p->next->data < min->data) /*找到一个比当前min小的节点。*/
16             {
17                 p_min = p; /*保存找到节点的前驱节点：显然p->next的前驱节点是p。*/
18                 min = p->next; /*保存键值更小的节点。*/
19             }
20         }
21  
22         /*上面for语句结束后，就要做两件事；
23             一是把它放入有序链表中；
24             二是根据相应的条件判断，安排它离开原来的链表。*/
25  
26         /*第一件事*/
27         if (first == NULL) /*如果有序链表目前还是一个空链表*/
28         {
29             first = min; /*第一次找到键值最小的节点。*/
30             tail = min; /*注意：尾指针让它指向最后的一个节点。*/
31         }
32         else /*有序链表中已经有节点*/
33         {
34             tail->next = min; /*把刚找到的最小节点放到最后，即让尾指针的next指向它。*/
35             tail = min; /*尾指针也要指向它。*/
36         }
37         /*第二件事*/
38         if (min == L) /*如果找到的最小节点就是第一个节点*/
39         {
40             //printf("表头%d已经是最小，当前结点后移。\n", min->data);
41             L = L->next; /*显然让head指向原head->next,即第二个节点，就OK*/
42         }
43         else /*如果不是第一个节点*/
44         {
45             p_min->next = min->next; /*前次最小节点的next指向当前min的next,这样就让min离开了原链表。*/
46         }
47     }
48     if (first != NULL) /*循环结束得到有序链表first*/
49     {
50         tail->next = NULL; /*单向链表的最后一个节点的next应该指向NULL*/
51     }
52     L = first;
53     return L;
54 }

完整的可执行程序：

view source
print ?
001 #include "stdio.h"
002  
003 #define OK 1
004 #define ERROR 0
005 #define TRUE 1
006 #define FALSE 0
007  
008 typedef int Status;/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
009 typedef int ElemType;/* ElemType类型根据实际情况而定，这里假设为int */
010  
011 typedef struct Node
012 {
013     ElemType data;
014     struct Node *next;
015 } Node;
016 typedef struct Node *LinkList; /* 定义LinkList */
017  
018 Status visit(ElemType c)
019 {
020     printf("->%d",c);
021     return OK;
022 }
023  
024 /* 初始化顺序线性表 */
025 Status InitList(LinkList *L)
026 {
027     *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */
028     if(!(*L)) /* 存储分配失败 */
029         return ERROR;
030     (*L)->next=NULL; /* 指针域为空 */
031  
032     return OK;
033 }
034  
035 /* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
036 int ListLength(LinkList L)
037 {
038     int i=0;
039     LinkList p=L->next; /* p指向第一个结点 */
040     while(p)
041     {
042         i++;
043         p=p->next;
044     }
045     return i;
046 }
047  
048 /* 初始条件：顺序线性表L已存在 */
049 /* 操作结果：依次对L的每个数据元素输出 */
050 Status ListTraverse(LinkList L)
051 {
052     LinkList p=L->next;
053     while(p)
054     {
055         visit(p->data);
056         p=p->next;
057     }
058     printf("\n");
059     return OK;
060 }
061  
062 /*  随机产生n个元素的值，建立带表头结点的单链线性表L（尾插法） */
063 void CreateListTail(LinkList *L, int n)
064 {
065     LinkList p,r;
066     int i;
067     srand(time(0));                      /* 初始化随机数种子 */
068     *L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */
069     r=*L;                                /* r为指向尾部的结点 */
070     for (i=0; i < n; i++)
071     {
072         p = (Node *)malloc(sizeof(Node)); /*  生成新结点 */
073         p->data = rand()%100+1;           /*  随机生成100以内的数字 */
074         r->next=p;                        /* 将表尾终端结点的指针指向新结点 */
075         r = p;                            /* 将当前的新结点定义为表尾终端结点 */
076     }
077     r->next = NULL;                       /* 表示当前链表结束 */
078 }
079  
080 LinkList SelectSort2(LinkList L)
081 {
082     LinkList p,q,small;
083     int temp;
084  
085     for(p = L->next; p->next != NULL; p = p->next)
086     {
087         small = p;
088         for(q = p->next; q; q = q->next)
089         {
090             if(q->data < small->data)
091             {
092                 small = q;
093             }
094         }
095         printf("循环后，获得最小值为:%d, 此时链表为:", small->data);
096         if(small != p)
097         {
098             temp = p->data;
099             p->data = small->data;
100             small->data = temp;
101         }
102         ListTraverse(L);
103     }
104     printf("输出排序后的数字:\n");
105     return L;
106 }
107  
108 LinkList SelectSort(LinkList L)
109 {
110     LinkList first;     /*排列后有序链的表头指针*/
111     LinkList tail;      /*排列后有序链的表尾指针*/
112     LinkList p_min;     /*保留键值更小的节点的前驱节点的指针*/
113     LinkList min;       /*存储最小节点*/
114     LinkList p;         /*当前比较的节点*/
115  
116     first = NULL;
117     while (L != NULL) /*在链表中找键值最小的节点。*/
118     {
119         /*注意：这里for语句就是体现选择排序思想的地方*/
120         for (p=L,min=L; p->next!=NULL; p=p->next) /*循环遍历链表中的节点，找出此时最小的节点。*/
121         {
122             if (p->next->data < min->data) /*找到一个比当前min小的节点。*/
123             {
124                 p_min = p; /*保存找到节点的前驱节点：显然p->next的前驱节点是p。*/
125                 min = p->next; /*保存键值更小的节点。*/
126             }
127         }
128  
129         /*上面for语句结束后，就要做两件事；
130             一是把它放入有序链表中；
131             二是根据相应的条件判断，安排它离开原来的链表。*/
132  
133         /*第一件事*/
134         if (first == NULL) /*如果有序链表目前还是一个空链表*/
135         {
136             first = min; /*第一次找到键值最小的节点。*/
137             tail = min; /*注意：尾指针让它指向最后的一个节点。*/
138         }
139         else /*有序链表中已经有节点*/
140         {
141             tail->next = min; /*把刚找到的最小节点放到最后，即让尾指针的next指向它。*/
142             tail = min; /*尾指针也要指向它。*/
143         }
144         /*第二件事*/
145         if (min == L) /*如果找到的最小节点就是第一个节点*/
146         {
147             //printf("表头%d已经是最小，当前结点后移。\n", min->data);
148             L = L->next; /*显然让head指向原head->next,即第二个节点，就OK*/
149         }
150         else /*如果不是第一个节点*/
151         {
152             p_min->next = min->next; /*前次最小节点的next指向当前min的next,这样就让min离开了原链表。*/
153         }
154     }
155     if (first != NULL) /*循环结束得到有序链表first*/
156     {
157         tail->next = NULL; /*单向链表的最后一个节点的next应该指向NULL*/
158     }
159     L = first;
160     return L;
161 }
162  
163 int main()
164 {
165     LinkList L;
166     Status i;
167     char opp;
168     ElemType e;
169     int find;
170     int tmp;
171  
172     i=InitList(&L);
173     printf("初始化L后：ListLength(L)=%d\n",ListLength(L));
174  
175     printf("\n1.查看链表 \n2.创建链表（尾插法） \n3.链表长度 \n4.交换两个结点 \n0.退出 \n请选择你的操作：\n");
176     while(opp != '0')
177     {
178         scanf("%c",&opp);
179         switch(opp)
180         {
181         case '1':
182             ListTraverse(L);
183             printf("\n");
184             break;
185  
186         case '2':
187             CreateListTail(&L,10);
188             printf("整体创建L的元素(尾插法)：\n");
189             ListTraverse(L);
190             printf("\n");
191             break;
192  
193         case '3':
194             //clearList(pHead);   //清空链表
195             printf("ListLength(L)=%d \n",ListLength(L));
196             printf("\n");
197             break;
198  
199         case '4':
200             L = SelectSort2(L);
201             //printf("%d \n", find);
202             ListTraverse(L);
203             printf("\n");
204             break;
205  
206         case '0':
207             exit(0);
208         }
209     }
210 }

tkp2014
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单链表排序
02-28
单链表排序
数据结构 - 单链表（百度面试题单链表的倒序打印）
chun的博客
10-02 209
方法1：反转打印（但是会改变链表结构，不建议） https://blog.csdn.net/weixin_43736084/article/details/101939789 方法2：存入栈中，在出栈 public static void reversePrint(HeroNode head){ if (head.next == null){ ret...
单链表反序
龚建波
03-10 2004
看图说话，需要用到三个连续节点的指针，用中间那个来进行反序操作（P2-&gt;next=P1）。 template&lt;typename T&gt; struct Node { T value; Node&lt;T&gt; *next; }; template&lt;typename T&gt; Node&lt;T&gt; *singleLinkedListReverse(Node...
单项链表逆序
weixin_30471561的博客
08-09 75
版权所有，转载请标明出处！ 程序1： // // main.cpp // testC++06ReverseSingleLinkedList // // Created by fei dou on 12-8-9. // Copyright (c) 2012年 vrlab. All rights reserved. // #include <iostream>...
通用版！完整代码，单链表SingleLinkedList增删改查，反转，逆序，有效数据等Java实现
叶绿体不忘呼吸
10-14 393
文章目录节点类链表类（主要）测试类小结 节点类 可以根据需要，对节点属性进行修改。注意重写toString()方法，以便后续的输出操作。 //节点类 class Node { public int id; public String name; public Node next; public Node(int id, String name) { this.id = id; this.name = name; } @Ov
单链表之链表的倒序
l769440473的博客
01-18 3318
单链表的倒序  借助结点法 今天我们要讲的如何将链表进行倒序的操作,链表的倒序操作我们讲比较普通的一种，那就是借助另一条链表或者另一个头节点来进行倒序的操作。    首先我们如图其中LA是我们的一条有数据的链表，L是一条只有一个头节点的链表，在这里我们的算法思想是将LA上的结点一个个取下来，然后一个个插入到L这条新的链表上。在插入的时候我们有几点要特别注意的就是怎样取...
单链表快速排序
11-03
大学或者考研时数据结构单链表快速排序问题,数据结构的基础代码。
shujujiegou.rar_C 单链表 排序_单链表
09-23
编写程序完成单链表的创建、插入、删除、排序、并、交、差运算、及输出等基本操作。
单链表合并排序
07-09
单链表合并排序
单链表排序和多项式分解
07-18
单链表排序和多项式分解
单链表 - SingleLinkedList
kayyoo的博客
11-28 410
链表是有序的列表，链表是以节点的方式存储的，是链式存储。每个节点包含data域，next域（指向下一个节点）。链表的各个节点不一定是连续存储。链表分为带头节点的链表和和不带头节点的链表
单链表倒序
csdn_wangchen的博客
07-04 365
单链表倒序 题目来源 牛客网 题目描述 输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 public class ListNode { int val; ListNode next = null; public ListNode(int val) { this.val = val; } public void setNext(ListNode node) { this.next = node; } }
单链表反转（逆序）
diweikang的博客
06-29 2892
面试被问到单链表反转，一脸懵逼，回来赶紧补 1、单链表的结点结构： data域：存储数据元素信息的域称为数据域； next域：存储直接后继位置的域称为指针域（链域），存储直接的下一个节点地址。 data域 + next域：组成数据的存储映射，称为结点； 注意： 链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 每个结点只有一个链域的链表称为单链表（Single L...
java实现单链表的反转倒序
new_buff_007的博客
08-05 551
实现的思路： 1.首先创建一个临时单链表single2。 2.将原来的链表single中的元素挨个取出，在取出的过程中相当于删除。 1）在取出的时候，需要将single的头指针指向它next的next headNode.next = headNode.next.next; 2) 取出res = headNode.next的时候，需要将res后边的都删掉 res.n...
单链表的倒序
notOnlyRush的博客
06-22 2337
原文：https://blog.csdn.net/evan123mg/article/details/45725357 单链表的翻转是一道很基本的算法题。 方法1：将单链表储存为数组，然后按照数组的索引逆序进行反转。 方法2：使用三个指针遍历单链表，逐个链接点进行反转。 方法3：从第2个节点到第N个节点，依次逐节点插入到第1个节点(he...
单链表的实现及实现链表的反转、逆序、倒数查询
休对故人思故国，且将新火试新茶。诗酒趁年华
01-09 247
链表是有序的列表，但它在内存中的存储如下： 小结： 链表是以节点的的方式来存储，是链式存储 每个节点包含data域，next域：指向下一个节点 链表各个节点不一定是连续存储 链表分为带头节点的链表和没有头节点的链表，根据实际的需求来确定。 带头节点的逻辑结构示意图如下： 单链表的应用实例： 定义实体类： /定义HeroNode，每个HeroNode对象就是-一个节点 class HeroN...
四、数据结构与算法 （四）单向链表面试：将链表顺序倒过来
sunweihao2019的博客
03-05 679
1.代码 1.将单向链表反向 /** * 反向设置链表 * @param head 传入要反向的头节点 */ public void reverseSetList(HeroNode head) { //判断链表是否可以反向，或没必要反向：null，或者链表长度为1，那么没有必要反向 if (head.next==null||head.next.next==null) {
单向链表实现倒排序
yinzhiqing的专栏
07-19 908
C++ 单向链表 逆序实现
c语言单链表排序z多种方法
最新发布
05-28
以下是几种C语言单链表排序的方法： 1. 冒泡排序法：对于链表中的每个节点，比较其与后面节点的值大小，如果前面节点的值大于后面节点的值，则交换它们的值。重复以上步骤，直到链表中的所有节点都被排序。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值