实现两个链表的合并 课程设计报告
实现两个链表的合并数据结构课程设计

实现两个链表的合并数据结构课程设计实现两个链表的合并。
输入两个链表的长度和节点,输出合并后的链表。
算法设计:使用递归的思想,对于传入的两个链表,比较他们的表头节点,将较小的节点加入到新链表中,然后递归将较小节点所在的链表和另一个链表继续合并,最后返回新链表即可。
实现过程如下:Step 1:定义链表数据结构typedef struct Node{int data;struct Node* next;}Node, *List;Step 2:定义合并函数List merge(List List1, List List2){ 合并两个链表if(List1 == NULL) return List2; 如果List1为空,则返回List2if(List2 == NULL) return List1; 如果List2为空,则返回List1List newList = NULL; 新链表的表头指针if(List1->data < List2->data){ 如果List1的表头节点的值小于List2的表头节点的值newList = List1; 将List1的表头节点作为新链表的表头节点newList->next = merge(List1->next, List2); 递归将List1的剩余节点和List2继续合并}else{ 若List1的表头节点的值大于等于List2的表头节点的值newList = List2; 将List2的表头节点作为新链表的表头节点newList->next = merge(List1, List2->next); 递归将List2的剩余节点和List1继续合并}return newList; 返回已合并的新链表的表头指针}Step 3:测试代码#include<stdio.h>#include<stdlib.h>int main(){int len1, len2, elem;scanf("%d%d", &len1, &len2);List List1 = NULL, List2 = NULL, p = NULL;for(int i = 0; i < len1; i++){ 创建List1 scanf("%d", &elem);List node = (List)malloc(sizeof(Node));node->data = elem;node->next = NULL;if(List1 == NULL){List1 = node;p = List1;}else{p->next = node;p = p->next;}}for(int i = 0; i < len2; i++){ 创建List2 scanf("%d", &elem);List node = (List)malloc(sizeof(Node));node->data = elem;node->next = NULL;if(List2 == NULL){List2 = node;p = List2;}else{p->next = node;p = p->next;}}List newList = merge(List1, List2); 合并两个链表p = newList; 输出新链表while(p != NULL){printf("%d ", p->data);p = p->next;}return 0;}示例输入:3 41 5 103 6 8 9示例输出:1 3 5 6 8 9 10。
数据结构课程设计 链表合并

数据结构课程设计链表合并数据结构课程设计 - 链表合并概述:在数据结构课程设计中,链表合并是一个常见的问题。
本文将详细介绍链表合并的概念、算法和实现方法,并提供代码示例和详细解释。
1. 链表的基本概念链表是一种常见的数据结构,用于存储和组织数据。
链表由一系列节点组成,每一个节点包含一个数据元素和一个指向下一个节点的指针。
链表的第一个节点称为头节点,最后一个节点的指针指向空。
2. 链表合并的定义链表合并是指将两个有序链表合并成一个有序链表的操作。
合并后的链表应保持有序性。
3. 链表合并的算法链表合并可以使用迭代或者递归算法来实现。
3.1 迭代算法迭代算法通过比较两个链表的节点值,挨次选择较小的节点插入到新链表中。
具体步骤如下:- 创建一个新链表和一个指向新链表尾部的指针。
- 比较两个链表的节点值,选择较小的节点插入到新链表中,并更新指针。
- 如果其中一个链表为空,将另一个链表的剩余部份直接插入到新链表中。
- 返回新链表的头节点。
3.2 递归算法递归算法通过递归地合并链表的子链表来实现链表合并。
具体步骤如下:- 如果其中一个链表为空,返回另一个链表。
- 比较两个链表的头节点值,选择较小的节点作为合并后的头节点。
- 递归调用合并函数,将较小节点的下一个节点与另一个链表合并,并将结果作为当前节点的下一个节点。
- 返回合并后的头节点。
4. 链表合并的实现方法下面是使用C++语言实现链表合并的示例代码:```cpp#include <iostream>struct ListNode {int val;ListNode* next;ListNode(int x) : val(x), next(NULL) {}};ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {if (l1 == NULL) return l2;if (l2 == NULL) return l1;ListNode* head = NULL;ListNode* tail = NULL;if (l1->val <= l2->val) {head = l1;l1 = l1->next;} else {head = l2;l2 = l2->next;}tail = head;while (l1 != NULL && l2 != NULL) { if (l1->val <= l2->val) {tail->next = l1;l1 = l1->next;} else {tail->next = l2;l2 = l2->next;}tail = tail->next;}if (l1 != NULL) {tail->next = l1;}if (l2 != NULL) {tail->next = l2;}return head;}int main() {// 创建链表1: 1 -> 2 -> 4ListNode* l1 = new ListNode(1);l1->next = new ListNode(2);l1->next->next = new ListNode(4);// 创建链表2: 1 -> 3 -> 4ListNode* l2 = new ListNode(1);l2->next = new ListNode(3);l2->next->next = new ListNode(4);// 合并链表ListNode* mergedList = mergeTwoLists(l1, l2); // 打印合并后的链表ListNode* current = mergedList;while (current != NULL) {std::cout << current->val << " ";current = current->next;}return 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进行直接插入排序的操作和根据用户的意愿可以对链表进行删除的操作。
三.算法流程图四.详细步骤(1)结构体的创建:struct Node(2)链表的创建:struct Node *create()链表的创建。
(3)链表的输出:void print(struct Node *head)功能是对链表进行输出。
合并两个链表课程设计

合并两个链表课程设计一、课程目标知识目标:1. 学生能理解链表的概念,掌握链表的基本操作,如插入、删除节点。
2. 学生能理解合并两个链表的过程,掌握合并算法的实现。
3. 学生能理解递归思想,并运用递归方法解决合并链表问题。
技能目标:1. 学生能运用所学知识,独立编写合并两个链表的程序。
2. 学生能够通过调试程序,找出并修正链表操作中的错误。
3. 学生能运用所学算法,解决实际问题,提高编程能力。
情感态度价值观目标:1. 学生培养对数据结构与算法的兴趣,认识到编程解决问题的价值。
2. 学生培养合作精神,学会在团队中分享、讨论和解决问题。
3. 学生培养良好的编程习惯,注重代码规范,提高代码质量。
分析课程性质、学生特点和教学要求:本课程为计算机科学或信息技术相关课程的章节,适用于高年级学生。
学生在学习本章节前,已具备基本的编程能力和数据结构知识。
课程旨在巩固学生的链表知识,提高编程技能,培养解决实际问题的能力。
课程目标具体、可衡量,旨在使学生能够独立完成合并两个链表的任务,并通过教学设计和评估,确保学生达到预期学习成果。
二、教学内容1. 链表基础知识回顾:包括链表的定义、节点结构、链表的分类(单向链表、双向链表等)。
2. 链表基本操作:插入、删除节点的方法及实现,重点讲解递归在链表操作中的应用。
3. 合并两个链表的概念:介绍合并链表的意义,分析合并过程中需注意的问题。
4. 合并算法讲解:详细讲解两种合并链表的方法(非递归和递归方法),并分析其优缺点。
5. 编程实践:指导学生编写合并两个链表的程序,要求学生独立完成,并注重代码规范。
6. 调试与优化:教授学生如何调试链表程序,找出并修正错误,提高程序性能。
教学内容安排和进度:1. 第一课时:回顾链表基础知识,讲解链表基本操作。
2. 第二课时:介绍合并两个链表的概念,讲解合并算法。
3. 第三课时:指导学生进行编程实践,完成合并链表的程序。
4. 第四课时:学生展示编程成果,讨论和解决编程过程中遇到的问题,进行调试与优化。
链表的合并课程设计

链表的合并课程设计一、课程目标知识目标:1. 学生能理解链表的基本概念,掌握链表的合并原理。
2. 学生能掌握链表节点的定义,理解链表的数据结构特点。
3. 学生能理解并掌握至少两种链表合并的算法,如归并排序和直接合并。
技能目标:1. 学生能够运用所学知识,独立编写链表合并的代码。
2. 学生能够通过分析问题,选择合适的链表合并算法解决问题。
3. 学生能够运用调试工具,检测并修复链表合并过程中出现的错误。
情感态度价值观目标:1. 学生培养对编程的兴趣,增强对数据结构与算法的探究欲望。
2. 学生培养团队合作意识,学会在团队中发挥个人优势,共同解决问题。
3. 学生通过链表合并的学习,培养解决问题的能力,增强自信心。
课程性质:本课程为信息技术学科的高阶课程,旨在帮助学生深入理解数据结构与算法在实际编程中的应用。
学生特点:学生处于高年级,已具备一定的编程基础,对数据结构与算法有一定了解,但实际应用能力有待提高。
教学要求:教师应注重理论与实践相结合,鼓励学生动手实践,培养学生的编程能力和问题解决能力。
在教学过程中,关注学生的个体差异,提供有针对性的指导。
通过链表合并的学习,使学生在知识、技能和情感态度价值观方面均有所提升。
二、教学内容本节教学内容主要包括以下几部分:1. 链表基础知识回顾:引导学生复习链表的定义、特点及基本操作,为学习链表合并打下基础。
2. 链表合并原理:讲解链表合并的基本原理,包括归并排序和直接合并两种方法,使学生理解并掌握合并过程。
3. 编程实践:指导学生运用所学知识,编写链表合并的代码,并进行调试和优化。
4. 算法分析与优化:分析不同链表合并算法的时间复杂度和空间复杂度,探讨优化策略。
5. 案例分析:选取实际案例,分析链表合并在实际编程中的应用,提高学生的应用能力。
教学大纲安排如下:1. 第一课时:链表基础知识回顾,引入链表合并原理。
- 教材章节:第三章 数据结构,第二节 链表。
2. 第二课时:讲解归并排序和直接合并两种链表合并方法。
数据结构课程设计-两个链表合并-星

数据结构课程设计-两个链表合并-星两个链表的合并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的元素按值非递减排列。
链表的合并实验报告

链表的合并实验报告文稿归稿存档编号:[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()链表的创建。
数据结构课程设计实现两个链表的合并讲课讲稿

数据结构课程设计实现两个链表的合并一、需求分析:题目:实现两个链表的合并问题描述: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;在将A\B链表进行合并,更具m和n的大小关系决定链表C的元素顺序;再将C经行直接插入排序得到一个新的链表D;最后输出ABCD的相关信息。
二、算法的流程图三、算法设计分析这个两个链表的交叉合并算法主要运用到的是链表的基本操作,定义节点,将链表的创建、计算链表的长度、链表A,B的交叉组合、链表内容升序排列、删除链表指定位置元素、删除指定的元素等算法写成了独立函数,通过主函数调用。
这样就大大精简了主函数的操作。
但主函数中很大篇幅用到了if、else语句,用以指定链表指定结点和指定元素的删除操作,这样就使得本来很精简变得繁琐,降低了程序的质量。
所以其有优点和缺点,但需要不断的改进,不断优化该程序。
四、源代码程序源代码:#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;scanf("%d",&a);while(a != 0){s =(node*)malloc(sizeof(node));s->data=a;r->next=s;r=s;printf("please input a data:");scanf("%d",&a);}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;}elseprintf("input indext error");return 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;}elseprintf("don't faind the element");return l;}linklist display(linklist l) //打印{ linklist p;printf("new linklist :\n");p = l->next;while(p){printf("%d\n",p->data);p= p->next;}return l;}main(){linklist p,q,A,B,C,D;int indexs;int datas;char name;int cmd;printf("Creat linklist A:\n"); //创建A链表,并打印printf("please input a data:");A = creat(A);printf("Creat linklist B:\n"); //创建B链表,并打印printf("please input a data:");B = creat(B);C = mergel(A,B); //生成C链表,并打印 printf("linklist C\n");p = C->next;while(p){printf("%d\n",p->data);p=p->next;}D=C; //对C进行排序生成D sort(D);printf("linklist D:\n");q = D->next;while(q){printf("%d\n",q->data);q = q->next;}printf("\nplease input 0 or 1 \n");//用1和0判断是按位置删除还是直接删除元素scanf("%d",&cmd);if(cmd==0) //位置删除{printf("please input linklist name\n ");fflush(stdin);scanf("%c",&name);printf("\nplease input index \n");scanf("%d",&indexs);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'){Delete(D,indexs);display(D);}elseprintf("nameError");}else if(cmd==1) //元素删除{fflush(stdin); //清除缓冲printf("please input linklist name\n ");//fflush(stdin);scanf("%c",&name);printf("\nplease input datas \n");scanf("%d",&datas);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);}elseprintf("name2error");}elseprintf("cmdError");printf("\nOver\n");getchar();return 0;}六、实验运行结果显示:设计体会及今后改进的意见;短短一周的数据结构课程设计结束了,回想着这一周自己的表现,感觉不是很满意,感到自己许多不足之处。
链表的合并课程设计

链表的合并课程设计一、教学目标本节课的学习目标包括以下三个方面:1.知识目标:学生需要掌握链表的基本概念,了解链表的合并原理和实现方法。
2.技能目标:学生能够运用链表的基本操作,实现链表的合并功能,并能够分析链表合并算法的的时间复杂度。
3.情感态度价值观目标:培养学生对计算机科学的兴趣,提高学生解决问题的能力,培养学生的团队协作精神。
二、教学内容本节课的教学内容主要包括以下几个部分:1.链表的基本概念:学生需要了解链表的定义、特点和基本操作。
2.链表的合并原理:学生需要理解链表合并的原理,掌握链表合并的方法和步骤。
3.链表合并的实现:学生需要通过编程实现链表的合并功能,掌握链表合并算法的实现技巧。
4.链表合并算法的时间复杂度分析:学生需要分析链表合并算法的时间复杂度,了解算法优化的重要性。
三、教学方法为了实现本节课的教学目标,我们将采用以下几种教学方法:1.讲授法:通过讲解链表的基本概念、合并原理和实现方法,使学生掌握相关知识。
2.案例分析法:通过分析具体的链表合并案例,使学生更好地理解链表合并的原理和实现方法。
3.实验法:让学生通过编程实验,亲手实现链表的合并功能,提高学生的实践能力。
4.讨论法:学生进行小组讨论,分享彼此的成果和心得,培养学生的团队协作精神。
四、教学资源为了支持本节课的教学内容和教学方法,我们将准备以下教学资源:1.教材:选用权威、实用的教材,为学生提供系统、科学的学习材料。
2.参考书:提供相关的参考书籍,丰富学生的知识体系。
3.多媒体资料:制作精美的PPT,直观地展示链表的基本概念和操作。
4.实验设备:准备计算机实验室,让学生进行编程实验,提高实践能力。
五、教学评估本节课的评估方式将包括以下几个方面:1.平时表现:通过观察学生在课堂上的参与程度、提问回答等情况,评估学生的学习态度和理解程度。
2.作业:布置相关的编程练习,评估学生对链表合并知识的掌握情况和实践能力。
3.考试:设计合理的考试题目,评估学生对链表基本概念、合并原理和实现方法的掌握程度。
链表合并实验报告

《数据结构》实验报告◎实验题目: 实现两个有序循环链表的合并◎实验目的:掌握链表的建立、遍历以及数据的插入,加深对链表的理解。
◎实验内容:设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、输⼊的形式和输⼊值的范围:根据题⽬要求与提⽰输⼊两链表,且数与数之间⽤空格隔开,输⼊⼀⾏数后⽤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;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=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。
链表的合并 实验报告

链表的合并实验报告一、实验目的本次实验的主要目的是深入理解链表的数据结构,并通过编程实现链表的合并操作,以提高对数据结构和算法的理解与应用能力。
二、实验环境本次实验使用的编程语言为 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);}七、运行结果分析八、收获及体会通过两个链表的合并的设计,使我了解了它的算法,进一步了解算法如何实现。
实现两个链表的合并数据结构课程设计

实现两个链表的合并数据结构课程设计实现两个链表的合并数据结构课程设计一、课程设计题目:实现两个链表的合并二、基本功能要求: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,…,yn3. 输出线性表C:用直接插入排序法对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)四、理论分析结果:1. A表的数据元素个数m=6,B表的数据元素个数n=9,此时m<n< bdsfid="84" p=""></n<>分析合并结果:当m<n时,应该先插入b表中的数据元素,在偶数位插入b< bdsfid="86" p=""></n时,应该先插入b表中的数据元素,在偶数位插入b<>表中的数据元素,在奇数位插入A表中的数据元素,最后插入B 表中剩余的数据元素。
C=23,30,56,41,78,15,23,12,12,56,33,80,79,90,55排序结果:D=12,12,15,23,23,30,33,41,55,56,56,78,79,80,902. A表的数据元素个数m=9,B表的数据元素个数n=5,此时m>n分析合并结果:当m>=n时,应该先插入A表中的数据元素,在偶数位插入A表中的数据元素,在奇数位插入B表中的数据元素,最后插入A 表中剩余的数据元素。
循环单链表合并实验报告

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模块设计本次课程设计所需要用到的是关于链表的建立、合并以及直接插入排序的排序算法。
链表的合并设计报告

《数据结构》实验报告◎实验题目:合并两个链表◎实验目的:对两个给定的带头结点的有序链表进行合并◎实验内容:建立链表,输入链表元素,并对链表进行合并一、需求分析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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
目录一需求分析 (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四个链表的相关信息。
void SortCToD(){struct Node *pre, *postC, *postD, *lopD;int len; //表示总的长度len = m + n;pre = D; //指向D有序数列的尾指针postC = C->next; //指向C列表//列表D第一个节点加入postD = new Node; //分配一个新的节点postD->data = postC->data; //将D的值赋给CpostD->next = 0; //D的下一个节点为0pre->next = postD; //pre的下一个节点指向Dpre = postD; //pre指向DpostC = postC->next; //指向下一个节点while (postC){//pre为指向插入的前一个节点,lopD是指向插入的后一个节点pre = D; //pre指向DlopD = D->next; //lopD指向D的下一个节点while (lopD) //当D不为空{if (lopD->data > postC->data) //判断条件break;else{pre = lopD; //pre指向DlopD = lopD->next; //指向下一个节点}}//将节点插入postD = new Node; //分配一个新的节点postD->data = postC->data; //将D的值赋给CpostD->next = 0; //D的下一个节点为0pre->next = postD; //pre的下一个指向DpostD->next = lopD; //循环条件postC = postC->next; //指向下一个节点}}int main(){InitListAB(); //初始化AB链表MergeABToC(); //合并AB链表SortCToD(); //对C进行直接插入排序得到D printList(A); //输出A链表printList(B); //输出B链表printList(C); //输出C链表printList(D); //输出D链表return 0;}四调试分析与测试结果测试数据A表的输出结果如图2所示:图2测试数据B表的输出结果如图3所示:图3五总结为期一个星期的数据结构课程设计结束了,我们小组所选择的课题也已经顺利的完成。
在这一个星期中我受益良多。
将在上个学期所学习的数据结构这门课程进行了一个系统的整理归纳,让我对数据结构了有更深刻的理解。
在选择这个课题之后我查阅了相关的资料,对在这次课程设计当中我们需要用到的知识做出了一个系统的归纳:链表的建立、链表的合并、直接插入排序以及switch语句等知识点。
虽然知识点已经整理出来了,但是在实际的编写过程当中,我们还是遇到了一些问题:比如链表的合并当中需要对AB链表的元素个数进行大小比较,在决定交叉排列的相关顺序。
这个地方我们试用了几种方法都不能解决。
最后通过逐条语句的分析以及画出的链表和指针的图示之后,才发现是一个指针的指向出现了问题。
经过修改之后顺利的输出了经过升序排列的链表D。
在本次的课程设计当中我明白了几点在今后的学习当中至关重要的东西:首先,团队合作精神是十分重要的,俗话还说:“三个臭皮匠胜过一个诸葛亮。
”一个人的力量始终是有限的,明确的团队分工才是完成任务的最好方法;其次,严谨的态度也是很重要的,编写代码的时候需要以一个认真严谨一丝不苟的态度去面对你的问题。
如果在你完成一大段的代码编写之后在发现编译不通过或者结果不正确,但是却始终找不出问题的所在,只好从头开始在却逐句的分析。
无疑这样会浪费大量的时间和精力,也会使得进度大大的变慢。
最后,拥有一个良好的心态也是必不可少的,编写代码是一个相对比较枯燥的过程,需要长时间的坐在电脑前面进行编写,偶尔出现的问题会让你思考很长时间却不一定会得到很好的解决。
这时良好的心态的作用就会显示出来,始终保持一颗平常心会使得你在关键的时刻很淡定的去面对所需要解决的问题。
课程设计虽然结束了,但是我们要走的路依然很远,对数据结构的学习远远没有结束。
我们不能满足于书本上已经学会的知识,要积极的去拓展我们的知识面,加强同学之间的交流,分享大家学习的心得,最终获得共同进步。
六参考文献01 谭浩强·C语言课程设计(第2版)·清华大学出版社,2009年:P89~P11102 李根强·数据结构(C++版)(第2版)·中国水利水电出版社,2009年:P14~P37,P218~21903 陈维兴,林小茶·C++面向对象程序设计教程·(第3版)·清华大学出版社,2009年:P326~P33804 严蔚敏吴伟民·数据结构(C语言版)·清华大学出版社,2010年:P18~P39,P265~P26605 百度数据结构吧/f?kw=%CA%FD%BE%DD%BD%E1%B9%B9&fr =ala0七致谢在本次的数据结构课程设计当中,我需要感谢席金菊老师以及谭罗勇同学。
席老师让我们在机房中自己去合理的利用时间以及机器完成课题的设计,宽松的环境让我们能够毫无压力的进行课程设计,这对我们的顺利完成有很大的裨益。
而作为一组的组员,我与谭罗勇同学共同将这个课题完成。
每当遇到了不可解决的问题的时候,我们总会进行深刻的探讨,一起查阅资料去努力解决这个问题。
解决问题之后得豁然开朗总是让人格外的有成就感。
在彼此的无间合作当中,经过几天的努力,我们的课题顺利的完成并且程序运行的结果是可喜的。
没有老师以及同学的帮助,我想独自完成这次的课程设计是很有难度的,在此,再次向对我提供过帮助的人致以最诚挚的感谢!八附录#include<iostream.h>int m, n;int count = 1;struct Node{int data;struct Node *next;}*A,*B,*C,*D;void printList(struct Node *AList){struct Node *post;post = AList->next;switch(count){case 1:cout<<endl;cout<<"ListA: ";break;case 2:cout<<endl;cout<<"ListB: ";break;case 3:cout<<endl;cout<<"ListC: ";break;case 4:cout<<endl;cout<<"ListD: ";break;default:cout<<endl;cout<<"List: ";break;}while (post){cout<<post->data<<' ';post = post->next;}count ++;}void InitListAB(){A = new Node;A->data = 0;A->next = 0;B = new Node;B->data = 0;B->next = 0;C = new Node;C->data = 0;C->next = 0;D = new Node;D->data = 0;D->next = 0;int i;struct Node *post;struct Node *pre;cout<<"m="; cin>>m;cout<<"n="; cin>>n;pre = A;for(i=1; i<=m; i++){post = new Node;cout<<"A"<<i<<"=";cin>>post->data;post->next = 0;pre->next = post;pre = post;}pre = B;for(i=1; i<=n; i++){post = new Node;cout<<"B"<<i<<"=";cin>>post->data;post->next = 0;pre->next = post;pre = post;}}void MergeABToC(){int i;struct Node *pre, *postA, *postB, *postC;pre = C;postA = A->next;postB = B->next;if(m >= n){for(i=1; i<=n; i++){postC = new Node;postC->data = postA->data;postC->next = 0;pre->next = postC;pre = postC;postC = new Node;postC->data = postB->data;postC->next = 0;pre->next = postC;pre = postC;postA = postA->next;postB = postB->next;}for(i=n+1; i<=m; i++){postC = new Node;postC->data = postA->data;postC->next = 0;pre->next = postC;pre = postC;}}else{for(i=1; i<=m; i++){postC = new Node;postC->data = postB->data;postC->next = 0;pre->next = postC;pre = postC;postC = new Node;postC->data = postA->data;postC->next = 0;pre->next = postC;pre = postC;postA = postA->next;postB = postB->next;}for(i=m+1; i<=n; i++){postC = new Node;postC->data = postB->data;postC->next = 0;pre->next = postC;pre = postC;postB = postB->next;}}}void SortCToD(){struct Node *pre, *postC, *postD, *lopD;int len;len = m + n;pre = D;postC = C->next;postD = new Node;postD->next = 0;pre->next = postD;pre = postD;postC = postC->next;while (postC){pre = D;lopD = D->next;while (lopD){if (lopD->data > postC->data)break;else{pre = lopD;lopD = lopD->next;}}postD = new Node;postD->data = postC->data;postD->next = 0;pre->next = postD;postD->next = lopD;postC = postC->next;}}int main(){InitListAB();MergeABToC();SortCToD();printList(A);printList(B);printList(C);printList(D);return 0;}。