c++单向链表的排序

河北联合大学 2011-2012 第 2 学期
《软件设计基础 -C++》
课程设计报告
设计名称：设计一个处理单向链表的程序：链表的排序姓名：王学增学号：201005100206
专业班级：土木工程 1 班学院：建筑工程学院
设计时间：2012-5-31 设计地点：机房
指导教师评语：教师评定：自评成绩；75
指导教师签字：
年年月月日日

《软件设计基础-C++》课程设计报告
第
2
页，共
16 页
目
录
1.课程设计目的···································· ···································· ···································· 2.课程设计任务与要求 ································ ································ ······························· 3.课程设计说明书··································· ··································· ·································· 4.课程设计成果···································· ···································· ···································· 5.程序调试过程···································· ···································· ···································· 6.设计问题的不足和改进方案 ···························· ···························· ··························· 7.课程设计心得···································· ···································· ···································· 8.参考文献······································· ······································· ······································

《软件设计基础-C++》课程设计报告
第
3
页，共
16 页
1．课程设计目的
《软件设计基础-C++》课程设计是这门课程的实践性教学环节之一，本次设计结合实际应用的要求，使课程设计既覆盖 C++的知识点，又接近工程实际需要。目的是通过课程设计的综合训练，培养学生实际分析问题、解决问题的能力，以及编程和动手能力，最终目标是通过课程设计这种形式，帮助学生系统掌握 C++这门课程的主要内容，养成良好的编程习惯，更好的完成教学任务。
2．课程设计任务与要求：
要求：
本次课程设计利用《软件设计基础-C++》课程中所学到的编程知识和编程技巧，完成具有一定难度和工作量的程序设计题目，帮助学生掌握编程、调试的基本技能，独立完成所布置的任务。要求： 1、对系统进行功能需求分析 2、设计合理的数据结构和系统框架 3、编程简练，程序功能齐全，能正确运行 4、说明书、流程图要清楚 5、课题完成后必须按要求提交课程设计报告任务：
将自己选择题目的任务要求简单填写在此处。
（1）要求用 C++的思想来完成程序的设计。（2）各个功能分别使用函数来完成，主函数和各个函数分别存放在不同的.cpp 文件中，要求使用头文件。 (3)在基本要求达到后，进行创新设计，例如：将两个非递减的链表合并成一个新的非递减的链表

《软件设计基础-C++》课程设计报告
第
4
页，共
16 页
3．课程设计说明书
⑴概要设计主要写模块说明，模块结构图，系统流程图（例 N-S 流程图）（五号，宋体）
模块说明: 在我设计的程序中一共包括了六个模块,分别是:新增模块、查找模块、修改模块、完全打印模块、删除模块、退出系统模块。这六个模块中新增、查找和修改都是独立分开作为子函数的，另外三个则是作为 switch 语句中的一部分，通过 switch 语句，把六大模块联系了起来，同时，为了实现多次使用这六大模块，就在 switch 语句外加了 while 循环。我的程序模块说明：在我设计的程序中一共可以分成三个模块，分别是数据打印模块，冒泡排序模块，主函数模块。其中，数据打印模块和冒泡排序模块都采用了 for 循环。并且这两个模块都是
模块结构图：
链表的排序打印数据主函数排序后输出
冒泡排序
⑵详细设计总体流程图：
头文件建立函数冒泡排序打印数据
主函数进行排序，输出。
各功能模块流程图
（1）打印数据的流程图：（以下是应用的 for 循环）

《软件设计基础-C++》课程设计报告
第
5
页，共
16 页
i=1
判断 i>n?
否执行 print i
i=i+1
结束循环，cout<<"
"<cout<<"\n"
i=1
判断 i>n?
否执行 print i
i=i+1
结束循环，cout<<"
"<cout<<"\n"

《软件设计基础-C++》课程设计报告 (接上页)
i=1
第
6
页，共
16 页
判断 i>n?
否执行 print i
i=i+1
结束循环，cout<<"
"<cout<<"\n"
（2）泡沫排序的流程图

《软件设计基础-C++》课程设计报告注：上述数组 d 为 r[j].score （3）主函数流程图
第
7
页，共
16 页
主函数
定义成员个数
确定成员信息
打印出成员数据
进行冒泡排序
得到排序后的成员信息

《软件设计基础-C++》课程设计报告
第
8
页，共
16 页
4．课程设计成果
程序源代码，运行结果（可用屏幕抓图的方法说明）（五号，宋体）(多页) （1）链表排序的源代码 #include #include // 头文件 #define N 100
typedef int
keytype;
typedef char xingming[5]; typedef char xingbie[5]; typedef struct num // 建立 { keytype score; xingming name; xingbie sex; }numpx[N];
struct num sqlist[N+1];
void px(numpx r,int n) // 冒泡排序 { int i,j; for(i=1;ir[j+1].score) { r[0]=r[j]; r[j]=r[j+1]; r[j+1]=r[0]; } } } }

《软件设计基础-C++》课程设计报告
第
9
页，共
16 页
void print(numpx list,int n) // 打印数据 { int i; for(i=1;i<=n;i++) { cout<<" } cout<<"\n"; for(i=1;i<=n;i++) { cout<<" } cout<<"\n"; for(i=1;i<=n;i++) { cout<<" } cout<<"\n"; } "<void main() { int n=10;
// 主函数
numpx a={0,"","",16,"小斯","男",24,"伊娃","女",13,"韦德","男",35,"杜兰","男",20,"阿伦","男 ",37,"李娜","女",55,"凯文","男",11,"罗斯","男",18,"波什","男",10,"刘兰","女"}; cout<<"\n"; cout<<"原系列数据:\n"; print(a,10); cout<<"\n"; px(a,n); cout<<"排序的序列（从低到高）：\n"; print(a,n); }

《软件设计基础-C++》课程设计报告
第
10
页，共
16 页
(2)运行以上源程序后的运行结果：

《软件设计基础-C++》课程设计报告 5.程序调试过程
写出程序调试步骤，及遇到的问题。（1）这时程序已经可以运行，但数据出现错误：没有输出第一组数。
第
11
页，共
16
页
这是字符数组那块的知识，在数据前加上“0,"","",”即可是程序完整显示。

《软件设计基础-C++》课程设计报告
（2）可以看出数据还是极不规范，需要对数据进行换行需要在数据打印模块中每一个 for 循环后加 cout<<"\n"; 调试后的结果为：
第
12
页，共
16 页
（3）下面对每组数据的间隔进行处理将语句 cout<

《软件设计基础-C++》课程设计报告
再改进一下间距：
第
13
页，共
16 页
（4）调试到现在程序已经大概完成，为与结果一样，需要在主函数中，print(a,10);后加上 cout<<"\n"; 得到下面程序：

《软件设计基础-C++》课程设计报告 6.设计问题的不足和改进方案
我认为这个程序应该还可以对链表进行插入和删除操作链（参照 18 题）
第
14
页，共
16 页
方案：根据三的分析，主要问题在于链表的创建以及如何插入和删除的操作上。如需要创建 N=5 个结点， if(i==1) head=p1; else p2->next =p1; p2=p1; p1=new(STUDENT); cin>>p1->stu_number >>p1->name >>p1->sex >>p1->age; p2->next =NULL; 则插入操作： t=p->next; p->next=q; q->next=t; n++;//结点数目增加这样就将该新结点插入到了指定位置，注意考虑要插入的结点可能位于最后的位置。删除时，要考虑待删除结点是否为第一个结点，若为中间结点，设指针变量 p1 指向的结点为待删除结点，p2 指向其前一个结点，则删除 p2 结点的操作为： p2->next=p1->next; //最后一个结点的 next 成员不指向任何结点在插入时，先根据学号找到新结点的位置，例如要插入到指针变量 p 指向的结点后，设 q 指向新结点， //将链表中第一个新建结点作为表头

《软件设计基础-C++》课程设计报告 7.课程设计心得
第
15
页，共
16 页
通过对 c++的学习，以及对 c++的课程设计，我对 c++产生很大的兴趣。课程设计是培养学生综合运用所学知识,分析和解决实际问题,锻炼实践能力的一个重要过程。当今计算机应用已经普及到我们生活的方方面面。所以学好计算机知识，学好 c++,做好课程设计是非常重要的。我的 c++基础并不好。在大一的时候学过一点 c 语言，只是简单了解其中的一些函数和算法。对于编程，我只能望尘莫及。经过这学期 c++的学习，我也进一步加深了对 c++的理解。课程设计虽然从某种意义上讲很难。但自从拿到题目到完成整个编程，从理论到实践，我学到很多很多的的东西，同时不仅可以巩固了以前所学过的知识，而且学到了很多在书本上所没有学到过的知识。。通过这次课程设计使我懂得了实践是检验理论的重要标准，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，才能真正提高自己的动手能力和独立思考的能力。我在设计过程中也遇到了好多问题。我在后悔当时没好好听课的的时候，也开始复习老师讲过的知识以及上网查资料学习。我及时改正了我的不足之处，对学过的知识更加深刻了。同时，我也学到了一些课外知识。我懂得了：不怕做不到，就怕不去做。只要我们有一种永不放弃的执着精神，没有什么办到的。最后，感谢老师这学期在 c++上为我们所做的一切。同时，对给过我帮助的所有同学表示忠心的感谢！

《软件设计基础-C++》课程设计报告 8.参考文献
（1）《C++程序设计》谭浩强编著清华大学出版社，2004 年版
第
16
页，共
16 页
（2）《C++程序设计教程》
钱能编著清华大学出版社，1999 年版
（3）《从新手到高手：C++全方位学习》范磊编著
科学出版社
（4）《C++程序设计》曾辉主编
北京邮电大学出版社
（5）《C++程序设计》李宁主编
中央广播电视大学出版社

历年链表考题及答案

历年链表考题及答案 [2005秋II.14] 设已建立了两条单向链表，这两链表中的数据已按从小到大的次序排好，指针h1和h2分别指向这两条链表的首结点。链表上结点的数据结构如下： struct node{ int data; node *next; }; 以下函数node *Merge(node *h1, node *h2)的功能是将h1和h2指向的两条链表上的结点合并为一条链表，使得合并后的新链表上的数据仍然按升序排列，并返回新链表的首结点指针。算法提示：首先，使newHead和q都指向首结点数据较小链表的首结点，p指向另一链表首结点。其次，合并p和q所指向的两条链表。在q不是指向链尾结点的情况下，如果q 的下一个结点数据小于p指向的结点数据，则q指向下一个结点；否则使p1指向q的下一个结点，将p指向的链表接到q所指向的结点之后，使q指向p所指向的结点，使p指向p1所指向的链表。直到p和q所指向的两条链表合并结束为止。注意，在合并链表的过程中，始终只有两条链表。 [函数] （4分） node * Merge(node *h1, node *h2) { node *newHead, *p, *p1; // 使newHead和q指向首结点数据较小链表的首结点，p指向另一链表首结点if( (27) ) { newHead=h1; p=h2; } // h1->datadata else { newHead=h2; p=h1; } node *q=newHead; // 合并两条链表 while( q->next) { if( q->next->data < p->data ) (28) ; // q=q->next else { (29) ; // p1=q->next q->next=p; q=p; p=p1; } } q->next=p; (30) ; // return newNead } [2005春II.11] 设已建立一条单向链表，指针head指向该链表的首结点。结点的数据结构如下： struct Node{ int data; Node *next; }; 以下函数sort(Node *head)的功能是：将head所指向链表上各结点的数据按data值从小

数据结构第三次实验+第二题链表排序

数据结构实验报告实验名称：实验三——排序学生姓名：XXX 班级：xxxxxxxxxxx 班内序号：学号：日期：2018年6月3日 1．实验要求实验目的：通过选择下面两个题目之一，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。实验内容：使用链表实现下面各种排序算法，并进行比较。排序算法： 1、插入排序 2、冒泡排序 3、快速排序 4、简单选择排序 5、其他要求： 1、测试数据分成三类：正序、逆序、随机数据 2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。 3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作） 4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。 2. 程序分析 2.1 存储结构

单链表，储存每个元素值同时，储存该元素的直接后继元素位置信息。即数据域（data），指针域（next）。struct Node { int data; struct Node *next; }; 2.2 关键算法分析链表的建立： Linklist::Linklist (int a[],int n) { front = new Node; Node *r = front ; for(int i=0;idata = a[i]; r->next = s; r=s; } r->next = NULL; } 尾插法创建链表：①堆中建立新节点②将a[i]写入新节点data域③新节点加入链表r->next=s. ④修改尾指针r=s. 简单选择排序： void Linklist ::Link_Selectsort (int n) { Node *p=front->next ; int a=0,b=0; //a记载比较次数，b记载移动次数 while(p!=NULL) { Node *s =p; //s指向最小节点 Node *q=p->next ; while(q!=NULL)

C语言链表的建立、插入和删除

数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个大小的数组，有时需要5 0个数组的大小，难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间，决不构成对存储区的浪费。链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，下面将逐一介绍。 7.4.1 单链表图7 - 3是单链表的结构。单链表有一个头节点h e a d，指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员（实际需要保存的数据）和指向下一个结构体类型节点的指针即下一个节点的地址（事实上，此单链表是用于存放整型数据的动态数组）。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问那一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为N U L L。图7 - 3还给出这样一层含义，链表中的各节点在内存的存储地址不是连续的，其各节点的地址是在需要时向系统申请分配的，系统根据内存的当前情况，既可以连续分配地址，也可以跳跃式分配地址。看一下链表节点的数据结构定义： struct node { int num; struct node *p; } ; 在链表节点的定义中，除一个整型的成员外，成员p是指向与节点类型完全相同的指针。在链表节点的数据结构中，非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。 ?单链表的创建过程有以下几步： 1 ) 定义链表的数据结构。 2 ) 创建一个空表。 3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。 4 ) 将新节点的指针成员赋值为空。若是空表，将新节点连接到表头；若是非空表，将新节点接到表尾。 5 ) 判断一下是否有后续节点要接入链表，若有转到3 )，否则结束。 ?单链表的输出过程有以下几步 1) 找到表头。

冒泡排序的算法及其程序实现

冒泡排序的算法及其程序实现浙江省慈溪中学施迪央教学分析：本节课是浙江教育出版社出版的普通高中课程标准实验教科书《算法与程序设计》第二第3节以及第五章第3节的部分教学内容。一组不长的数据（如5个），从小到大排序，对学生来说是一件容易的事情，但他们并不知道计算机是怎么实现排序的，同时他们也没见识过计算机对大量数据（如1000个）的排序。学习排序有助于学生对计算机工作原理的认识。冒泡排序对学生来说初次接触，但前面的枚举算法和解析算法的部分内容对学习排序有一定的帮助，如数组变量的定义及使用方法、双重循环的使用方法及特点以及如何通过键盘输入一批数据（即text1_keypress()事件）在前面都已涉及，冒泡排序的学习又可以巩固前面的知识。关于冒泡排序的算法及程序实现我安排了3个课时，本案例是在教室内完成的2节随堂课，第3课时安排学生上机实践：对键盘输入的一批数据进行冒泡排序。教学目标： 1、知识与技能：了解排序及冒泡排序的概念及特点掌握冒泡排序算法的原理初步掌握冒泡排序的程序实现 2、过程与方法：理解冒泡排序的分析过程，并初步掌握用冒泡排序算法来设计解决简单的排序问题 3、情感态度与价值观：通过冒泡排序算法的分析过程，培养学生思维的严谨性以及用科学方法解决问题的能力使学生深入理解计算机的工作原理，激发了学生学习程序兴趣。教学重点：冒泡排序算法的原理教学难点：分析冒泡排序的实现过程教学策略：讲授法与探究法。教师讲授、学生听讲，教师提问、学生动脑，层层深入，步步为营，一切水到渠成。教学准备：编写好手动输入一批的数据的冒泡排序的程序编写好计算机自动生成数据的冒泡排序的程序课堂中使用的教学课件教学过程：一、问题引入问题一：什么是排序？所谓排序，把杂乱无章的一列数据变为有序的数据,比如7，3，4，8，1这五个数据从小到大排序，结果是1，3，4，7，8，我们很容易排出来。那么电脑是怎么进行排序的呢？问题二：一批数据在VB中如何存储的?比如如何存储六位裁判为一位运动员评出的分数? 用数组变量来存储一批类型、作用相同的数据，如分别用d(1),d(2),d(3),d(4),d(5),d(6)来存储六位裁判给出的分数。问题三：如果运动员的最后得分是从这6个分数中去掉最高分与最低分后的平均分，你认为

链表排序算法总结

这个星期做数据结构课设，涉及到两个基于链表的排序算法，分别是基于链表的选择排序算法和归并排序算法。写出来跟大家一起分享一下，希望对数据结构初学朋友有所帮助，高手就直接忽视它吧。话不多说，下面就看代码吧。 [c-sharp]view plaincopy 1.node *sorted(node *sub_root) 2.{ 3.if (sub_root->next) 4. { 5. node * second_half = NULL; 6. node * first_half = sub_root; 7. node * temp = sub_root->next->next; 8.while (temp) 9. { 10. first_half = first_half->next; 11. temp = temp->next; 12.if(temp) 13. temp = temp->next; 14. } 15. second_half = first_half->next; 16. first_half->next = NULL; 17. node * lChild = sorted(sub_root); 18. node * rChild = sorted(second_half); 19.if (lChild->data < rChild->data) 20. { 21. sub_root = temp = lChild; 22. lChild = lChild->next; 23. } 24.else 25. { 26. sub_root = temp = rChild; 27. rChild = rChild->next; 28. } 29.while (lChild&&rChild) 30. { 31.if (lChild->data < rChild->data ) 32. { 33. temp->next = lChild; 34. temp = temp->next; 35. lChild = lChild->next; 36. } 37.else 38. {

实验1顺序表和链表基本操作(学生)

实验一线性表运算的实现班级学号姓名一、实验预备知识 1．复习C中函数的相关内容。 2．复习如何用主函数将多个函数连在一起构成一个C完整程序。 3．复习多文件结构。二、实验目的 1．掌握线性表的顺序和链式存储结构 2．熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算 3．熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求 1．编写初始化并创建线性表和输出线性表的算法。 2．编写对线性表插入和删除运算算法，要判断位置的合法性和溢出问题。 3．编写有序表的插入和删除运算算法。 4．编写一个主函数，将上面函数连在一起，构成一个完整的程序。 5．将实验源程序调试并运行，写出输入、输出结果，并对结果进行分析。四、实验内容顺序表实验内容： 1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。 2．初始化并建立顺序表。（开辟的存储空间大小为8） 3．编写顺序表输出算法。 4．依次插入3，21，15三个数，分别插入在第4，6和2位置，每插入一次都要输出一次顺序表。 5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次顺序表。 6．编写一个排序算法，对线性表中元素从小到大排列。 7．向有序表分别插入20和50，插入后表仍然有序。（修改开辟的存储空间大小为15）单链表实验内容： 1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。 2．建立一个带表头结点的单链表（前插入法和尾插入法都可以）。 3．编写单链表输出算法。 4．依次插入3，21，15三个数，分别插入在第4，6和12位置，每插入一次都要输出一次单链表。 5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次单链表。 6．编写一个排序算法，对线性表中元素从小到大排列。 7．分别删除值为25和42的元素，删除后表仍然有序。五、实验结果给出程序清单及输入/输出结果六、总结 1．实验过程中遇到的问题及解决方法 2．收获

链表习题高考真题

（2）下列程序的功能是实现向head指向的链表中插入新结点s，如图17所示，使该链表按结点的id值保持升序排列。图17 #include #include typedef struct Node{ int id; char *name; struct Node *next; }Node; void Innode(Node *head,int id,char *str) { int j=0; Node *p,*q,*s; p=head; while( ④) { q=p; p=p->next; } s=(Node*)malloc(sizeof(Node)); s->id=id; s->name=str; ⑤ ⑥ } main() { /*省略创建链表head的代码*/ Innode(head,3,”Jone”); } 36．Merge函数用于将两个升序的链表head1和head2合并成一个链表，并保持合并后链表依然升序。排序的依据为结构体类型Node中的data成员，合并中不得删除节点。下面给出Merge函数的主体框架,在空出的五个位置补充该主体框架缺失的代码段。注意：不能定义新的变量，可不用已定义的某些变量。 typedef struct Node { int data； struct Node *next； }Node； Node *Merge(Node *head1，Node *head2) { if ( head1==NULL) return head2； if(head2==NULL) return headl； Node *head=NULL；//head指针用于指向合并后链表的头结点 Node *pl=NULL； Node *p2=NULL； if(headl->datadata){ head=headl； ______①______

高中信息技术_冒泡排序算法教学设计学情分析教材分析课后反思

高一冒泡排序教学设计基本路线：数组-排序-冒泡排序【冒泡排序原理--流程图-算法优化】-小结一、教材分析：本节内容选自浙江教育出版社《算法与程序设计》第五章第三节。本节课主要讲解冒泡排序思想。排序算法是使用频率最高的算法之一，而冒泡排序是其中一种很典型而且相对简单的方法。它的学习同时为后面的选择排序做了铺垫。教学目标知识目标：掌握冒泡排序的原理；掌握冒泡排序的流程图；能力目标：学会使用冒泡排序思想设计解决简单排序问题的算法；进一步理解程序设计的基本方法，体会程序设计在现实中的作用；进一步学习流程框图的使用。情感目标：增强分析问题、发现规律的能力，激发学习热情；学情分析通过前面的学习，学生已经了解vb算法设计的基本知识，学会利用自然语言和流程图描述解决问题的算法，对排序中循环语句以有了一定的基础。但数组变量的使用方法尚未接触，程序设计思想比较弱，在实际生活中往往忽视运用排序算法来处理实际问题，这就要求学生通过本节课的学习，学会运用冒泡排序算法来处理实际问题，并为以后学习其它排序算法打下基础。二、重点难点重点：理解冒泡排序原理及它的流程图

难点：理解冒泡排序中的遍、次等概念（即对变量使用的理解）以及用流程图描述冒泡排序的过程三、教学策略与手段采用讲解法、演示法、分析归纳法引导学生参与思考，用逐步求精的方式降低学生的理解难度，化抽象为具体，由特殊到一般，有效地突出重点、突破难点。四、课前准备 1．教师的教学准备：冒泡排序的课件、学案、素材 2．教学环境的设计与布置：多媒体网络教室、电子白板、多媒体教学平台等五、教学过程课前学习【设计意图】学生能自己学会的不讲。排序数组知识点相对简单，由学生自学完成，之前的知识点学生可能会有所遗忘，通过这个方式让学生回顾。冒泡排序算法原理比较容易也由学生自学完成。已给出的素材，完成学案关于数组、冒泡排序和循环结构的基本模式的相关部分的内容，。请同学们学习学习网站上的课前学习，并完成学案的相关部分的内容。上课！对答案。

基于链表的排序和查找算法的设计与实现

《数据结构》实践任务书学生姓名：专业班级：指导教师：题目: 基于链表的排序与查找要求：（1）熟练掌握基本的数据结构；（2）熟练掌握各种算法；（3）运用高级语言编写质量高、风格好的应用程序。主要任务: 1、系统应具备的功能：（1）建立链表（2）基于链表的排序算法实现（3）基于链表的查找算法实现 2、数据结构设计； 3、主要算法设计； 4、编程及上机实现； 5、撰写数据结构实践报告，包括：（1）设计题目；（2）摘要和关键字；（3）正文，包括引言、需求分析、数据结构设计、算法设计、程序实现及测试等；（4）结束语；（5）参考文献。时间安排：2014年-2015年第1学期第15周-第17周 15周星期五 1-4节系统设计，数据结构设计，算法设计 16周星期四 5-8节编程并上机调试 16周星期五 1-4节编程并上机调试 17周星期四 5-8节验收程序，提交数据结构实践报告书指导教师签名：2014年11月

基于链表的排序和查找算法的设计与实现摘要：该程序的主要功能是对以链表为存储结构的数值型数据进行查找和排序。排序和查找是链表中的一个重要应用。本文对输入的n个整数进行内部排序，使用交换排序来实现。在本程序中应用链式存储结构，对数据进行了基本的查找和排序。关键字：存储结构链表排序排序。 1.引言查找是求出一个数据元素在序列中的索引或指针，将其返回，本程序返回的为指针。排序是将一个数据元素(或记录)的任意序列，重新排列成一按关键字(或排序码)有序的序列，以便于进行数据查询。 2.需求分析本程序是基于链表的排序和查找，所以数据的存储结构为连式存储结构。文件中记录用节点来表示，其物理位置任意，节点之间用指针相连，链表结构的有点在于排序是无需移动记录，只需修改相应记录的指针即可。排序本程序选用交换排序。 3.数据结构设计

顺序链表

#include #include #define initsize 100 #define increa 10 int length=0;/*包含标记符号-1，实际元素长度要减去一*/ int size=0;/*存储空间大小*/ int *initlist() { int *head; head=(int*)malloc(initsize*sizeof(int)); if(head==NULL) { printf("malloc error"); exit(0); } length=0; size=100;

// printf("when you initlist,you should typein your element as follow\n,so you'd better chose '2'!!!!\n"); printf("***********************************************\n"); return head; } void typeelem(int *p) { int n; int *head; head=p; printf("type in you elem \nps.add -1 as an end to have a stop\n输入正整数数据，以-1作为结尾标志，-1不算入链表元素\n"); if(length>=size) { p=(int*)realloc(p,initsize*sizeof(int)); size+=increa; } scanf("%d",&n); length++; while(n!=-1) { if(length>=size) { p=(int*)realloc(p,initsize*sizeof(int)); size+=increa; } *head=n; head++; length++; scanf("%d",&n); } printf("***********************************************\n"); } void printlist(int *head) { int *p; int i; p=head;

双向链表实验报告

13软工转本1 钱剑滨实验报告双向链表实验报告信息工程系 13软工转本1 日期 2016年03月12日姓名钱剑滨学号 13131116 电话一、实验内容编写关于双向链表操作的C语言程序，要求包含双向链表的创建（生成）、输出（遍历）、查找、任意位置插入、有顺序插入、删除、等。二、实验步骤 1.分析操作所需思路，熟练运用单链表的各种特点。 2.编写程序，利用函数特性进行操作。 3.运行程序，纠正错误，对预测结果进行验证。 4.分析总结单链表的优缺点，并可以做到熟练掌握双向链表的各种操作。三、设计概要 1.本实验包含了7个函数： a)主函数main() b)创建链表函数Listcreate() c)数据输出函数Listprint() d)查找数据函数Listlocate() e)无序插入函数Listinsert_discretion () f)有序插入函数Listinsert_order g)删除数据函数Listdelete() 2.明确函数的功能； a)Listcreate() 创建一个可控长度的斐波那契数列的双向链表。 b)Listprint() 将此链表中的数据全部输出。 c)Listlocate() 查找此链表中任意位置元素的值。 d)Listinsert_discretion ()向此链表的某个位置插入一组数据。 e)Listinsert_order() 向数列中插入一个数，使插入后的数列任然有序 f)Listdelete() 将此链表的某个位置的一组数据删除。

四、程序设计 1.函数前包含的头文件名、结点类型定义、全局变量和函数声明 #include #include typedef struct number //定义结构体 { struct number *prior； int num; struct number *next; }number; number *head; //定义全局变量头节点 int k = 0; //k记录元素个数，防止溢出 /*函数声明*/ void Listcreate(); //建立链表 void Listprint(); //全体输出 void Listlocate(); //查找 void Listinsert_discretion(); //任意位置插入 void Listinsert_order(); //有顺序插入 void Listdelete(); //删除 2.主函数main() void main() { int select; printf("1、输入斐波那契数列的个数\n"); printf("2、全部输出数列\n"); printf("3、查找定位数列的元素\n"); printf("4、添加数列元素\n"); printf("5、插入顺序数列元素\n"); printf("6、删除数列元素\n"); printf("-------------------------------------\n"); while (1) { printf("请选择序号\n"); scanf("%d", &select); switch (select) { case 1: Listcreate(); break; //链表创建 case 2: Listprint(); break; //全链表输出 case 3: Listlocate(); break; //元素查找 case 4: Listinsert_discretion(); break; //任意位置插入

两个线性表合并成一个线性表

#include #include //节点结构 struct LinkList { int data; struct LinkList * next; }; void main() { int a[8]={1,3,4,7,7,8,34,45}; int b[9]={1,2,4,7,9,12,33,43,56}; LinkList *pa=NULL; LinkList *pb=NULL; LinkList *pc=NULL; LinkList *la=NULL;//la,lb,lc保存链表首地址 LinkList *lb=NULL; LinkList *lc=NULL; // 初始化单链表 for(int i=7;i>=0;i--) { pa=(LinkList *) malloc(sizeof(struct LinkList)); pa->data=a[i]; pa->next=la; la=pa; } for(int j=8;j>=0;j--) { pb=(LinkList *) malloc(sizeof(struct LinkList)); pb->data=b[j]; pb->next = lb; lb=pb; } lc=pc=(LinkList *) malloc(sizeof(struct LinkList));//LC指向单链表的头节点 //递增排序 while(pa && pb) {

if( (pa->data) <= (pb->data) ) { pc->next=pa; pc=pc->next; pa=pa->next; } else { pc->next=pb; pc=pc->next; pb=pb->next; } } if(pa) { pc->next=pa; } if(pb) { pc->next=pb; } pc=lc->next; while(pc) { printf("%d\t",*pc); pc=pc->next; } printf("\n"); }

北邮数据结构实验四-链表排序

数据结构实验报告实验名称：实验四——链表的排序学生姓名：班级：班内序号：学号：日期： 1．实验要求 [内容要求] 使用链表实现下面各种排序算法，并进行比较。排序算法： 1、插入排序 2、冒泡排序 3、快速排序 4、简单选择排序 5、其他要求： 1、测试数据分成三类：正序、逆序、随机数据 2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。 3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作） 4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性代码要求 1、必须要有异常处理，比如删除空链表时需要抛出异常； 2、保持良好的编程的风格：代码段与段之间要有空行和缩近标识符名称应该与其代表的意义一致函数名之前应该添加注释说明该函数的功能关键代码应说明其功能 3、递归程序注意调用的过程，防止栈溢出

2. 程序分析 2.1 存储结构 [内容要求] 存储结构：双链表 2.2 关键算法分析 [内容要求] 定义类： template class LinkList { public: LinkList(){front = new Node ;front->next=rear;front->prior=NULL;rear=new Node;rear->next=NULL;rear->prior=front;} LinkList(T a[],int n); void BackLinkList(T a[]);//恢复原链表 ~LinkList();//析构函数 void PrintList();//打印数列 void InsertSort();//插入排序 void BubbleSort();//冒泡排序 Node * Partion(Node *i,Node *j);//快速排序中寻找轴值的函数 void Qsort(Node *i,Node *j);//快速排序 void SelectSort();//选择排序 Node*front; Node*rear; }; 成员函数包括：构造函数：单链表，打印单链表，插入排序，快速排序，冒泡排序，选择排序，析构函数公有成员：头指针和尾指针 1、构造函数： LinkList::LinkList(T a[],int n) { front=new Node; rear=new Node; front->prior=NULL;front->next=rear; rear->next=NULL;rear->prior=front; Node *s; for (int i=n-1;i>=0;i--) {

《数据结构与算法分析》课程设计：顺序表、单链表、顺序栈、查找、排序算法

*******大学《数据结构与算法分析》课程设计题目：数据结构上机试题学生姓名：学号：专业：信息管理与信息系统班级：指导教师： 2014年04月

目录一、顺序表的操作 (2) 【插入操作原理】 (2) 【删除操作原理】 (2) 【NO.1代码】 (3) 【运行截图演示】 (7) 二、单链表的操作 (10) 【创建操作原理】 (10) 【插入操作原理】 (10) 【删除操作原理】 (10) 【NO.2代码】 (11) 【运行截图演示】 (20) 三、顺序栈的操作 (25) 【数值转换原理】 (25) 【NO.3代码】 (26) 【运行截图演示】 (30) 四、查找算法 (32) 【顺序查找原理】 (32) 【折半查找原理】 (32) 【NO.4代码】 (33) 【运行截图演示】 (38) 五、排序算法 (40) 【直接插入排序原理】 (40) 【快速排序原理】 (40) 【NO.5代码】 (41) 【运行截图演示】 (46)

一、顺序表的操作（1）插入元素操作：将新元素x 插入到顺序表a 中第i 个位置；（2）删除元素操作：删除顺序表a 中第i 个元素。【插入操作原理】线性表的插入操作是指在线性表的第i-1个数据元素和第i 个数据元素之间插入一个新的数据元素，就是要是长度为n 的线性表： ()11,,,,,i i n a a a a -………… 变成长度为n+1的线性表： ()11,,,,,,i i n a a b a a -………… 数据元素1i a -和i a 之间的逻辑关系发生了变化。（其【插入原理】在课本P23的算法2.3有解释）【删除操作原理】反之，线性表的删除操作是使长度为n 的线性表： ()111,,,,,,i i i n a a a a a -+………… 变成长度为n-1的线性表： ()111,,,,,i i n a a a a -+………… 数据元素1i a -、i a 和1i a +之间的逻辑关系发生变化，为了在存储结构上放映这个变化，同样需要移动元素。（其【删除原理】在课本P24的算法2.4有解释）

冒泡排序算法和递归算法

实验一、冒泡排序算法和递归算法一、实验目的与要求 1.熟悉C/C++语言的集成开发环境； 2.通过本实验加深对冒泡排序算法和递归过程的理解。二、实验内容：掌握冒泡排序算法和递归算法的概念和基本思想，分析并掌握“汉诺塔”问题的递归算法。三、实验题 1、分析并写出冒泡排序算法，输入数列{43，1，23，100，90，9，19，17}，写出程序运行结果。算法如下： BUBBLE SORT (A) 1 for i ←1 to length ［A ］ 2 do for j ←length ［A ］downto i + 1 3 do if A ［j ］< A ［j -1］ 4 then exchange A ［j ］A ［j -1］ C 程序如下： #include void main() { int a[8]; int i,j,t; printf("Please input 8 number:\n"); for(i=0;i<8;i++) scanf("%d",&a[i]); printf("\n"); for(i=0;i<7;i++) for(j=0;j<7-i;j++) if(a[j]>a[j+1]) { t=a[j]; a[j]=a[j+1]; a[j+1]=t; } printf("\nThe number are:\n"); for(i=0;i<8;i++) printf("%5d",a[i]); } 程序运行结果如下：

2、写出汉诺塔问题的递归算法程序。写出n=3和n=4时，圆盘的移动总次数和每步移动过程。规模为n的算法如下： HANOI(n，X，Y，Z) 1 if n=1 2 then MOVE(X，1，Z) 3 else HANOI(n-1，X，Z，Y) 4 MOVE(X，n，Z) 5 HANOI(n-1，Y，X，Z) 实现算法程序如下： #include #include #include using namespace std; int count=0; void move(int n,char a,char b); void hanoi(int n, char a,char b, char c); int main() { int number; char a,b,c; a='A'; b='B'; c='C'; SYSTEMTIME sys1,sys2;

c++数据结构实验链表排序

1．实验要求 i.实验目的: 通过编程，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。理解算法的主要思想及流程。 ii.实验内容：使用链表实现下面各种排序算法，并进行比较。排序算法： 1、插入排序 2、冒泡排序（改进型冒泡排序） 3、快速排序 4、简单选择排序 5、堆排序（小根堆）要求： 1、测试数据分成三类：正序、逆序、随机数据 2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。 3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作） 4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性 iii.代码要求： 1、必须要有异常处理，比如删除空链表时需要抛出异常；

2、保持良好的编程的风格：代码段与段之间要有空行和缩近标识符名称应该与其代表的意义一致函数名之前应该添加注释说明该函数的功能关键代码应说明其功能 3、递归程序注意调用的过程，防止栈溢出 2. 程序分析通过排序算法将单链表中的数据进行由小至大（正向排序） 2.1 存储结构单链表存储数据： struct node { i nt data; n ode *next; }; 单链表定义如下： class LinkList { private : n ode * front; public : L inkList(int a[], int n); //构造 ~LinkList(); v oid insert(node *p, node *s); //插入 ……

双向链表上的插入和删除算法

编写程序，演示在双向链表上的插入和删除算法。问题分析：1、在双向链表上操作首先要生成一个双向链表： 1>节点定义struct DuLNode{ ElemType data; DuLNode *prior; DuLNode *next; }; 2.> 创建双列表 L=(DuLinkList)malloc(sizeof(DuLNode)); L->next=L->prior=L; 3>输入链表数据； 2、 3、对向链表进行插入操作算法：在节点p的前面加入一个新的节点q： q=(DuLinkList)malloc(sizeof(DuLNode)); q->data=e; q->prior=p->prior; q->next=p; p->prior->next=q; p->prior=q; 4、对双向链表进行删除操作算法删除给定节点p 得到的代码如下： #include #include #define OK 1 #define ERROR 0 using namespace std; typedef int ElemType; typedef int status; struct DuLNode { ElemType data; DuLNode *prior;

DuLNode *next; }; typedef DuLNode *DuLinkList; status DuListInsert_L(DuLinkList L,int i , ElemType e)//插入函数 { DuLinkList p=L; //定义两个指向头节点的指针 DuLinkList q=L; int j=0; while(p->next!=L&&jnext; j++; } if(p->next==L||jdata=e; q->prior=p->prior; q->next=p; p->prior->next=q; p->prior=q; return OK; } status DuListDelete_L(DuLinkList L,int i , ElemType &e)//删除 { DuLinkList p=L; int j=0; while(p->next!=L&&jnext;j++; } if(p->next==L||jprior->next=p->next; p->next->prior=p->prior;

汇编语言实现冒泡排序(一)

;用汇编语言实现实现冒泡排序，并将排序后的数输出 DATAS SEGMENT A dw 100,344,3435,43433,3438,343,134,80,8,1000,65535,54,45 N=$-A ;计算数字所占的字节数 DATAS ENDS CODES SEGMENT ASSUME CS:CODES,DS:DATAS START:MOV AX,DATAS MOV DS,AX MOV SI,0 ;SI遍历数字;前一个数的地址 MOV CX,N/2-1 ;设置循环次数，M(M=N/2)个数需要，循环M-1次 CALL BUBBLE ;调用BUBBLE将原来的数排序 ;输出排序后的数 MOV CX,N/2 ;循环M次输出排序后的M个数 MOV SI,0 ;SI遍历排序后的数 MOV DI,0 ;用DI记录数字的位数 MOV BP,N+5 ;BP用于遍历存储的转化后的字符的位置 SHOW: PUSH CX ;循环次数入栈 MOV DX,0 ;由于将要进行16位除需要置高16位为0 MOV AX,[SI] ;低16位为排序后的数 CALL DTOC ;调用DTOC将十进制数转换为字符串 CALL SHOW_STR ;调用SHOW_STR将一个数转化得到的字符串输出ADD SI,2 ;下一个数 POP CX ;循环次数出栈栈 LOOP SHOW MOV AH,4CH INT 21H ;冒泡排序 BUBBLE PROC L1: PUSH CX ;将循环次数入栈 LEA SI,A ;SI遍历DATAS数据段的数字 L2: MOV AX,A[SI] ;将前一个数存于AX CMP AX,A[SI+2] ;比较前后两个数 JBE NEXT ;如果前一个数小于或等于后一个数则继续本轮的比较XCHG AX,A[SI+2] ;否则，交换前后两个数的位置 MOV A[SI],AX NEXT:ADD SI,2 ;下一个数 LOOP L2 ;注意内层循环的次数已经确定了 POP CX ;将循环次数出栈 LOOP L1 ;下一轮比较 RET BUBBLE ENDP