链表的合并 实验报告材料
有序链表的合并实验总结
有序链表的合并实验总结有序链表的合并是计算机科学中常见的操作之一,它在许多算法和数据结构中都有广泛的应用。
本文将对有序链表的合并进行实验总结,并探讨其应用和实现方法。
我们需要了解什么是有序链表。
有序链表是一种数据结构,它按照某种规则将元素按顺序排列在链表中。
在有序链表中,每个节点都包含一个值和一个指向下一个节点的指针。
这种数据结构的优点是插入和删除操作相对容易,但查找操作的效率较低。
因此,在某些场景下,有序链表比其他数据结构更适合。
有序链表的合并就是将两个有序链表合并成一个新的有序链表。
合并的过程是将两个链表中的节点逐个比较,并按照大小顺序插入到新链表中。
具体步骤如下:1. 创建一个新链表和两个指针,分别指向两个待合并的链表的头节点。
2. 比较两个指针所指节点的值的大小,将较小的节点插入到新链表中,并将指针向后移动一位。
3. 重复步骤2,直到有一个链表的指针为空。
4. 将另一个链表剩余的节点直接插入到新链表的末尾。
在实验过程中,我们可以编写一个简单的函数来实现有序链表的合并。
以下是一个示例代码:```pythonclass ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef mergeTwoLists(l1, l2):dummy = ListNode(0) # 创建一个虚拟节点作为新链表的头节点curr = dummy # 创建一个指针指向新链表的当前位置while l1 and l2:if l1.val < l2.val:curr.next = l1l1 = l1.nextelse:curr.next = l2l2 = l2.nextcurr = curr.next# 将剩余的节点直接插入到新链表的末尾if l1:curr.next = l1if l2:curr.next = l2return dummy.next # 返回新链表的头节点```通过上述代码,我们可以在O(n)的时间复杂度内完成两个有序链表的合并,其中n为两个链表的总长度。
数据结构实验报告之链表(终极版本)
五、 用户使用说明
1、 本程序的运行环境为 Microsofe VC++ 6.0,执行文件为:***.c。 2、 进入界面后只需汇编、建立、执行即可得出结果。
六、测试结果: 1:70 3:75 2:85 4:90 ********************** ********************** ********************** ********************** 8:50 5:60 7:76 6:80 ********************** ********************** ********************** ********************** 8:50 5:60 1:70 3:75 7:76 6:80 2:85 4:90 ********************** ********************** ********************** ********************** ********************** ********************** ********************** ********************** Press any key to continue
} a=a->next; } }
4. 编写函数实现链表 a 和链表 b 的合并:
list *merge(list *a,list *b)
{
list *rt=NULL,*n=NULL,*now=NULL; while (a&&b) { n=(list *)malloc(sizeof(node)); n->next=NULL; if (a->score<=b->score) { n->id=a->id; n->score=a->score; a=a->next; } else { n->id=b->id; n->score=b->score; b=b->next ; } if (!rt) { rt=now=n; } else{ now->next=n; now=n; } } while (a) { n=(list *)malloc(sizeof(node)); n->next=NULL; n->id=a->id; n->score=a->score; now->next=n; now=n; a=a->next ; } while (b) { n=(list *)malloc(sizeof(node));
数据结构课程设计-两个链表合并-星
数据结构课程设计-两个链表合并-星两个链表的合并1.课程设计目的实现对两个的链表的交叉合并,输出线形表C用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
掌握对线性表的链式表示和实现,实现插入的操作。
了解链表交叉合并的方法和直接插入排序法的思想,并深刻掌握算法的格式和应用。
提高对数据结构的理解和应用,增强个人动手实践能力和逻辑分析能力。
2.设计方案论证2.1设计思路本课程设计将对链表的交叉合并和直接插入排序的实现。
首先将两个链表进行交叉合并,合并的要求如下:建立两个链表A和B,链表元素个数分别为m和n个。
假设元素分别为(x1,x2,…xm),和(y1,y2, …yn)。
把它们合并成一个线形表C,使得:当m>=n时,C=x1,y1,x2,y2,...xn,yn, (x)当n>m时,C=y1,x1,y2,x2,…ym,xm,…,yn输出线形表C。
对合并的链表C进行直接插入排序,输出链表D。
此次课程设计实验的数据位①A表(30,41,15,12,56,80)B表(23,56,78,23,12,33,79,90,55)②A表(30,41,15,12,56,80,23,12,34)B表(23,56,78,23,12)2.1.1链表链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。
每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。
通常我们把链表画成用箭头相连接的结点沈阳大学的序列,节点之间的箭头表示指针。
在c语言中,链表用结构指针来描述。
相比于线性表顺序结构,链表比较方便插入和删除操作。
(1)线性表的单链表存储结构ypedef struct Node{ElemType data;struct Node *next;} Node;typedef struct Node *Linklist;(2)实现两个链表的简单合并算法如下:Void Mergelist_L(Linklist &La,Linklist &Lb,Linklist &Lc){//已知单线性链表La和Lb的元素按值非递减排列。
实现两个链表的合并 课程设计报告
目录一需求分析 (1)二概要设计 (2)三详细设计 (3)四调试分析与测试结果 (5)五总结 (6)六参考文献 (7)七致谢 (8)八附录 (9)一需求分析题目:实现两个链表的合并问题描述:(1)建立两个链表A和B,链表元素个数分别为m和n个。
(2)假设元素分别为(x1,x2,…xm),和(y1,y2, …yn)。
把它们合并成一个线形表C,使得:当m>=n时,C=x1,y1,x2,y2,...xn,yn, (x)当n>m时,C=y1,x1,y2,x2,…ym,xm,…,yn输出线形表C(5)用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
测试数据:(1) A表(30,41,15,12,56,80)B表(23,56,78,23,12,33,79,90,55)(2) A表(30,41,15,12,56,80,23,12,34)B表(23,56,78,23,12)由题目的相关信息可以分析得:首先我们需要建立两个链表AB,A链表的元素个数为m,B链表的元素个数为n;在将A、B链表进行合并,根据m和n的大小关系决定链表C的元素顺序;再将C进行直接插入排序得到一个新的链表D;最后输出四个链表ABCD的相关信息。
本次课程设计所需要用到的是关于链表的建立、合并以及直接插入排序的排序算法。
需要先建立两个链表,再将其合并为一个无序链表,最后对这个无序链表进行直接插入排序并将其输出。
难点在于将AB合并为链表C的操作以及对链表C进行直接插入排序的操作。
图1.链表合并的流程图我所负责的直接插入排序的代码编写以及主函数的编写。
直接插入排序的定义如下:把n个待排序的元素看成一个有序表和一个无序表,开始时有序表中只包含一个元素,无序表中包含n-1个元素,排序过程中每次从无序表中取出第一个元素,把他的排序吗一次与有序表元素的排序码进行比较,将它插入到有序表中的适当位置,使之成为新的有序表;主函数的编写则是调用AB链表初始化函数,再调用合并AB链表函数,再调用直接插入排序函数,最后依次输出ABCD四个链表的相关信息。
链表的合并实验报告
链表的合并实验报告文稿归稿存档编号:[KKUY-KKIO69-OTM243-OLUI129-G00I-FDQS58-课程设计报告课程设计题目:两个链表的合并专业:软件工程班级:姓名:学号:指导教师:年月日目录1.课程设计的目的及要求2.课程设计的内容(分析和设计)3.算法流程图4.详细步骤5.代码6.显示结果7.课程设计的总结一.课程设计的目的及要求1.目的:实现两个链表的合并2.要求:(1)建立两个链表A和B,链表元素个数分别为m和n个。
(2)假设元素分别为(x1,x2,…xm),和(y1,y2,?…yn)。
把它们合并成一个线形表C,使得:当m>=n时,C=x1,y1,x2,y2,...xn,yn, (x)当n>m时,C=y1,x1,y2,x2,…ym,xm,…,yn输出线形表C(3)用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
(4)能删除指定单链表中指定位子和指定值的元素。
二.课程设计的内容(分析和设计)1..分析由题目的相关信息可以分析得:首先我们需要建立两个链表AB,A链表的元素个数为m,B链表的元素个数为n;在将A、B链表进行合并,根据m和n的大小关系决定链表C的元素顺序;再将C进行直接插入排序得到一个新的链表D;没次输入完一次链表信息,程序都会对相应的链表进行输入操作以此确保程序输入的数据是你想要输入的数据。
同时当你合并好和排序好后都会进行输出操作。
最后当排序好后你可以指定你所要删除数据的位置来删除你所要删除的数据。
2.设计本次课程设计所需要用到的是关于链表的建立、合并以及直接插入排序的排序算法。
需要先建立两个链表,再将其合并为一个无序链表,最后对这个无序链表进行直接插入排序并将其输出。
难点在于将AB合并为链表C的操作以及对链表C进行直接插入排序的操作和根据用户的意愿可以对链表进行删除的操作。
三.算法流程图四.详细步骤(1)结构体的创建:struct Node(2)链表的创建:struct Node *create()链表的创建。
链表合并实验报告
《数据结构》实验报告◎实验题目: 实现两个有序循环链表的合并◎实验目的:掌握链表的建立、遍历以及数据的插入,加深对链表的理解。
◎实验内容:设A与B分别为两个带有头结点的有序循环链表(所谓有序是指链接点按数据域值大小链接,本题不妨设按数据域值从小到大排列),list1和list2分别为指向两个链表的头指针。
请写出将这两个链表合并为一个带头结点的有序循环链表的算法。
一、需求分析1、输入:该实验需要建立循环链表,以及读入数据,输出数据,并实现合并。
该链表输入为整数形式,输入值的范围为整个整数域。
2、输出:而输出的形式为整数。
3、程序功能:该程序实现了循环链表的建立,读入和输出数据,主要功能为实现了两个有序循环链表的合并。
4、程序执行命令:(1)创建链表(2)输入数据(3)合并链表(4)输出合并后链表(5)结束5、测试数据:假设第一个链表的输入数据个数为5,其分别为1、3、5、7、9,第二个链表的输入数据个数为3个,其分别为7、9、10,则合并后应输出结果:1 3 5 7 7 9 9 10。
二概要设计为了实现上述操作,应以单向循环链表为存储结构。
本程序的主程序的流程为:本程序的调用函数有创建链表函数create,输出函数displist,以及合并函数add三个模块,其中这三个函数都在主函数中被调用,三个调用函数为平行关系。
三详细设计1.元素类型,结点类型和指针类型:typedef int elemtype;typedef struct lnode{elemtype data;struct lnode *next;}linklist;linklist *s,*r;linklist *list1,*list2,*list3; 2.每个模块的分析:(1)主程序模块:main(){linklist *l1,*l2,*l3;int i,x,n;printf("请输入要建立的链表节点个数:\n");scanf("%d",&n);create(l1,n);displist(l1);getch();printf("请输入要建立的链表节点个数:\n");scanf("%d",&n);create(l2,n);displist(l2);getch();add(l1,l2,l3);printf("合并后链表:\n");displist(l3);getch();return 0;}(2)链表创建并输入数据create(linklist *&l,int n){linklist *s,*r;int i;l=(linklist *)malloc(sizeof(linklist));l->next=NULL;r=l;for(i=0;i<n;i++){s=(linklist *)malloc(sizeof(linklist));printf("\n请输入新节点数据:\n");scanf("%d",&s->data) ;r->next=s;r=s;}r->next=l->next;}(3)数据输出displist(linklist *l){linklist *p=l->next;do{printf("%5d",p->data);p=p->next;}while(p!=l->next);printf("\n");}(4)链表合并add(linklist *l1,linklist *l2,linklist *&l3){linklist *list1,*list2,*list3;l3=(linklist *)malloc(sizeof(linklist));l3->next=NULL;list3=l3;list1=l1->next;list2=l2->next;do{if(list1->data<=list2->data){list3->next=list1;list1=list1->next;list3=list3->next;}else{list3->next=list2;list2=list2->next;list3=list3->next;}} while(list3->next!=l1->next&&list3->next!=l2->next);if(list3->next==l2->next)while(list3->next!=l1->next){list3->next=list1;list3=list1;list1=list1->next;}elsewhile(list3->next!=l2->next){list3->next=list2;list3=list2;list2=list2->next;}list3->next=l3->next;}(5)函数调用关系图main()create()displist()add()diaplist()3.完整的程序:(见源文件).四使用说明、测试分析及结果1.程序使用说明:(1)本程序的运行环境为VC6.0。
链表的合并 实验报告(参考资料)
课程设计报告课程设计题目:两个链表的合并专业:软件工程班级:姓名:学号:指导教师:年月日目录1.课程设计的目的及要求2.课程设计的内容(分析和设计)3.算法流程图4.详细步骤5.代码6.显示结果7.课程设计的总结一.课程设计的目的及要求1.目的:实现两个链表的合并2.要求:(1)建立两个链表A和B,链表元素个数分别为m和n个。
(2)假设元素分别为(x1,x2,...xm),和(y1,y2, ...yn)。
把它们合并成一个线形表C,使得:当m>=n时,C=x1,y1,x2,y2,...xn,yn, (x)当n>m时,C=y1,x1,y2,x2,…ym,xm,…,yn输出线形表C(3)用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
(4)能删除指定单链表中指定位子和指定值的元素。
二.课程设计的内容(分析和设计)1..分析由题目的相关信息可以分析得:首先我们需要建立两个链表AB,A链表的元素个数为m,B链表的元素个数为n;在将A、B链表进行合并,根据m和n的大小关系决定链表C的元素顺序;再将C进行直接插入排序得到一个新的链表D;没次输入完一次链表信息,程序都会对相应的链表进行输入操作以此确保程序输入的数据是你想要输入的数据。
同时当你合并好和排序好后都会进行输出操作。
最后当排序好后你可以指定你所要删除数据的位置来删除你所要删除的数据。
2.设计本次课程设计所需要用到的是关于链表的建立、合并以及直接插入排序的排序算法。
需要先建立两个链表,再将其合并为一个无序链表,最后对这个无序链表进行直接插入排序并将其输出。
难点在于将AB合并为链表C的操作以及对链表C进行直接插入排序的操作和根据用户的意愿可以对链表进行删除的操作。
三.算法流程图建立链表A 建立链表B合并A B链表比较m.n得到C链表排序得到D链表删除得到E链表四.详细步骤(1)结构体的创建:struct Node(2)链表的创建:struct Node *create()链表的创建。
链表的合并 实验报告
链表的合并实验报告一、实验目的本次实验的主要目的是深入理解链表的数据结构,并通过编程实现链表的合并操作,以提高对数据结构和算法的理解与应用能力。
二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。
三、实验原理链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
在合并两个链表时,需要比较两个链表节点的值,将较小的值依次添加到新的合并链表中。
当其中一个链表遍历完后,将另一个链表剩余的节点直接添加到合并链表的末尾。
四、实验步骤1、定义链表节点类```pythonclass ListNode:def __init__(self, val=0, next=None):selfval = val```2、合并链表函数```pythondef mergeTwoLists(l1, l2):dummy = ListNode(0) curr = dummywhile l1 and l2:if l1val < l2val:currnext = l1l1 = l1nextelse:currnext = l2l2 = l2nextcurr = currnextif l1:currnext = l1if l2:return dummynext```3、测试函数```pythondef test_mergeTwoLists():构建测试链表 l1l1 = ListNode(1)l1next = ListNode(2)l1nextnext = ListNode(4)构建测试链表 l2l2 = ListNode(1)l2next = ListNode(3)l2nextnext = ListNode(4)merged_list = mergeTwoLists(l1, l2)打印合并后的链表while merged_list:print(merged_listval, end="")merged_list = merged_listnext```五、实验结果与分析运行测试函数,得到合并后的链表输出为:1 1 2 3 4 4 。
数据结构课程设计实现两个链表的合并
一、需求分析:题目:实现两个链表的合并问题描述:1. 建立两个链表 A 和 B,链表元素个数分别为 m 和n 个。
2. 假设元素分别为(x1,x2,…xm),和(y1,y2, …yn)。
把它们合并成一个线形表 C,使得:当 m>=n 时,C=x1,y1,x2,y2, ...xn,yn, (x)当 n>m 时,C=y1,x1,y2,x2, …ym,xm,…,yn输出线性表 C。
由题目的相关信息可以分析得到:首先我们需要建立两个链表 AB,A 链表的元素个数为m;B 链表的元素个数为n;在将链表进行合并,更具 m 和n 的大小关系决定链表 C 的元素顺序;再将C 经行直接插入排序得到一个新的链表 D;最后输出 ABCD 的相关信息。
二、算法的流程图开始Creat A链表Creat B链表Mergel(A,B)合并成C对C排序生成D提示输入 0 或者 1错误输入Cmd error链表的名字正确 错误表的名字正确 错误删除, 打印 Nameerror 删除,打印 Nameerror打印“over ”结束三、 算法设计分析这个两个链表的交叉合并算法主要运用到的是链表的基本操作,定义 节点,将链表的创建、计算链表的长度、链表 A,B 的交叉组合、链表内容升 序罗列、删除链表指定位置元素、删除指定的元素等算法写成为了独立函数, 通过主函数调用。
这样就大大精简了主函数的操作。
但主函数中很大篇幅用 到了 if 、else 语句, 用以指定链表指定结点和指定元素的删除操作, 这样就 使得本来很精简变得繁琐,降低了程序的质量。
所以其有优点和缺点,但需 要不断的改进,不断优化该程序。
cmd=1输入将要操作的链 cmd=0输入将要操作的四、源代码程序源代码:#include<stdio.h>#include<stdlib.h>typedef struct node//节点定义{int data;struct node *next;} node,*linklist;linklist creat(linklist head) //该函数用来创建链表{node *r,*s;int a;r = (linklist)malloc(sizeof(node));head = r ;while(a != 0){s =(node*)malloc(sizeof(node));s->data=a;r->next=s;r=s ;}r->next=NULL;return head;}linklist length(linklist l) // 返回 L 中数据元素个数{int i=0;linklist p=l->next; // p 指向第一个结点while(p){i++;p=p->next;}return i;}linklist mergel(linklist A,linklist B) //用于实现链表 A,B 的交叉组合{int m,n;node *p,*q,*s,*t;linklist C;p=A->next;q=B->next;m=length(A);n=length(B);C=A;if(m<n){p=B->next;q=A->next;C=B;}while(p&&q){s=p->next;p->next=q;if(s){t=q->next;q->next=s;}p=s;q=t;}return C;}linklist sort(linklist L) //链表内容升序罗列{linklist p,q,min;int temp;p=L;while( p=p->next ){q=min=p;while(q=q->next){if( q->data<min->data )min = q;}if( min!=p ){temp = p->data;p->data = min->data;min->data=temp;}}return L;}linklist Delete(linklist l,int index) //删除链表指定位置元素{ linklist p,t;int cx=1; //用于计数p=l;if(index<length(l)){while(p&&(cx<index)){t=p;p=p->next;cx++;}t->next=p->next;}elsereturn l;}linklist Delete_element(linklist l,int data) //删除指定的元素{ linklist p;p=l;if(p->next){while(p->next->data!=data){p=p->next;}p->next=p->next->next;}elsereturn l;}linklist display(linklist l) //打印{ linklist p;p = l->next;while(p){p= p->next;}return l;}main(){linklist p,q,A,B,C,D;int indexs;int datas;char name;int cmd ;A = creat(A);B = creat(B);C = mergel(A,B);p = C->next;while(p){p=p->next;创建 A 链表,并打印创建 B 链表,并打印//生成 C 链表,并打印}//对 C 进行排序生成D D=C;sort (D) ;q = D->next;while(q){q = q->next;}//用 1 和 0 判断是按位置删除还是直接删除元素//位置删除if(cmd==0){fflush(stdin);fflush(stdin);if(name=='A'){Delete(A,indexs);display(A);}else if(name=='B'){Delete(B,indexs);display(B);}else if(name=='C'){Delete(C,indexs);display(C);}else if(name=='D'){}elseDelete(D,indexs);display(D); } else}else if(cmd==1) {fflush(stdin);//fflush(stdin);//元素删除//清除缓冲if(name=='A') {Delete_element(A,datas);display(A);}else if(name=='B') {Delete_element(B,datas);display(B);}else if(name=='C') {Delete_element(C,datas);display(C);}else if(name=='D') {Delete_element(D,datas);display(D);} elsegetchar();return 0;}六、实验运行结果显示:设计体味及今后改进的意见;短短一周的数据结构课程设计结束了,回想着这一周自己的表现,感觉不是很满意,感到自己许多不足之处。
二.两个链表的合并
二.两个链表的合并一、设计题目及设计目的1.设计题目两个链表的合并2、设计目的2.1 掌握线性链表的建立。
2.2 掌握线性链表的基本操作。
二、运行环境(软、硬件环境)1. 硬件环境PC-386以上微机4M以上的内存VGA显示格式2. 软件环境西文DOS操作系统(可使用UCDOS汉字操作系统)Turbo C (2.0版)三、算法设计的思想1 建立两个链表A和B,链表元素个数分别为m和n个。
2 假设元素分别为(x1,x2,…xm),和(y1,y2, …yn)。
把它们合并成一个线形表C,使得:当m>=n时,C=x1,y1,x2,y2,...xn,yn, (x)当n>m时,C=y1,x1,y2,x2,…ym,xm,…,yn输出线形表C3 用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
4 能删除指定单链表中指定位置和指定值的元素。
四、算法的流程图五、算法设计分析首先,建立两个结构体:一是链表接点结构体,其中包括数据域和指针域;另一个是整个链表。
主函数中,先对链表1和链表2进行初始化,创建表1与表2,然后,创建主菜单,进行选择操作,用的是switch语句。
最后,写出LinkList的hebing 函数,paixu函数,print函数。
六、源代码#include "stdio.h"#include "malloc.h"#define datatype inttypedef struct Node{ datatype data;struct Node *next;}LNode;typedef struct{ LNode *Link;int num;}LinkList;LinkList *init_LinkList(){ LinkList *L;L=new LinkList;L->Link=new LNode;L->Link->next=NULL;L->num=0;return L;}LinkList *Creat_LinkList(LinkList *L1) { LNode *s,*r;r=L1->Link;int n;scanf("%d",&n);while(n!=0){ s=new LNode;s->data=n;s->next=r->next;r->next=s;r=s;L1->num++;scanf("%d",&n);}if(r!=NULL)r->next=NULL;return L1;}LinkList *Creat_LinkListe(LinkList *L2) { LNode *s,*r;r=L2->Link;int n;scanf("%d",&n);while(n!=0){ s=new LNode;s->data=n;s->next=r->next;r->next=s;r=s;scanf("%d",&n);L2->num++;}// printf("%d",L2->num);if(r!=NULL)r->next=NULL;return L2;}LinkList *hebing(LinkList *L1,LinkList *L2,LinkList *L) { LNode *p,*q,*r,*s,*t,*g;int i=0;p=L1->Link->next;q=L2->Link->next;if(L1->num>=L2->num){ r=p;L->Link->next=r;while(q!=NULL){ p=p->next;t=p;r->next=q;p=t;s=q->next;q->next=p;r=p;q=s;}}else{r=q;L->Link->next=r;while(p!=NULL){ q=q->next;t=q;r->next=p;q=t;s=p->next;p->next=q;r=q;p=s;}}g=L->Link->next;while(g){L->num++;g=g->next;}return L;}LinkList *paixu(LinkList *L){ int i=0,j,k,t,o;LNode *r,*p;//printf("%d",L->num);for(j=i+1;j<L->num;i++,j++){ p=L->Link->next;for(k=0;k<j;k++)p=p->next;t=p->data;// printf("%d/n",t);// printf("%d",r->data);for(k=i;k>=0;k--){ r=L->Link;for(o=k;o>0;o--)r=r->next;// printf("%d",r->next->data);if(t<r->next->data){ //m=r;// m->next=p;r->next->next->data=r->next->data;r->next->data=t;}}}//printf("%d",L->Link->next->next->data);return L;}void print(LinkList *L1,LinkList *L2,LinkList *L){LNode *p;p=L->Link->next;//printf("%d\n",L->Link->next->next->next->next->data);while(p!=NULL){printf("%3d",p->data);p=p->next;}printf("\n");}LinkList *dete(LinkList *L){ int k,i,j,sum=1;LNode *p,*r;printf("0.指定位置删除 1.指定数删除\n");scanf("%d",&k);if(k!=0 && k!=1)printf("输入错误!请重新输入!\n");if(k==0){printf("请输入你要删除的位置:\n");scanf("%d",&i);if(i>L->num)printf("你输入的数越界!!\n");else{p=L->Link;for(j=0;j<i-1;j++)p=p->next;r=p->next;p->next=r->next;free(r);printf("删除成功!!\n");}}if(k==1){ printf("请输入你要删除的数:\n");scanf("%d",&i);p=L->Link->next;while(p->data!=i){ p=p->next;sum++;}if(sum>L->num)printf("没有这个元素!!\n");else{printf("删除成功!!\n");p=L->Link;for(j=0;j<sum-1;j++)p=p->next;r=p->next;p->next=r->next;free(r);}}return L;}void main(){ LinkList *L1;L1=init_LinkList();LinkList *L2;L2=init_LinkList();LinkList *L;L=init_LinkList();int k;do{printf("\t\t===========两个链表的合并============\n");printf("\t\t\t0.退回到主菜单");printf("\n\t\t\t1.创建表1\n");printf("\t\t\t2.创建表2\n");printf("\t\t\t3.合并表\n");printf("\t\t\t4.重新排序\n");printf("\t\t\t5.指定删除\n");printf("\t\t\t6.两个链表的输出\n");printf("\t\t请选择0----6\n");scanf("%d",&k);switch(k){case 0:break;case 1:printf("请输入一个链表:");L1=Creat_LinkList(L1);break;case 2: printf("请输入另一个链表:");L2=Creat_LinkListe(L2);break;case 3:printf("\n系统在合并两个链表之中……\n");L=hebing(L1,L2,L);printf("合并成功!!\n");//printf("%d\n",L->Link->next->next->data);break;case 4: printf("\n系统在重新排序当中……\n");L=paixu(L);printf("排序成功!!\n");break;case 5: L=dete(L);break;case 6:printf("两个链表排序为:\n");print(L1,L2,L);break;}}while(k!=0);}七、运行结果分析八、收获及体会通过两个链表的合并的设计,使我了解了它的算法,进一步了解算法如何实现。
循环单链表合并实验报告
4. 输入及输出结果:
链表长度: 4 6
两个链表的数据:1 5 12 78
6 12 56 99 120 156
顺序合并结果为:1 5 12 12 56 78 99 120 156 1
逆序合并结果为:156 120 99 78 56 12 12 5 1 156
3.各模块之间的调用关系
主程序模块
构造链表及链表的合并与输出模块
结点结构单元模块
三.详细设计
1.元素类型,结点类型和指针类型
typedef struct Lnode
{
int data;
struct Lnode *next;
}Lnode,*Linklist;
2.每个函数的具体分析
1)主函数
int main()
scanf("%d",&s->data);//输入新建立的节点数据
s->next=p->next;
p->next=s;
p=s;//尾插法插入新节点
}
}
3)输出循环链表
DispList(Linklist L,int n)
{
p=L->next;
while(p!=L)
{
printf("%d ",p->data);
}
}
5)链表的逆序合并
mergelistoppose(Linklist list1,Linklist list2)
{
p=(Linklist)malloc(sizeof(Lnode));
p->next=p; //先建立一个循环单链表
链表的合并课程设计报告正文
目录1 前言 (1)2 需求分析 (1)2.1课程设计目的 (2)2.2课程设计任务 (2)2.3设计环境 (2)3 概要设计 (2)3.1数据结构设计 (2)3.2模块设计 (3)4 详细设计 (4)5 测试分析 (10)6 课程设计总结 (11)参考文献 (11)致谢 (11)附录 (12)1 前言实现对两个的链表的交叉合并,输出线形表C用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
掌握对线性表的链式表示和实现,实现插入的操作。
了解链表交叉合并的方法和直接插入排序法的思想,并深刻掌握算法的格式和应用。
提高对数据结构的理解和应用,增强个人动手实践能力和逻辑分析能力。
2 需求分析2.1课程设计目的学生在教师指导下运用所学课程的知识来研究、解决一些具有一定综合性问题的专业课题。
通过课程设计(论文),提高学生综合运用所学知识来解决实际问题、使用文献资料、及进行科学实验或技术设计的初步能力,为毕业设计(论文)打基础。
2.2课程设计任务(1)建立两个链表A和B,链表元素个数分别为m和n个。
(2)假设元素分别为(x1,x2,…x m),和(y1,y2, …y n)。
把它们合并成一个线形表C,使得:当m>=n时,C=x1,y1,x2,y2,…x n,y n,…,x m当n>m时,C=y1,x1,y2,x2,…y m,x m,…,y n输出线形表C(3)用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
测试数据:(1)A表(30,41,15,12,56,80)B表(23,56,78,23,12,33,79,90,55)(2)A表(30,41,15,12,56,80,23,12,34)B表(23,56,78,23,12)2.3设计环境(1)WINDOWS 2000/2003/XP/7/Vista系统(2)Visual C++或TC集成开发环境3 概要设计3.1数据结构设计带头结点链表抽象数据类型的结点结构定义如下:typedef struct node{elemtype data;struct node *next;}*linklist,lnode;3.2模块设计本次课程设计所需要用到的是关于链表的建立、合并以及直接插入排序的排序算法。
有序表的合并的标准实验报告Word版
软件工程专业类课程实验报告课程名称:学院专业:学生姓名:学号:指导教师:日期:电子科技大学计算机学院实验中心电子科技大学实验报告一、实验室名称:二、实验项目名称:有序单链表的合并三、实验原理:合并单链表算法的思想描述,因这是本实验重点,这里老是就不写了。
四、实验目的:1. 掌握带头结点的单链表建立,插入,删除,查找等基本操作的设计与实现2. 通过单链表的排序编程理解单链表与顺序表操作的区别与联系3. 理解单链表对集合操作的实现4. 掌握有序集合合并的算法设计与存储结构的关系,及时空复杂度与算法性能的关系五、实验内容:1. 编程实现建立单链表的操作2. 编程实现单链表的排序3. 编程实现用单链表合并有序表,使得合并结果有序,但是要求不额外增加内存空间存放合并后的数据,时间开销尽量少六、实验器材(设备、元器件):电脑1台;XP或者windows 7操作系统Visual studio 2010开发环境七、实验步骤:1. 项目分析与概要设计(1)输入:第一个单链表长度第一个单链表的所有数据第二个单链表长度第二个单链表的所有数据(2)输出:2个有序单链表合并成一个有序表(3)算法分析与概要设计:a). 实现两个有序单链表的合并,首先要保证输入的单链表有序,因此要判断单链表是否有序,如果无序,要先重新对单链表进行排序,然后才能够做合并操作。
b). 因为单链表合并后不能增加额外空间,所以原来单链表的结点要串连到新的合并后的单链表中,原来的单链表合并后将不再存在。
原来的单链表有2个头结点,合并后只有一个单链表,因此有一个头结点将被释放。
这里选择A集合的头结点为合并后的头结点,而原来B集合的头结点将被释放。
合并有序单链表的算法流程图见图1所示。
图1 有序单链表的合并的概要设计流程图2. 数据结构与详细设计(1)数据结构采用带头结点的单链表存储数据,结点结构如下:struct node {int value;struct node * next;};typedef struct node Node;typedef struct node *ptrList,*List;(2)详细设计根据概要设计流程图,需要实现如下功能:建立带头结点的单链表;判断单链表是否有序;单链表排序;合并有序表使其仍然有序;打印输出单链表的所有数据。
链表的合并设计报告
《数据结构》实验报告◎实验题目:合并两个链表◎实验目的:对两个给定的带头结点的有序链表进行合并◎实验内容:建立链表,输入链表元素,并对链表进行合并一、需求分析1、输入的形式和输入值的范围:输入两个链表的长度(整型)和其中的元素(实型);2、输出的形式:合并后的链表长度和链表中的元素。
3、程序所能达到的功能:(1)循环链表的建立(2)循环链表的输出(3)将俩个链表进行合并(4)合并后对链表输出4、测试数据:输入数据:5,1 3 15 26 39;6,2 3 8 9 26 35;输出数据:1 2 3 3 8 9 15 26 26 35 39二概要设计(1)抽象数据类型定义:三个链表指针:LinkList *list,*list1,*list2;两个整型数表示链表长度:int n1,n2;(2)主程序的流程:1.创建链表;2.输出链表;3.链表合并;4.合并后链表输出;(3)其函数之间调用关系如下:注:大箭头表示函数调用,小箭头表示程序执行过程;三详细设计1.元素类型typedef int ElemType;typedef struct LNode{ElemType data;struct LNode *next;} LinkList,*p;2.每个模块的分析:(1)主程序模块://主函数int main(){LinkList *list,*list1,*list2;int n1,n2;printf("请输入第一个链表的长度:");scanf("%d",&n1);list1=CreateListR(list1,n1);DispList(list1);printf("请输入第二个链表的长度:");scanf("%d",&n2);list2=CreateListR(list2,n2);DispList(list2);list=MergeLL(list1,list2,list);printf("合并后的链表为: ");DispList(list);return 1;}(2)创建链表并输入链表信息p CreateListR(LinkList *L,int n){LinkList *s,*r;int i;L=(LinkList *)malloc(sizeof(LinkList));r=L;r->next=L;printf("\n 请输入节点的数据:\n");for(i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));scanf("%d",&s->data);r->next=s;r=s;}r->next=L;return L;}(3)输出已建立链表中的元素进行验证;void DispList(LinkList *L){LinkList *p=L->next;do{printf("%d ",p->data);p=p->next;}while(p!=L);printf(" \n");}(4)对链表进行合并并对合并后链表进行输出;p MergeLL(LinkList *La,LinkList *Lb,LinkList *Lc) {LinkList *pa,*pb,*pc;Lc=(LinkList *)malloc(sizeof(LinkList));pc=Lc;pa=La->next;pb=Lb->next;while(pa!=La&&pb!=Lb) {if(pa->data<pb->data){pc->next=pa;pa=pa->next;pc=pc->next;}else{pc->next=pb;pb=pb->next;pc=pc->next;}}//处理剩余部分while(pa!=La){pc->next=pa;pa=pa->next;pc=pc->next;}while(pb!=Lb){pc->next=pb;pb=pb->next;pc=pc->next;}pc->next=Lc;return Lc;}四使用说明、测试分析及结果1.程序使用说明;(1)本程序的运行环境为VC6.0。
数据结构实验报告_合并链表
《数据结构》链表合并实验报告(一) 需求分析1、输入的形式和输入值的范围:根据题目要求与提示输入两链表,且数与数之间用空格隔开,输入一行数后用0作为结束符。
2、输出的形式:输出合并后的链表。
3、程序所能达到的功能:程序能合并两个有序链表为一个新的有序链表,并以从小到大的顺序输出。
4、测试数据:输入一个链表,并用空格将数隔开,每个链表以0作为结束符,如:1 3 9 02 4 6 10 0输出的链表为:1 2 3 4 6 9 10.(二) 概要设计为了实现上述操作,应以链表为存储结构。
1.基本操作:(1). struct node *scanff()初始条件:struct node *scanff形式的指针存在;操作结果:建立链表函数,返回建立好的链表的头结点head。
(2).void print(struct node *head)初始条件:struct node *head为一已知链表的头结点;操作结果:输出该链表。
(3).struct node *insert(struct node *ah,struct node *bh)初始条件:ah,bh两链表已知,且有序;操作结果:合并ah,bh为一新的有序链表。
2.本程序包含二个模块:(1)主程序模块;(2)输入,输出,合并链表函数模块(3)模块调用图:主程序模块输入链表模块(三) 详细设计1.存储类型,元素类型,结点类型:struct node{//构造链表指针结构int data;struct node *next;}node,*lnode;元素类型为整形。
2.每个模块的分析:(1)主程序模块:void main(){struct node *ahead,*bhead,*abh;ahead=scanff();//调用scanff函数,输入表Abhead=scanff();//调用scanff函数,输入表Babh=insert(ahead,bhead);//调用insert函数,合并两链表print(abh);//输出合并后的函数}(2)输入函数模块struct node *scanff(){//建立链表函数,返回建立好的链表的头结点struct node *p1;struct node *head;n=0;struct node *p2;p1=p2=(struct node *)malloc(len);scanf("%d",&p1->data);head=NULL;while(p1->data!=0){n++;if(n==1) head=p1;else p2->next=p1;p2=p1;p1=(struct node *)malloc(len);scanf("%d",&p1->data);}p2->next=NULL;return(head);}输出函数模块void print(struct node *head){//建立输出函数struct node *p;p=head;if(p!=NULL)do{printf("%d ",p->data);p=p->next;}while(p!=NULL);}合并链表函数模块struct node *insert(struct node *ah,struct node *bh){//定义insert函数,用来合并两个链表struct node *pa1,*pb1,*pa2,*pb2;pa2=pa1=ah;pb2=pb1=bh;do{while((pb1->data>pa1->data)&&(pa1->next!=NULL)){pa2=pa1;pa1=pa1->next;}if(pb1->data<=pa1->data){if(ah==pa1) ah=pb1;else {pa2->next=pb1;pb1=pb1->next;pb2->next=pa1;pa2=pb2;pb2=pb1;}}}while ((pa1->next!=NULL)||(pa1==NULL&&pb1!=NULL));if((pb1!=NULL)&&(pb1->data>pa1->data)&&(pa1->next==NULL)) pa1->next=pb1;return(ah);}3)函数调用关系图main()3.完整的程序:#include "stdio.h"#include "malloc.h"#define len sizeof(struct node)struct node{//构造链表指针结构int data;struct node *next;}node,*lnode;int n;struct node *scanff(){//建立链表函数,返回建立好的链表的头结点struct node *p1;struct node *head;n=0;struct node *p2;p1=p2=(struct node *)malloc(len);scanf("%d",&p1->data);head=NULL;while(p1->data!=0){n++;if(n==1) head=p1;else p2->next=p1;p2=p1;p1=(struct node *)malloc(len);scanf("%d",&p1->data);}p2->next=NULL;return(head);}void print(struct node *head){//建立输出函数struct node *p;p=head;if(p!=NULL)do{printf("%d ",p->data);p=p->next;}while(p!=NULL);}struct node *insert(struct node *ah,struct node *bh) {//定义insert函数,用来合并两个链表struct node *pa1,*pb1,*pa2,*pb2;pa2=pa1=ah;pb2=pb1=bh;do{while((pb1->data>pa1->data)&&(pa1->next!=NULL)){pa2=pa1;pa1=pa1->next;}if(pb1->data<=pa1->data){if(ah==pa1) ah=pb1;else {pa2->next=pb1;pb1=pb1->next;pb2->next=pa1;pa2=pb2;pb2=pb1;}}}while ((pa1->next!=NULL)||(pa1==NULL&&pb1!=NULL));if((pb1!=NULL)&&(pb1->data>pa1->data)&&(pa1->next==NULL))pa1->next=pb1;return(ah);}void main(){struct node *ahead,*bhead,*abh;ahead=scanff();//调用scanff函数,输入表Abhead=scanff();//调用scanff函数,输入表Babh=insert(ahead,bhead);//调用insert函数,合并两链表print(abh);//输出合并后的函数}(四) 程序使用说明及测试结果1.程序使用说明(1)本程序的运行环境为VC6.0。
有序链表的合并
一、实验目的用链表(LinkList)类型实现书上算法,并且了解线性表及在计算机中的两类不同的存储结构;熟练掌握线性表的合并。
二、实验内容有序链表合并(原节点、新节点两种方式),用顺序方法存储的线性表称为顺序表,当线性表中很少做插入和删除操作,线性表的长度变化不大,易于事先确定其大小时,可以采用顺序表作为存储结构。
用链接方法存储的线性表称为线性链表,当线性表的长度变化较大,难以估计其存储规模,另外对线性表频繁进行插入和删除操作时,则采用链表作为存储结构可能会更好一些。
三、实验步骤有序链表的合并(新节点)#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define ok 1#define error 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define elemtype inttypedef struct //结构体定义顺序表{int *elem;int length;}SqList;int InitList_sq(SqList &A, int n) //顺序表的初始化函数{A.elem = (elemtype *)malloc(n*sizeof(elemtype));if(!A.elem)return error;A.length = n;return ok;}int traverse_Sq(SqList &L) //遍历顺序表{int i;if(L.length == 0)printf("链表不存在!");else{ for(i=0;i <L.length;i++)printf("%d ",L.elem[i]);}printf("\n");return ok;}SqList MergeList_Sq(SqList &A,SqList &B, SqList &C) //合并{int *lista = A.elem;int *listb = B.elem;C.length = A.length + B.length;int *listc = C.elem = (elemtype * )malloc(C.length * sizeof(elemtype));if(!C.elem)exit(1);int *lista_last = A.elem + A.length;int *listb_last = B.elem + B.length;while((lista <lista_last) && (listb <listb_last)){if(*lista <=*listb)*listc++ = *lista++;else*listc++ = *listb++;}while(lista <lista_last)*listc++ = *lista++;while(listb <listb_last)*listc++ = *listb++;return C;}int main(){SqList A, B, C;int i,na, nb;scanf("%d", &na);InitList_sq(A, na);for( i = 0;i <na;i++){scanf("%d", &A.elem[i]);}scanf("%d", &nb);InitList_sq(B, nb);for( i = 0;i <nb;i++){scanf("%d", &B.elem[i]);}printf("A列表:");traverse_Sq(A);printf("B列表:");traverse_Sq(B);MergeList_Sq(A,B,C);printf("C列表:");traverse_Sq(C);return 0;}//以原节点方式实现合并void Merge0(Node *La,Node *Lb){//void MergeList_L(Linklist *La, Linklist *Lb, Linklist *Lc){ Node*Lc;Node *pa,*pb,*pc;pa = La->next;pb = Lb->next;Lc = pc = La;while(pa && pb){if(pa->data <= pb->data){pc->next = pa;pc = pa;pa = pa->next;}else {pc->next = pb;pc = pb;pb = pb->next;}}pc->next = pa? pa:pb;free(Lb);}四、实验结果五、实验小结线性表是软件设计中最基础的数据结构。
链表的建立、合并与拆分
2链表的建立、合并与拆分【实验简介】链表是用链接存储的方式来表达线性表,它用指针表示结点间的逻辑关系,链表适用于插入或删除频繁,存储空间需求不定的情形。
【实验内容】定义一个链表存储的线性表,除已给出的表元素插入、删除、查找等基本操作外,再提供表的合并、拆分和逆置等操作。
在应用程序中建立两个整型的单链表对象A和B,应用线性表的基本操作对表的实例对象进行操作测试。
1. 设线性链表A=(a1,a2,…,am),,B=(b1,b2,…bm),按下列规则合并A,B为线性表C 的算法,即使得C = (a1,b1,…,am,bm, b(m+1),…,bn) 当m<=n或 C = (a1,b1,…,an,bn, a(n+1),…,am) 当m>nC表利用A表和B表中的结点空间构成。
2. 将C表原地逆置。
3. 将C表的中偶数和奇数分别链接为两个循环链表D和E。
说明:每一次合并、拆分和逆置等操作的结果均要输出。
【主要代码】#include<iostream>using namespace std;template <class T>struct LinkNode //结点类{T data;LinkNode<T> *link;LinkNode(LinkNode<T> *ptr=NULL){link=ptr;} //仅初始化指针成员的构造函数LinkNode(const T& item,LinkNode<T> *ptr=NULL) //初始化数据成员和指针成员的构造函数{data=item;link=ptr;}};template <class T>class List //链表类{private:LinkNode<T> *first; //链表头指针public:List(){first=new LinkNode<T>;} //构造函数List(T& x){first=new LinkNode<T>(x);} //构造函数List(List& L); //复制构造函数~List(){MakeEmpty();}void MakeEmpty(); //将链表置为空表//int Length()const; //计算链表长度LinkNode<T> *GetHead()const{return first;} //返回附加头结点地址void SetHead(LinkNode<T> *p){first=p;} //设置附加头结点地址LinkNode<T> *Search(T x); //搜索含数据x的元素LinkNode<T> *Locate(int i); //搜索第i个元素的地址T *GetData(int i, T& x); //取第i个元素的值bool SetData(int i,T& x); //用x修改第i个元素的值bool Insert(int i,T& x); //在第i个元素后插入xbool Remove(int i,T& x); //删除第i个元素,x返回该元素的值bool IsMmpty()const //判断表是否为空{return first->link=NULL?true:false;}void Sort();void Input(T endTag); ////从前端输入,当输入字符endTag时结束输入void Output(); //输出List<T>& operator=(List<T>& L); //重载函数:赋值};template <class T> //将链表置为空表void List<T>::MakeEmpty(){ LinkNode<T> *q;while(first->link!=NULL){q=first->link; //保存被删结点first->link=q->link; //从链上摘下该结点delete q; //删除}};template <class T> //计算链表长度int List<T>::Length () const{ListNode<T> *p=first->link;int count=0;while (p!=NULL) //逐个结点检测{ p=p->link;count++; }return count;};template <class T> //在表中搜索含数据x的结点, 搜索成功时函数返该结点地址; 否则返回NULL。
数据结构实验报告 有序表合并
实验有序表合并姓名:窦晓磊班级:软件工程142学号:********** 试验时间:2015.10.111.问题描述把两个有序表归并为一个有序表。
2.数据结构设计链表结点的结构为:Typedef struct Node{T data;Node *next;};3.算法设计(1)表的输入和输出。
设计一个输入输出函数Node *CreateList()。
Step1:设计指针。
Node *q, //工作指针,存储head*Head, //头指针*p; //工作指针,存储数据int size, //用于存储有序表元素的个数n; //元素的输入Step2:利用指针进行输入。
q=Head=new Node; //建立头结点利用循环输入for(int i=1;i<=n;i++){p=new Node; //建立结点cin>>n; //输入元素p->data=n; //将输入的元素赋值给链表Head->next=p; //尾指针后移Head=p; //指向下一个结点Head=p;}Head->next=NULL; //设置尾指针Head=q;Step3:输出。
for(p=Head->next;p!=NULL;p=p->next)cout<<p->data;Return Head; //返回Head所指的链表(2)合并算法1’初始化Step1:设置工作指针pa、pb,分别指向两个有序表LA、LB的首元结点。
Node *pa,*pb; //工作指针pa,pbpa=LA->next;pb=LB->next;Step2:生成新表LC的头结点,工作指针pc指向LC。
Node *pc;LC=pc;2’只要pa和pb有所指,循环执行下列操作。
While(pa!=NULL&&pb!=NULL)Step1:生成一新结点,链到LC表尾,pc指向它。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
课程设计报告课程设计题目:两个链表的合并专业:软件工程班级:姓名:学号:指导教师:年月日目录1.课程设计的目的及要求2.课程设计的容(分析和设计)3.算法流程图4.详细步骤5.代码6.显示结果7.课程设计的总结一.课程设计的目的及要求1.目的:实现两个链表的合并2.要求:(1)建立两个链表A和B,链表元素个数分别为m和n个。
(2)假设元素分别为(x1,x2,...xm),和(y1,y2, ...yn)。
把它们合并成一个线形表C,使得:当m>=n时,C=x1,y1,x2,y2,...xn,yn, (x)当n>m时,C=y1,x1,y2,x2,…ym,xm,…,yn输出线形表C(3)用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
(4)能删除指定单链表中指定位子和指定值的元素。
二.课程设计的容(分析和设计)1..分析由题目的相关信息可以分析得:首先我们需要建立两个链表AB,A链表的元素个数为m,B链表的元素个数为n;在将A、B链表进行合并,根据m和n的大小关系决定链表C的元素顺序;再将C进行直接插入排序得到一个新的链表D;没次输入完一次链表信息,程序都会对相应的链表进行输入操作以此确保程序输入的数据是你想要输入的数据。
同时当你合并好和排序好后都会进行输出操作。
最后当排序好后你可以指定你所要删除数据的位置来删除你所要删除的数据。
2.设计本次课程设计所需要用到的是关于链表的建立、合并以及直接插入排序的排序算法。
需要先建立两个链表,再将其合并为一个无序链表,最后对这个无序链表进行直接插入排序并将其输出。
难点在于将AB合并为链表C的操作以及对链表C进行直接插入排序的操作和根据用户的意愿可以对链表进行删除的操作。
三.算法流程图四.详细步骤(1)结构体的创建:struct Node(2)链表的创建:struct Node *create()链表的创建。
(3)链表的输出:void print(struct Node *head)功能是对链表进行输出。
(4)链表的合并:struct Node * inter_link(struct Node * chain1, int a, struct Node *chain2, int b)算法的功能是实现两个链表的交叉合并,并且可以根据两链表的长短将行不通的插入。
(5)排序:void InsertSort(struct Node *p,int m)算法的功能是对一合并好的链表进行升序插入排序。
(6)按位删除操作:struct Node * delete_link(struct Node *p,int i)。
(7)按值删除操作:struct Node * delete_linkz(struct Node *p,int i)。
(8)主函数:main()函数主要是对算法进行测试。
五.代码struct Node //数据结构定义如下:{long int number;struct Node *next;}Node,*linkList;#include<stdlib.h> //源程序:#include<stdio.h>#include<conio.h>#include<malloc.h>#define error 0#define null 1#define L sizeof(struct Node)struct Node *create(int a)//链表创建函数{int n;struct Node *p1, *p2, *head;head = NULL;n = 0;p2 = p1 = (struct Node *) malloc(L); //分配存scanf("%ld", &p1->number);while (a)//录入链表信息{n = n + 1;if (n == 1)head = p1;elsep2->next = p1;p2 = p1;p1 = (struct Node *) malloc(L);if (a != 1)//分配存scanf("%ld", &p1->number);a--; //控制输入的个数}p2->next = NULL;return (head);}//链表创建函数结束void print(struct Node *head)//输出函数{struct Node *p;p = head;printf("数字:\n");if (head != NULL)do//循环实现输出{printf("%ld", p->number);printf(" ");p = p->next;} while (p != NULL);printf("\n");}//链表的交叉合并算法struct Node * inter_link(struct Node * chain1, int a, struct Node * chain2, int b) { int temp;struct Node *head, *p1, *p2, *pos;/*判断a,b大小并合并*/if (a >= b) {head = p1 = chain1;p2 = chain2;} else/*b>a*/ {head = p1 = chain2;p2 = chain1;temp = a, a = b, b = temp; /*交换a和b*/}/*下面把p1的每个元素插在p2相应元素之前,p1长a,p2长b*/pos = head; /*此时pos指向p1中的第一个元素*/while (p2 != NULL) {//漂亮,蛇形插入p1 = p1->next;pos->next = p2;pos = p2;p2 = p2->next;pos->next = p1;pos = p1;}return head;}//对合并好的链表进行排序void InsertSort(struct Node *p, int m)//排序函数{int i, j, t;struct Node *k;k = p;for (i = 0; i < m - 1; i++) {for (j = 0; j < m - i - 1; j++) {if (p->number > (p->next)->number) {t = p->number;p->number = (p->next)->number;(p->next)->number = t;}p = p->next;}p = k;}}struct Node * delete_link(struct Node *p,int i) //按位删除{ struct Node *q;int j=0;while(j<i-1&&p->next){ p=p->next;j++;}if(j==i-1&&p->next){q=p->next;p->next=q->next;free(q);}else return error;}struct Node * delete_linkz(struct Node *p,int i)//按值删除{ struct Node *q;struct Node *k;int j=0;int h=0;while(p&&p->number!=i)p=p->next;j++;if (p){while (h<j-1&&p->next){p=p->next;h++;}if(h==j-1&&p->next){k=p->next;p->next=k->next;free(k);}}elsereturn error;}//主函数int main()//main函数{struct Node *p1, *p2;int a;int b;int h;int t;int m;printf("请输入第一个链表:\n");printf("\n输入链表的长度a:\n");scanf("%d", &a);printf("请输入链表数据:");p1 = create(a);printf("\n你刚才输入的第一个链表信息:\n ");print(p1);printf("\n 请输入第二个链表:\n");printf("\n输入链表的长度b:\n");scanf("%d", &b);printf("请输入链表数据:");p2 = create(b);printf("\n你刚才输入的第二个链表的信息:\n");print(p2);p1 = inter_link(p1, a, p2, b);h = a + b;printf("\n合并后的链表\n:");print(p1);InsertSort(p1, h);printf("\n排序后的链表:\n");print(p1);printf("\n请输入链表中你所要删除数据的所在位置:\n");scanf("%d",&t);delete_link(p1,t);printf("\n链表删除数据后链表的信息:\n");print(p1);printf("\n请输入你想要删除的数值:\n");scanf("%d",&m);delete_linkz(p1,m);printf("\n链表删除数据后链表的信息:\n");print(p1);return 0;}六.显示结果(1)m<n(2)m>n3.m=n4.按位删除操作5.按值删除七.课程设计的总结通过进一周的学习和实践,解决实际问题,让我对链表有了更深的了解,也让我提高了解决实际问题的能力。
在上机的同时改正了自己对某些算法的错误使用,使自己在通过程序解决问题时抓住关键算法,有了算法设计思想和流程图,并用C语言描绘出关键算法。