单向链表操作详解(二)[The End]
/*
接着讲(测试编译时,请把相应的函数及测试代码放到上一讲代码的相关地方):
排序(选择、插入、冒泡)
插入(有序)
*/
/*
===============================================
作者:rerli
时间:2003-12-08
目的:学习单向链表的创建、修改、删除、
插入(无序、有序)、输出、
排序(选择、插入、冒泡)、反序
说明:编译没有任何错误,能生成EXE文件。
这个程序TC2.0中编译生成的EXE文件,
在运行输入节点时出现以下错误(TC2.01中没有任何错误):
scanf : floating point formats not linked
Abnormal program termination
即:struct student中float score字段在输入时,
它不认float数格式,而改为long score却可以正常运行。
但是在TC2.01中float score重新编译、链接、运行很正常。
因此,我认为这是TC2.0在结构类型中的Bug.
================================================
*/
/*
==========================
功能:选择排序(由小到大)
返回:指向链表表头的指针
==========================
*/
/*
选择排序的基本思想就是反复从还未排好序的那些节点中,
选出键值(就是用它排序的字段,我们取学号num为键值)最小的节点,
依次重新组合成一个链表。
我认为写链表这类程序,关键是理解:
head存储的是第一个节点的地址,head->next存储的是第二个节点的地址;
任意一个节点p的地址,只能通过它前一个节点的next来求得。
单向链表的选择排序图示:
---->[1]---->[3]---->[2]...---->[n]---->[NULL](原链表)
head 1->next 3->next 2->next n->next
---->[NULL](空链表)
first
tail
---->[1]---->[2]---->[3]...---->[n]---->[NULL](排序后链表)
first 1->next 2->next 3->next tail->next
图10:有N个节点的链表选择排序
1、先在原链表中找最小的,找到一个后就把它放到另一个空的链表中;
2、空链表中安放第一个进来的节点,产生一个有序链表,并且让它在原链表中分离出来(此时要注意原链表中出来的是第一个节点还是中间其它节点);
3、继续在原链表中找下一个最小的,找到后把它放入有序链表的尾指针的next,然后它变成其尾指针;
*/
struct student *SelectSort(struct student *head)
{
struct student *first; /*排列后有序链的表头指针*/
struct student *tail; /*排列后有序链的表尾指针*/
struct student *p_min; /*保留键值更小的节点的前驱节点的指针*/
struct student *min; /*存储最小节点*/
struct student *p; /*当前比较的节点*/
first = NULL;
while (head != NULL) /*在链表中找键值最小的节点。*/
{
/*注意:这里for语句就是体现选择排序思想的地方*/
for (p=head,min=head; p->next!=NULL; p=p->next) /*循环遍历链表中的节点,找出此时最小的节点。*/
{
if (p->next->num < min->num) /*找到一个比当前min小的节点。*/
{
p_min = p; /*保存找到节点的前驱节点:显然p->next的前驱节点是p。*/
min = p->next; /*保存键值更小的节点。*/
}
}
/*上面for语句结束后,就要做两件事;一是把它放入有序链表中;二是根据相应的条件判断,安排它离开原来的链表。*/
/*第一件事*/
if (first == NULL) /*如果有序链表目前还是一个空链表*/
{
first = min; /*第一次找到键值最小的节点。*/
tail = min; /*注意:尾指针让它指向最后的一个节点。*/
}
else /*有序链表中已经有节点*/
{
tail->next = min; /*把刚找到的最小节点放到最后,即让尾指针的next指向它。*/
tail = min; /*尾指针也要指向它。*/
}
/*第二件事*/
if (min == head) /*如果找到的最小节点就是第一个节点*/
{
head = head->next; /*显然让head指向原head->next,即第二个节点,就OK*/
}
else /*如果不是第一个节点*/
{
p_min->next = min->next; /*前次最小节点的next指向当前min的next,这样就让min离开了原链表。*/
}
}
if (first != NULL) /*循环结束得到有序链表first*/
{
tail->next = NULL; /*单向链表的最后一个节点的next应该指向NULL*/
}
head = first;
return head;
}
/*
==========================
功能:直接插入排序(由小到大)
返回:指向链表表头的指针
==========================
*/
/*
直接插入排序的基本思想就是假设链表的前面n-1个节点是已经按键值
(就是用它排序的字段,我们取学号num为键值)排好序的,对于节点n在
这个序列中找插入位置,使得n插入后新序列仍然有序。按照这种思想,依次
对链表从头到尾执行一遍,就可以使无序链表变为有序链表。
单向链表的直接插入排序图示:
---->[1]---->[3]---->[2]...---->[n]---->[NULL](原链表)
head 1->next 3->next 2->next n->next
---->[1]---->[NULL](从原链表中取第1个节点作为只有一个节点的有序链表)
head
图11
---->[3]---->[2]...---->[n]---->[NULL](原链表剩下用于直接插入排序的节点)
first 3->next 2->next n->next
图12
---->[1]---->[2]---->[3]...---->[n]---->[NULL](排序后链表)
head 1->next 2->next 3->next n->next
图13:有N个节点的链表直接插入排序
1、先在原链表中以第一个节点为一个有序链表,其余节点为待定节点。
2、从图12链表中取节点,到图11链表中定位插入。
3、上面图示虽说画了两条链表,其实只有一条链表。在排序中,实质只增加了一个用于指向剩下需要排序节点的头指针first罢了。
这一点请读者务必搞清楚,要不然就可能认为它和上面的选择排序法一样了。
*/
struct student *InsertSort(struct student *head)
{
struct student *first; /*为原链表剩下用于直接插入排序的节点头指针*/
struct student *t; /*临时指针变量:插入节点*/
struct student *p; /*临时指针变量*/
struct student *q; /*临时指针变量*/
first = head->next; /*原链表剩下用于直接插入排序的节点链表:可根据图12来理解。*/
head->next = NULL; /*只含有一个节点的链表的有序链表:可根据图11来理解。*/
while (first != NULL) /*遍历剩下无序的链表*/
{
/*注意:这里for语句就是体现直接插入排序思想的地方*/
for (t=first, q=head; ((q!=NULL) && (q->num < t->num)); p=q, q=q->next); /*无序节点在有序链表中找插入的位置*/
/*退出for循环,就是找到了插入的位置*/
/*注意:按道理来说,这句话可以放到下面注释了的那个位置也应该对的,但是就是不能。原因:你若理解了上面的第3条,就知道了。*/
first = first->next; /*无序链表中的节点离开,以便它插入到有序链表中。*/
if (q == head) /*插在第一个节点之前*/
{
head = t;
}
else /*p是q的前驱*/
{
p->next = t;
}
t->next = q; /*完成插入动作*/
/*first = first->next;*/
}
return head;
}
/*
==========================
功能:冒泡排序(由小到大)
返回:指向链表表头的指针
==========================
*/
/*
直接插入排序的基本思想就是对当前还未排好序的范围内的全部节点,
自上而下对相邻的两个节点依次进行比较和调整,让键值(就是用它排
序的字段,我们取学号num为键值)较大的节点往下沉,键值较小的往
上冒。即:每当两相邻的节点比较后发现它们的排序与排序要求相反时,
就将它们互换。
单向链表的冒泡排序图示:
---->[1]---->[3]---->[2]...---->[n]---->[NULL](原链表)
head 1->next 3->next 2->next n->next
---->[1]---->[2]---->[3]...---->[n]---->[NULL](排序后链表)
head 1->next 2->next 3->next n->next
图14:有N个节点的链表冒泡排序
任意两个相邻节点p、q位置互换图示:
假设p1->next指向p,那么显然p1->next->next就指向q,
p1->next->next->next就指向q的后继节点,我们用p2保存
p1->next->next指针。即:p2=p1->next->next,则有:
[ ]---->[p]---------->[q]---->[ ](排序前)
p1->next p1->next->next p2->next
图15
[ ]---->[q]---------->[p]---->[ ](排序后)
图16
1、排序后q节点指向p节点,在调整指向之前,我们要保存原p的指向节点地址,即:p2=p1->next->next;
2、顺着这一步一步往下推,排序后图16中p1->next->next要指的是p2->next,所以p1->next->next=p2->next;
3、在图15中p2->next原是q发出来的指向,排序后图16中q的指向要变为指向p的,而原来p1->next是指向p的,所以p2->next=p1->next;
4、在图15中p1->next原是指向p的,排序后图16中p1->next要指向q,原来p1->next->next(即p2)是指向q的,所以p1->next=p2;
5、至此,我们完成了相邻两节点的顺序交换。
6、下面的程序描述改进了一点就是记录了每次最后一次节点下沉的位置,这样我们不必每次都从头到尾的扫描,只需要扫描到记录点为止。
因为后面的都已经是排好序的了。
*/
struct student *BubbleSort(struct student *head)
{
struct student *endpt; /*控制循环比较*/
struct student *p; /*临时指针变量*/
struct student *p1;
struct student *p2;
p1 = (struct student *)malloc(LEN);
p1->next = head; /*注意理解:我们增加一个节点,放在第一个节点的前面,主要是为了便于比较。因为第一个节点没有前驱,我们不能交换地址。*/
head = p1; /*让head指向p1节点,排序完成后,我们再把p1节点释放掉*/
for (endpt=NULL; endpt!=head; endpt=p) /*结合第6点理解*/
{
for (p=p1=head; p1->next->next!=endpt; p1=p1->next)
{
if (p1->next->num > p1->next->next->num) /*如果前面的节点键值比后面节点的键值大,则交换*/
{
p2 = p1->next->next; /*结合第1点理解*/
p1->next->next = p2->next; /*结合第2点理解*/
p2->next = p1->next; /*结合第3点理解*/
p1->next = p2; /*结合第4点理解*/
p = p1->next->next; /*结合第6点理解*/
}
}
}
p1 = head; /*把p1的信息去掉*/
head = head->next; /*让head指向排序后的第一个节点*/
free(p1); /*释放p1*/
p1 = NULL; /*p1置为NULL,保证不产生“野指针”,即地址不确定的指针变量*/
return head;
}
/*
==========================
功能:插入有序链表的某个节点的后面(从小到大)
返回:指向链表表头的指针
==========================
*/
/*
有序链表插入节点示意图:
---->[NULL](空有序链表)
head
图18:空有序链表(空有序链表好解决,直接让head指向它就是了。)
以下讨论不为空的有序链表。
---->[1]---->[2]---->[3]...---->[n]---->[NULL](有序链表)
head 1->next 2->next 3->next n->next
图18:有N个节点的有序链表
插入node节点的位置有两种情况:一是第一个节点前,二是其它节点前或后。
---->[node]---->[1]---->[2]---->[3]...---->[n]---->[NULL]
head node->next 1->next 2->next 3->next n->next
图19:node节点插在第一个节点前
---->[1]---->[2]---->[3]...---->[node]...---->[n]---->[NULL]
head 1->next 2->next 3->next node->next n->next
图20:node节点插在其它节点后
*/
struct student *SortInsert(struct student *head, struct student *node)
{
struct student *p; /*p保存当前需要检查的节点的地址*/
struct student *t; /*临时指针变量*/
if (head == NULL) /*处理空的有序链表*/
{
head = node;
node->next = NULL;
n += 1; /*插入完毕,节点总数加1*/
return head;
}
p = head; /*有序链表不为空*/
while (p->num < node->num && p != NULL) /*p指向的节点的学号比插入节点的学号小,并且它不等于NULL*/
{
t = p; /*保存当前节点的前驱,以便后面判断后处理*/
p = p->next; /*后移一个节点*/
}
if (p == head) /*刚好插入第一个节点之前*/
{
node->next = p;
head = node;
}
else /*插入其它节点之后*/
{
t->next = node; /*把node节点加进去*/
node->next = p;
}
n += 1; /*插入完毕,节点总数加1*/
return head;
}
/*
测试代码如下:
*/
/*测试SelectSort():请编译时去掉注释块*/
/*
head = SelectSort(head);
Print(head);
*/
/*测试InsertSort():请编译时去掉注释块*/
/*
head = InsertSort(head);
Print(head);
*/
/*测试BubbleSort():请编译时去掉注释块*/
/*
head = BubbleSort(head);
Print(head);
*/
/*测试SortInsert():上面创建链表,输入节点时请注意学号num从小到大的顺序。请编译时去掉注释块*/
/*
stu = (struct student *)malloc(LEN);
printf("/nPlease input insert node -- num,score: ");
scanf("%ld,%f",&stu->num,&stu->score);
head = SortInsert(head,stu);
free(stu);
stu = NULL;
Print(head);
*/
(全文完)
单向链表操作详解(二)[The End]相关推荐
- Java单向链表操作详解
/* 先定义一个Node类用来存储节点的值域和指针域 * 即当前节点中的值和后面节点的方法 * 在C中就是相当与定义一个结构体类型一个数据域和指针域的方法 */ class LNode{//这个写法已 ...
- 数据结构—单向链表(详解)
一.链表基础 链表是一种常见的数据结构,其中运用到了结构体指针,链表可以实现动态存储分配,换而言之,链表是一个功能强大的数组,可以在某个节点定义多种数据类型,可以实现任意的添加,删除,插入节点等.链表 ...
- 跟我学python之mysql操作详解 一、查询操作
在python中,我们使用PyMySQL来操作mysql. 一.安装PyMySQL: 使用pip进行安装,命令为: pip install PyMySQL 二.在进行操作之前,首先要打开本机的mysq ...
- Android面试Hash原理详解二
Hash系列目录 Android面试Hash原理详解一 Android面试Hash原理详解二 Android面试Hash常见算法 Android面试Hash算法案例 Android面试Hash原理详解 ...
- 数据结构--图(Graph)详解(二)
数据结构–图(Graph)详解(二) 文章目录 数据结构--图(Graph)详解(二) 一.图的存储结构 1.图的顺序存储法 2.图的邻接表存储法 3.图的十字链表存储法 4.图的邻接多重表存储法 二 ...
- python列表切片后得到剩余列表_python列表切片和嵌套列表取值操作详解
python列表切片和嵌套列表取值操作详解 给出列表切片的格式: [开头元素::步长] # 输出直到最后一个元素,(最后一个冒号和步长可以省略,下同) [开头元素:结尾元素(不含):步长] # 其中, ...
- 安卓 linux init.rc,[原创]Android init.rc文件解析过程详解(二)
Android init.rc文件解析过程详解(二) 3.parse_new_section代码如下: void parse_new_section(struct parse_state *state ...
- SVN的Windows和Linux客户端操作详解
SVN的Windows和Linux客户端操作详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.Windows客户端操作 1.安装SVN客户端 a>.去官网下载svn软件 ...
- python3d动态图-Python图像处理之gif动态图的解析与合成操作详解
本文实例讲述了Python图像处理之gif动态图的解析与合成操作.分享给大家供大家参考,具体如下: gif动态图是在现在已经司空见惯,朋友圈里也经常是一言不合就斗图.这里,就介绍下如何使用python ...
最新文章
- Confluence 6 使用一个页面为站点的默认页面
- typedef的用途
- mysql排序分页乱的_Mysql 排序分页混乱
- python中运行错误: 'utf-8' codec can't decode byte 0xc8'
- weblogic常见漏洞
- PE文件格式和ELF文件格式(上)----PE文件
- 为什么需要架构图,怎么画?
- MFC 强大功能函数
- 【LeetCode 剑指offer刷题】特殊数题3:204 Count Primes
- windows系统bat批处 注册一个exe执行文件变成服务
- matlab生成低通滤波,用matlab设计低通滤波器
- 无代码app在线制作网站:自己做app的制作方法
- 关于网络超时时间那些事
- 分区助手扩大c盘后自动修复_分区助手扩大c盘的详细操作步骤
- python123第三次作业的解答
- aes离线解密工具_AES-加密解密工具类
- 【转】如何使用visual studio将你的程序打包成安装包
- 被社会毒打的20年毕业的后端
- HDU - 1431 素数回文 [ 学到了 ]
- 电子表格文件读写控件Spreadsheet免费下载购买地址
热门文章
- 微信小程序——事件委托
- 马拉车(manacher),KMP
- Nginx配置——反向代理
- Elasticsearch 整合机器学习强化排序
- 视频直播,点播,悬浮小窗口播放demo (使用阿里云sdk)
- java游戏赏金猎人,【图片】[0.65.1a] Starsector+ Vanilla Enhancement Mod 新版本持续更新【远行星号吧】_百度贴吧...
- linux https中使用阿里云加速
- UTP、STP是什么
- 毕设走过的路——如何研究(一)
- vue3知识点:provide 与 inject