C#实现单链表排序

C#实现单链表排序
C#实现单链表排序

首先写一个单链表的C#实现:

public class Link

{

public Link Next;

public string Data;

public Link(Link next, string data)

{

this.Next = next;

this.Data = data;

}

}

无外乎是冒泡、选择、插入等排序方法。关键是交换算法,需要额外考虑,此处选择了插入排序算法,如下所示:

public static Link SortLink(Link head)

{

Link pre1 = head;

Link pre2 = head.Next;

Link min = null;

for (Link curr1 = head.Next; curr1 != null; curr1 = min.Next)

{

if (curr1.Next == null)

break;

min = curr1;

for (Link curr2 = curr1.Next; curr2 != null; curr2 = curr2.Next)

{

//swap curr1 and curr2

if (curr2.Data < curr1.Data)

{

min = curr2;

curr2 = curr1;

curr1 = min;

pre1.Next = curr1;

curr2.Next = curr1.Next;

curr1.Next = pre2;

//if exchange element n-1 and n, no need to add reference from pre2 to curr2, because they are the same one

if (pre2 != curr2)

pre2.Next = curr2;

}

pre2 = curr2;

}

pre1 = min;

pre2 = min.Next;

}

return head;

}

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

数据结构实验报告 实验名称:实验三——排序 学生姓名: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-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. {

最新C语言链表排序

========================== 功能:选择排序(由小到大) 返回:指向链表表头的指针 ========================== */ /* 选择排序的基本思想就是反复从还未排好序的那些节点中, 选出键值(就是用它排序的字段,我们取学号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; /*保存键值更小的节点。*/ } }

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

*******大学 《数据结构与算法分析》课程设计 题目:数据结构上机试题 学生姓名: 学号: 专业:信息管理与信息系统 班级: 指导教师: 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有解释)

c++单向链表的排序

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

《软件设计基础-C++》课程设计报告

2
页,共
16 页


1.课程设计目的···································· ···································· ···································· 2.课程设计任务与要求 ································ ································ ······························· 3.课程设计说明书··································· ··································· ·································· 4.课程设计成果···································· ···································· ···································· 5.程序调试过程···································· ···································· ···································· 6.设计问题的不足和改进方案 ···························· ···························· ··························· 7.课程设计心得···································· ···································· ···································· 8.参考文献······································· ······································· ······································

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

数据结构实验报告 实验名称:实验四——链表的排序 学生姓名: 班级: 班内序号: 学号: 日期: 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--) {

学生信息系统 链表 排序 学生系统 数据结构C程序

内蒙古工业大学信息工程学院实验报告 课程名称:数据结构(C语言版) 实验名称:线性表的创建与访问算法设计 实验类型:验证性□ 综合性□ 设计性□ 实验室名 班级:学号: 姓名:组别: 同组人:成绩: 实验日期: 2011年5月16日

预习报告成绩:指导教师审核(签名): 2011年 5月16日 预习报告 (一)实验目的 数据结构于算法实验是计算机类本科学生计算机软件知识重要的实验环节,它将使学生从实践上学会用高级语言程序设计、实现复杂的数据结构,为大型软件设计奠定基础。本实验以某种线性表的创建与访问算法设计作为实验内容,举一反三,全面、深刻掌握线性结构的实现方法,培养解决问题的能力。 (二)实验内容 1、编写生成线性表的函数,线性表的元素从键盘输入; 2、编写在线性表中插入元素的函数; 3、编写在线性表中删除元素的函数; 4、编写输出线性表的函数; 5、编写主函数,调用以上各函数,以便能观察出原线性表以及作了插入或删除后线性表的屏幕输出。 (三)实验要求 1、掌握线性结构的机器内表示; 2、掌握线性结构之上的算法设计与实现; 3、列表对比分析两种数据结构的相应操作的时间复杂度、空间复杂度,阐明产生差异的原因。 (四)问题描述 有一班学生上体育课排队,构成了一个单链表,链表的结点存储了学生的学号、姓名。

(五)基本要求 (1)从键盘输入学生的信息,建立学生链表。 (2)从键盘输入学生的信息,实现学生查询操作。 (3)从键盘输入学生的学号值,将学号为x的学生与其右边的学生进行交换。(注:不允许将链表中数据域的值进行交换) (六)实验设计思路 实验实现9个功能,先在主函数m a i n()设计声明每个函数,然后依次对每个函数细化,逐步调试,直到达到该函数的预期功能,即采用自顶向下,逐步细化的设计思路。该实验全部采用单链表,设计一个学生信息系统,通过该系统一次可以完成:1.创建学生系统 2.学生系统排序 3.删除学生信息 4.增加学生信息 5.查找学生信息 6.清除学生信息7.修改学生信息8.模式查找信息9.退出学生系统等功能。

单链表实现冒泡排序

1.#include 2. 3.struct Node; 4. 5.typedef struct Node *PtrToNode; 6.typedef PtrToNode List; 7.typedef PtrToNode Position; 8.typedef int ElementType; 9. 10.struct Node 11.{ 12. ElementType Element; 13. Position Next; 14.}; 15. 16.List initList() 17.{ 18. List L = (List)malloc(sizeof(struct Node)); 19. L->Next = NULL; 20. return L; 21.} 22. 23.void insertElement(List L) 24.{ 25.int element; 26. while(scanf("%d", &element)) 27. { 28. Position tmp = (Position)malloc(sizeof(struct Node)); 29. tmp->Element = element; 30. tmp->Next = L->Next; 31. L->Next = tmp; 32. } 33.} 34. 35.void printList(List L)

36.{ 37. Position P = L->Next; 38. printf("L->"); 39. while(P != NULL) 40. { 41. printf("%d - >", P->Element); 42. P = P->Next; 43. } 44. printf("NULL\n"); 45.} 46. 47.int get_length(List L) 48.{ 49.int i = 0; 50. Position P = L->Next; 51. while(P != NULL) 52. { 53. i++; 54. P = P->Next; 55. } 56. return i; 57.} 58. 59.void BubblePoint(List L) 60.{ 61. Position pre; 62. Position cur; 63. Position next; 64. 65.int i, j; 66. i = get_length(L); 67. printf("length = %d\n", i); 68. 69. while(i != 1) 70. {

单链表排序

#include using namespace std; struct Cnode { int data; Cnode *next; }; Cnode *creat(Cnode *head) { Cnode *pnew,*pcur; pcur=head; head->next=NULL; pnew=new Cnode; cout<<"请输入你的元素:"; cin>>pnew->data; pcur->next=pnew; pcur=pnew; while(pnew->data!=0) { pnew=new Cnode; cin>>pnew->data; pcur->next=pnew; pcur=pnew; } pcur->next=NULL;

return head; } Cnode *order(Cnode *head) { Cnode *p,*q; int big; p=head->next; q=p->next; while(q!=NULL) { if(p->datadata) { big=p->data; p->data=q->data; q->data=big; } q=q->next; if(q=NULL) { p=p->next; q=p->next; } } return head; } void show(Cnode *head)

{ Cnode *ph; ph=head->next; while(ph!=NULL) { cout<data<<","; ph=ph->next; } } void main() { Cnode *head,*op,*ip; head=new Cnode; head->next=NULL; op=creat(head); ip=order(op); show(ip); }

链表实现排序算法

数据结构 实 验 报 告 实验名称:实验三排序 学生姓名: 班级: 班内序号:15 学号: 日期:2016.12.19

1.实验要求 题目2 使用链表实现下面各种排序算法,并进行比较。 排序算法: 1、插入排序 2、冒泡排序 3、快速排序 4、简单选择排序 5、其他 要求: 1、测试数据分成三类:正序、逆序、随机数据 2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动 次数(其中关键字交换计为3次移动)。 3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精 确到微秒(选作) 4、对2和3的结果进行分析,验证上述各种算法的时间复杂度 编写测试main()函数测试线性表的正确性 2. 程序分析 2.1 存储结构 我使用了线性表的链式存储结构,通过建立双向循环链表进行顺序存取。每个节点分为data、next、previor。data域称为数据域,数据通过node结构存储待排序的信息;next为指针域,用来储存直接后继的地址;prior为指针域,用来储存直接前继的地址; struct Node { int data; struct Node*next; struct Node*previor; };

2.2 程序流程(或程序结构、或类关系图等表明程序构成的内容,一般为流程 { private: Node* partion(Node*first,Node*end); //快速排序一趟 public: Node*front; int comparision; //比较次数 int movement; //移动次数 LinkList() //无参构造 { front = new Node; front->next = NULL; front->previor = NULL; comparision = movement = 0; } LinkList(int a[],int n); //构造函数:建立双向链表

基于链表的排序与查找

基于链表的排序与查找 摘要:链表是程序设计中的一种重要的动态数据结构,它是动态地进行存储分配的一种结构。链表即采用链式存储结构的线性表。对线性表,我们主要对其的操作有:建立,插入,删除,查找,排序等。此次实践主要是针对于链表的排序和查找进行。 关键字:链表排序查找 1引言 排序是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个按关键字有序的序列,以便于进行数据的查询。而基于链表的查找是采用的动态查找表,是求出一个数据元素在序列中的索引或指针,将其返回。 2需求分析 (1)建立链表; (2)基于链表的排序算法实现; (3)基于链表的查找算法实现。 3数据结构 3.1建立链表 3.1.1节点定义 typedef struct node//定义节点 { int data; struct node *next; }lnode, *linklist; 3.1.2链表尾部插入 void insertlist(linklist l,int i)//链表尾部插入 { linklist p,s;

s=(linklist)malloc(sizeof(lnode)); s->data=i; s->next=NULL; p->next=s; } 此时,相应的主函数中应该有存储代码,才能完成数据的链式存储。 int i,n,f,a[100]; h=(lnode)malloc(sizeof(lnode)); lnode *r,*p,*s; h->data=0; h->next =NULL; r=h; printf("请输入数据的数目:"); scanf("%d",&n); for(i=0;inext ; } h=r; h为头指针,将h赋给r,r记录h初始指向地址,在存完数据后,再将r赋给h。4算法设计 4.1排序算法的设计 4.1.1排序的定义 假设含n个记录的序列为

链表的选择排序

排序采用选择法: 把30 接到80后面 45接到90后面 90替原来45的位置 *************************** 预备知识: NODE *v,*u,*p,*h; U,v,h,p都是指针,它们只是地址性的可以指向结构 而链表中的表 有next指针 **************************************** 链表排序 h 45 65 54 80 90 30 要实现45和90 的交换: 30要接到80后面 45要接到90后面 90要接到h后面

90 45 65 54 80 30 要实现45和80 的交换: 30 接到54后面 45接到80后面 80要接到90后面。即插入到90后面 所以一般情况需要用: 两个指针vold v 指出45 两个指针mold max 指出最大 这样可以方便的实现v 或max,移走或被替换时,其它的可以接上。 但如果要被替换的是第一个,如45被90替换。 h,vold,v max 45 65 54 80 90 30 Max指向90,30 放到80后面, h,vold,v max 45 65 54 80 30 90 45 放到90后面,h,v,vold都跟着45移动, max h,vold,v 90 45 65 54 80 30 h=max 还要一个游动指针,u,用于不断和v比较 为了继续进行,下一轮开始前应该为:

h ,vold v,max u 90 45 65 54 80 30 vold要指向90, v指向45, u指向54 所以对于第一次交换后还要移动vold if(vold==v) 时,vold=h; 总之一个比较可行的程序为: while (v->next != NULL) //省去空的v,//选择法{ for(max=v,uold= u = v->next; u->next != NULL; uold=u, u = u->next) { if (u->score > max->score ) { mold=uold; max = u; } //找到最大的 } //u已移动,但队列未动 // u->next == NULL即u是最后一个表,跳出循环, // 还要判别u指向的表是最大吗? if(u->score>max->score) {mold =uold; max=u;} //最后一个 if (max!= v) { mv->next= max->next; max->next =v; if(vold==v) { h=max; } else { vold->next=max; }

单链表排序

单链表排序 #include using namespace std; struct Cnode { int data; Cnode *next; }; Cnode *creat(Cnode *head) { Cnode *pnew,*pcur; pcur=head; head->next=NULL; pnew=new Cnode; cout<<"请输入你的元素:"; cin>>pnew->data; pcur->next=pnew; pcur=pnew; while(pnew->data!=0) { pnew=new Cnode; cin>>pnew->data; pcur->next=pnew; pcur=pnew; } pcur->next=NULL; return head; } Cnode *order(Cnode *head)

Cnode *p,*q; int big; p=head->next; q=p->next; while(q!=NULL) { if(p->datadata) { big=p->data; p->data=q->data; q->data=big; } q=q->next; if(q=NULL) { p=p->next; q=p->next; } } return head; } void show(Cnode *head) { Cnode *ph; ph=head->next; while(ph!=NULL) { cout<data<<","; ph=ph->next;

} void main() { Cnode *head,*op,*ip; head=new Cnode; head->next=NULL; op=creat(head); ip=order(op); show(ip); }

C#实现单链表排序

首先写一个单链表的C#实现: public class Link { public Link Next; public string Data; public Link(Link next, string data) { this.Next = next; this.Data = data; } } 无外乎是冒泡、选择、插入等排序方法。关键是交换算法,需要额外考虑,此处选择了插入排序算法,如下所示: public static Link SortLink(Link head) { Link pre1 = head; Link pre2 = head.Next; Link min = null; for (Link curr1 = head.Next; curr1 != null; curr1 = min.Next)

{ if (curr1.Next == null) break; min = curr1; for (Link curr2 = curr1.Next; curr2 != null; curr2 = curr2.Next) { //swap curr1 and curr2 if (curr2.Data < curr1.Data) { min = curr2; curr2 = curr1; curr1 = min; pre1.Next = curr1; curr2.Next = curr1.Next; curr1.Next = pre2; //if exchange element n-1 and n, no need to add reference from pre2 to curr2, because they are the same one if (pre2 != curr2) pre2.Next = curr2; } pre2 = curr2; }

c++单向链表的排序

c++单向链表的排序

河北联合大学 2011-2012第2学期 《软件设计基础-C++》 课程设计报告 设计名称:设计一个处理单向链表的程序:链表的排序 姓名:王学增学号:201005100206 专业班级:土木工程1班 学院:建筑工程学院 设计时间:2012-5-31 设计地点:机房

指导教师评语: 教师评定:自评成绩;75 指导教师签字: 年月日 年月日

目录 1.课程设计目的 ··············································································· 2.课程设计任务与要求 ······································································ 3.课程设计说明书 ············································································ 4.课程设计成果 ··············································································· 5.程序调试过程 ··············································································· 6.设计问题的不足和改进方案 ····························································· 7.课程设计心得 ··············································································· 8.参考文献 ·····················································································

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 { ……

int data; node*next; }; 单链表定义如下: class LinkList { private: node * front; public: LinkList(int a[], int n); //构造 ~LinkList(); void insert(node*p, node*s); //插入 void turn(node*p, node*s); //交换数据 void print(); //输出 void InsertSort(); //插入排序 void BubbleSort(); //pos冒泡 void QSort(); //快速排序 void SelectSort(); //简单选择排序 node* Get(int i); //查找位置为i的结点 void sift(int k, int m); //一趟堆排序 void LinkList::QSZ(node * b, node *e); //快速排序的递归主体 void heapsort(int n); //堆排序算法 }; 2.2关键算法分析: 1、直接插入排序:首先将待排序数据建立一个带头结点的单链表。将单链表划分为有序区与无序区,有序区只包含一个元素节点,依次取无序区中的每一个结点,在有序区中查找待插入结点的插入位置,然后把该结点从单链表中删除,再插入到相应位置。 分析上述排序过程,需设一个工作指针p->next在无序区中指向待插入的结点,在找到插入位置后,将结点p->next插在结点s与p之间。 void LinkList::InsertSort() //将第一个元素定为初始有序区元素,由第二个元素开始依次比较 { LARGE_INTEGER t1, t2, feq; QueryPerformanceFrequency(&feq); //每秒跳动次数 QueryPerformanceCounter(&t1); //测前跳动次数 node * p = front->next; //要插入的节点的前驱 while (p->next) { node * s = front; //充分利用带头结点的单链表 while (1) { comparef++;

数据结构_链表排序(1)

https://www.360docs.net/doc/a18819208.html,/archives/490 1.编写实现链表排序的一种算法。说明为什么你会选择用这样的方法? 1.1 字符串A/B,找出共同包含的最长子串 #include #include void max_same_substr( char a[], char b[], char substr[], int *max ) { int i; char *ptr; char tmp[ 20 ] = { 0 }; for ( i = 0; *a != '\0'; ++i ) { strncat( tmp, a++, 1 ); // add each char to the end of the tmp ptr = strstr( b, tmp ); if ( ptr != NULL ) { if ( strlen(tmp) > *max ) { strcpy( substr, tmp );

*max = strlen( tmp ); } } else { break; } } if ( *a != '\0' ) max_same_substr( a, b, substr, max ); } 2.编写实现数组排序的一种算法。说明为什么你会选择用这样的方法? 1)希尔排序 希尔排序基本思想:先取一个小于n的整数d1作为第一个增量,把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插入排序;然后,取第二个增量d2

数据结构--单链表排序及通用排序模板

数据结构——单链表排序 昨天晚上写了个单链表排序功能的函数,没想到数据结构课只是过了一学期,写单链表数据结构的函数就遇到太多问题。唉,老师,我对不起你啊。 我所要写的函数的程序是以单链表结构进行组织,无空头节点。 要求可以按节点里的某个属性作为key大小排序。 最开始,我并没回想到这个单链表交换位置,需要以指针进行移动。事实上,潜意识认为,只要将指针的值进行交换,即可(完全忘了单链表的知识了)。因为很自然的想成,链表是通过指针进行寻找节点的,交换了指针,就相当于交换节点顺序。貌似没有问题,所以我编写了如下函数(为了卖弄下,我还挑了个麻烦的快速排序方法,而不是后来简单的冒泡排序): void QuickSort(struct book *head_book,int low,int high) { static int count=1; int i=low,j=high; struct book *temp_ptr_book,*iptr_book,*jptr_book; temp_ptr_book=GetPtr_book(head_book,low); iptr_book=GetPtr_book(head_book,i); jptr_book=GetPtr_book(head_book,j); if(i=GetKey(jptr_book)) {jptr_book=GetPtr_book(head_book,j);j--} if(i

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

1.实验要求 i.实验目的: 通过编程,学习、实现、对比各种排序算法,掌握各种排序算法的优劣,以及各种 算法使用的情况。 理解算法的主要思想及流程。 ii.实验内容: 使用链表实现下面各种排序算法,并进行比较。 排序算法: 1、插入排序 2、冒泡排序(改进型冒泡排序) 3、快速排序 、 4、简单选择排序 5、堆排序(小根堆) 要求: 1、测试数据分成三类:正序、逆序、随机数据 2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关 键字交换计为3次移动)。 3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选 作) 4、对2和3的结果进行分析,验证上述各种算法的时间复杂度 编写测试main()函数测试线性表的正确性 iii.代码要求: — 1、必须要有异常处理,比如删除空链表时需要抛出异常; 2、保持良好的编程的风格: 代码段与段之间要有空行和缩近 标识符名称应该与其代表的意义一致 函数名之前应该添加注释说明该函数的功能 关键代码应说明其功能 3、递归程序注意调用的过程,防止栈溢出 2. 程序分析 通过排序算法将单链表中的数据进行由小至大(正向排序) 存储结构 -

单链表存储数据: struct node { int data; node *next; }; 单链表定义如下: class LinkList # { private : node * front; public : LinkList(int a[], int n); 接插入排序:首先将待排序数据建立一个带头结点的单链表。将单链表划分为有序区和无序区,有序区只包含一个元素节点,依次取无序区中的每一个结点,在有序区中查找待插入结点的插入位置,然后把该结点从单链表中删除,再插入到相应位置。 分析上述排序过程,需设一个工作指针p->next 在无序区中指向待插入的结点,在找到插入位置后,将结点p->next 插在结点s 和p 之间。 void LinkList ::InsertSort() 速排序: 主要通过轴值将数据从两端向中间进行比较,交换以实现排序。 通过递归的调用来实现整个链表数据的排序。 ¥ 代码中选用了第一个元素作为轴值。 一趟排序的代码: void LinkList ::QSZ(node * b , node *e ) { if (b ->next == e || b == e ) 进版的冒泡排序: 通过设置pos 来记录无序边界的位置以减少比较次数。 将数据从前向后两两比较,遇到顺序不对是直接交换两数据的值。 每交换一次movef+3; void LinkList ::BubbleSort() { 】 LARGE_INTEGER t1, t2, feq; QueryPerformanceFrequency(&feq); 择排序: 每趟排序再待排序的序列中选择关键码最小的元素,顺序添加至已排好的有序序列最后,知道全部记录排序完毕。 void LinkList ::SelectSort() { ……

相关主题
相关文档
最新文档