实验报告03-两个有序链表的合并
数据结构单链表实验报告
数据结构单链表实验报告实验目的:掌握单链表的基本操作,学会使用单链表实现各种算法。
实验内容:实现单链表的基本操作,包括创建、插入、删除、访问等。
利用单链表完成以下算法:- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第K个节点- 合并两个有序单链表为一个有序单链表实验步骤:1. 创建单链表在创建单链表时,先定义一个结构体Node来表示链表中的节点,节点包括数据域和指针域,指针域指向下一个节点。
然后,用指针p指向链表的头节点,将头节点的指针域初始化为NULL。
2. 插入节点在单链表中插入节点的操作分为两种情况:- 在链表头插入节点- 在链表中间或尾部插入节点无论是哪种情况,先将新节点的指针域指向要插入的位置的下一个节点,再将要插入的位置的指针域指向新节点即可。
3. 删除节点删除链表节点的操作同样分为两种情况:- 删除头节点- 删除中间或尾部节点要删除头节点,先用一个指针将头节点指向的下一个节点保存起来,再将头节点释放掉。
要删除中间或尾部节点,先用一个指针指向要删除节点的前一个节点,然后将指向要删除节点的前一个节点的指针域指向要删除节点的下一个节点,最后将要删除的节点释放掉。
4. 单链表逆序单链表逆序可以使用三个指针来完成,分别为pre指针、cur指针和next指针。
首先将pre指针和cur指针指向NULL,然后循环遍历链表,将cur指针指向当前节点,将next指针指向当前节点的下一个节点,然后将当前节点的指针域指向pre指针,最后将pre指针和cur指针向前移动一个节点,继续进行循环。
5. 查找单链表中的中间节点查找单链表中的中间节点可以使用双指针法,将两个指针p1和p2都指向链表头,然后p1每次向前移动一个节点,而p2每次向前移动两个节点,当p2指向了链表尾部时,p1指向的节点即为中间节点。
6. 删除单链表中的倒数第K个节点删除单链表中的倒数第K个节点可以使用双指针法,在链表中定义两个指针p1和p2,p1指向链表头,p2指向第K个节点,然后p1和p2同时向前移动,直到p2指向链表尾部,此时p1指向的节点即为要删除的节点。
设计两个有序单链表的合并排序算法
设计两个有序单链表的合并排序算法有序单链表的合并排序,是一种高效的排序算法,可以在较短的时间内对大量数据进行排序。
这种排序算法的核心在于将两个有序的单链表合并成一个有序的单链表,然后再对整个链表进行排序。
合并排序算法的基本原理是分治法。
将需要排序的数组不断地分解成两个子数组,直到每个子数组只包含一个元素为止。
然后再将这些子数组两两合并,直到整个数组被合并成一个有序的数组为止。
这里介绍两个有序单链表的合并排序算法,它们分别是迭代算法和递归算法。
1. 迭代算法迭代算法是一种通用的算法,它的思路是利用循环结构来重复执行一段相同或相似的代码,从而解决一类问题。
对于有序单链表的合并排序,迭代算法的基本思路是将两个有序单链表的元素依次比较,然后将较小的元素加入到新的链表中,直到两个链表中的元素全部被加入到新链表中为止。
以下是迭代算法的具体实现过程:```// 合并两个有序单链表Node* mergeList(Node* head1, Node* head2) { // 新建一个头结点Node* dummy = new Node(-1);// 定义两个指针,分别指向两个链表的头结点 Node* p = head1;Node* q = head2;// 定义一个指针,指向新链表的最后一个节点 Node* curr = dummy;// 循环比较两个链表中的元素while (p != nullptr && q != nullptr) {if (p->val <= q->val) {curr->next = p;p = p->next;} else {curr->next = q;q = q->next;}curr = curr->next;}// 将剩余的元素加入到新链表中curr->next = p != nullptr ? p : q;// 返回新链表的头结点return dummy->next;}// 归并排序Node* mergeSort(Node* head) {if (head == nullptr || head->next == nullptr) {return head;}// 定义两个指针,一个快指针每次走两步,一个慢指针每次走一步 Node* slow = head;Node* fast = head->next;while (fast != nullptr && fast->next != nullptr) {slow = slow->next;fast = fast->next->next;}// 将链表分成两部分Node* head1 = head;Node* head2 = slow->next;slow->next = nullptr;// 分别对两部分链表进行归并排序head1 = mergeSort(head1);head2 = mergeSort(head2);// 合并两个有序单链表return mergeList(head1, head2);}```2. 递归算法递归算法的思想是将一个大问题分解成若干个小问题,然后逐个解决这些小问题,最终得到大问题的解决方案。
有序链表的合并实验总结
有序链表的合并实验总结有序链表的合并是计算机科学中常见的操作之一,它在许多算法和数据结构中都有广泛的应用。
本文将对有序链表的合并进行实验总结,并探讨其应用和实现方法。
我们需要了解什么是有序链表。
有序链表是一种数据结构,它按照某种规则将元素按顺序排列在链表中。
在有序链表中,每个节点都包含一个值和一个指向下一个节点的指针。
这种数据结构的优点是插入和删除操作相对容易,但查找操作的效率较低。
因此,在某些场景下,有序链表比其他数据结构更适合。
有序链表的合并就是将两个有序链表合并成一个新的有序链表。
合并的过程是将两个链表中的节点逐个比较,并按照大小顺序插入到新链表中。
具体步骤如下: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. 首先,判断两个循环链表是否为空。
若其中一个链表为空,则直接返回另一个链表作为合并后的链表。
2. 接下来,找到第一个链表的最后一个节点和第二个链表的第一个节点。
将第一个链表的最后一个节点的指针指向第二个链表的第一个节点,同时将第二个链表的最后一个节点的指针指向第一个链表的第一个节点。
3. 最后,返回第一个链表的第一个节点作为合并后的循环链表的起始节点。
下面我们通过一个具体的例子来说明合并两个循环链表的过程:假设有两个循环链表A和B,它们分别包含如下节点:链表A:1 -> 2 -> 3 -> 4 -> 1链表B:5 -> 6 -> 7 -> 5判断链表A和链表B是否为空。
由于两个链表都不为空,我们继续执行下一步。
然后,找到链表A的最后一个节点4和链表B的第一个节点5。
将节点4的指针指向节点5,同时将节点7的指针指向节点1。
返回链表A的第一个节点1作为合并后的循环链表的起始节点。
合并后的循环链表为:1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 1通过上述的例子,我们可以看出,合并两个循环链表的过程并不复杂。
只需要找到两个链表的相应节点,并修改它们之间的指针关系即可。
在实际应用中,合并循环链表的操作可以用于将两个有序的循环链表合并成一个有序的循环链表。
这种操作在某些场景下非常有用,比如合并两个有序的链表可以用于合并两个有序数组,从而形成一个更大的有序数组。
总结起来,合并循环链表的过程简单明了。
通过找到两个链表的相应节点,并修改它们之间的指针关系,我们可以将两个循环链表合并成一个新的循环链表。
算法分析与设计实验报告合并排序快速排序
算法分析与设计实验报告:合并排序与快速排序一、引言算法是计算机科学中非常重要的一部分,它涉及到解决问题的方法和步骤。
合并排序和快速排序是两种经典而常用的排序算法。
本文将对这两种排序算法进行分析和设计实验,通过对比它们的性能和效率,以期得出最优算法。
二、合并排序合并排序是一种分治算法,它将原始数组不断分解为更小的数组,直到最后细分为单个元素。
然后,再将这些单个元素两两合并,形成一个有序数组。
合并排序的核心操作是合并两个有序的数组。
1. 算法步骤(1)将原始数组分解为更小的子数组,直到每个子数组只有一个元素;(2)两两合并相邻的子数组,同时进行排序,生成新的有序数组;(3)重复步骤(2),直到生成最终的有序数组。
2. 算法性能合并排序的最优时间复杂度为O(nlogn),其中n为待排序数组的长度。
无论最好情况还是最坏情况,合并排序的复杂度都相同。
合并排序需要额外的存储空间来存储临时数组,所以空间复杂度为O(n)。
三、快速排序快速排序也是一种分治算法,它将原始数组根据一个主元(pivot)分成两个子数组,一个子数组的元素都小于主元,另一个子数组的元素都大于主元。
然后,递归地对这两个子数组进行排序,最后得到有序数组。
快速排序的核心操作是划分。
1. 算法步骤(1)选择一个主元(pivot),可以是随机选择或者固定选择第一个元素;(2)将原始数组根据主元划分为两个子数组,一个子数组的元素都小于主元,另一个子数组的元素都大于主元;(3)递归地对这两个子数组进行快速排序;(4)重复步骤(2)和(3),直到每个子数组只有一个元素,即得到最终的有序数组。
2. 算法性能快速排序的平均时间复杂度为O(nlogn),其中n为待排序数组的长度。
最坏情况下,当每次选择的主元都是最小或最大元素时,时间复杂度为O(n^2)。
快速排序是原地排序,不需要额外的存储空间,所以空间复杂度为O(1)。
四、实验设计为了验证合并排序和快速排序的性能和效率,我们设计以下实验:1. 实验目的:比较合并排序和快速排序的时间复杂度和空间复杂度。
将两个有序顺序表合并成一个新的有序顺序表
将两个有序顺序表合并成⼀个新的有序顺序表#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define MaxSize 50typedef struct{int data[MaxSize];int length;}SqList;void ListInsert(SqList *L,int i,int e){int j;if(i<1||i>L->length+1)exit(-1);if(L->length>=MaxSize)exit(-1);for(j=L->length;j>=i;j--)L->data[j]=L->data[j-1];L->data[i-1]=e;L->length++;}void DispList(SqList *L){int i;for(i=0;i<L->length;i++)printf("%d ",L->data[i]);printf("\n");}void Exchange(SqList *A,SqList *B,SqList *C){int i=0,j=0,k=0;while(i<A->length&&j<B->length){if(A->data[i]<B->data[j])C->data[k++]=A->data[i++];else if(A->data[i]>B->data[j])C->data[k++]=B->data[j++];}while(i<A->length)C->data[k++]=A->data[i++];while(j<B->length)C->data[k++]=B->data[j++];C->length=k;}void main(){SqList *A,*B,*C;A=(SqList*)malloc(sizeof(SqList));A->length=0;B=(SqList*)malloc(sizeof(SqList));B->length=0;C=(SqList*)malloc(sizeof(SqList));C->length=0;ListInsert(A,1,1);ListInsert(A,2,3);ListInsert(A,3,5);ListInsert(A,4,7);ListInsert(A,5,9);ListInsert(B,1,2);ListInsert(B,2,4);ListInsert(B,3,6);ListInsert(B,4,8);ListInsert(B,5,10);ListInsert(B,6,12);Exchange(A,B,C);printf("顺序表A:");DispList(A);printf("顺序表B:");DispList(B);printf("顺序表C:");DispList(C);}。
数据结构实验两个有序顺序表的合并
南昌大学实验报告学生姓名:李木子学号:8000113146 专业班级:软工133 实验类型:□验证□综合□设计□创新实验日期:实验成绩:一、实验项目名称两个有序顺序表的结合二、实验目的顺序表的创建1.实现顺序表的追加2.实现顺序表的显示3.两顺序表的合并三、实验基本原理四、主要仪器设备及耗材电脑,VC6.0五、实验步骤/*******************************************//* 顺序表的创建 *//* 1.实现顺序表的追加 *//* 2.实现顺序表的显示 *//* 3.两顺序表的合并 *//*******************************************/#include <stdio.h>#include <stdlib.h>#define MAXSIZE 100typedef int datatype;/************************************//* 顺序表结构体的定义 *//************************************/typedef struct{datatype a[MAXSIZE];int size;}sequence_list;/************************************//* 函数声明 *//************************************/void init(sequence_list *slt);void append(sequence_list *slt,datatype x);void display(sequence_list slt);int find(sequence_list slt ,datatype x);void dele(sequence_list *slt,datatype x);void sort(sequence_list *s);void combine( sequence_list *s1 ,sequence_list *s2 ,sequence_list *s3);/************************************//* 顺序表的初始化函数 *//************************************/void init(sequence_list *slt){slt->size=0;}/************************************//* 顺序表的追加函数 *//************************************/void append(sequence_list *slt,datatype x){if(slt->size==MAXSIZE){printf("\n顺序表是满的!");exit(1);}slt->a[slt->size]=x ;slt->size=slt->size+1;}/************************************/ /* 顺序表的显示函数 */ /************************************/ void display(sequence_list slt){int i;if(!slt.size){printf("\n顺序表为空");}else{for(i=0;i<slt.size;i++)printf("\n%d\n",slt.a[i]);}}/************************************/ /* 顺序表的查找函数 */ /* 返回所查数据的下标 */ /************************************/ int find(sequence_list slt ,datatype x) {int i=0;while(i<slt.size &&slt.a[i]!=x)i++;return(i<slt.size? i:-1);}/************************************/ /* 顺序表的删除函数 */ /************************************/ void dele(sequence_list *slt,datatype x) {int i=0;i=find(*slt,x);for(;i<slt->size-1;i++)slt->a[i]=slt->a [i+1];slt->size--;}/************************************//* 顺序表的插入函数 *//************************************/ void insert(sequence_list *slt,datatype x) {int i=0;i=find(*slt,x);for(;i<slt->size-1;i++)slt->a[i+1]=slt->a [i];slt->size++;}/************************************//* 顺序表排序 *//************************************/ void sort(sequence_list *s){int i ;int j ;int temp ;for(i=0;i<s->size-1;i++){for(j=i+1;j<s->size;j++){if(s->a[i]>=s->a[j]){temp=s->a[i];s->a[i]=s->a[j];s->a[j]=temp;}}}}/************************************//* 两个有序顺序表连接函数 *//************************************/void combine( sequence_list *s1 , sequence_list *s2 , sequence_list *s3 ) {int i=0;int j=0;int k=0;while( i < s1->size && j < s2->size){if(s1->a[i]<=s2->a[j]){s3->a[k]=s1->a[i];i++;}else{s3->a[k]=s2->a[j];j++;}k++;}if(i==s1->size){while(j<s2->size){s3->a[k]=s2->a[j];k++;j++;}}if(j==s2->size){while(i<s1->size){s3->a[k]=s1->a[i];k++;}}s3->size=k;}/************************************/ /* 主函数 */ /************************************/ int main(){int i ;int j ;int x ;int n ;sequence_list list1 ;sequence_list list2 ;sequence_list list3 ;init(&list1);printf("第一个顺序表元素个数:\n");scanf("%d",&n);printf("第一个顺序表输入:\n");for(i=0; i<n ; i++){scanf("%d",&list1.a[i]);list1.size++;}sort(&list1);printf("排序后\n");display(list1);init(&list2);printf("第二个顺序表元素个数:\n");scanf("%d",&n);printf("第二个顺序表输入:\n");for(i=0; i<n ; i++){scanf("%d",&list2.a[i]);list2.size++;}sort(&list2);printf("排序后\n");display(list2);init(&list3);combine(&list1 ,&list2 ,&list3);printf("表一与表二连接后:\n");display(list3);return0;}六、实验数据及处理结果七、思考讨论题或体会或对改进实验的认识八、参考资料[1]《数据结构(c语言版)(第三版)》,李云清,人民邮电出版社[2]《C语言程序设计》,苏小红,高等教育出版社教你如何用WORD文档(2012-06-27 192246)转载▼标签:杂谈1. 问:WORD 里边怎样设置每页不同的页眉?如何使不同的章节显示的页眉不同?答:分节,每节可以设置不同的页眉。
链表的反转与合并掌握链表反转和合并操作的实现
链表的反转与合并掌握链表反转和合并操作的实现链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
链表的反转和合并是链表操作中常见且重要的操作,在很多编程问题中都有应用。
本文将介绍链表的反转和合并操作的实现方法。
一、链表的反转链表的反转是指将链表中节点的顺序反向排列。
例如,对于链表1→2→3→4→5,反转后的链表为5→4→3→2→1。
实现链表的反转有两种常见的方法:迭代法和递归法。
1. 迭代法迭代法的实现思路是,从链表头节点开始,依次遍历每个节点,将该节点的指针指向前一个节点。
具体步骤如下:1)定义三个指针:当前节点指针cur、前一个节点指针prev、下一个节点指针next。
2)遍历链表,将当前节点的指针指向前一个节点,然后更新prev、cur和next指针的位置。
3)重复上述步骤,直到遍历到链表末尾。
以下是迭代法的实现代码示例(使用Python语言):```pythondef reverse_list(head):prev = Nonecur = headwhile cur:next = cur.nextcur.next = prevprev = curcur = nextreturn prev```2. 递归法递归法的实现思路是,从链表的尾节点开始,依次反转每个节点。
具体步骤如下:1)递归地反转除最后一个节点外的链表。
2)将当前节点的指针指向前一个节点。
3)返回反转后的链表的头节点。
以下是递归法的实现代码示例(使用Python语言):```pythondef reverse_list(head):if not head or not head.next:return headnew_head = reverse_list(head.next)head.next.next = headhead.next = Nonereturn new_head```二、链表的合并链表的合并是指将两个有序链表按照一定的规则合并成一个有序链表。
c++手写算法,两个有序数组的合并
c++手写算法,两个有序数组的合并【最新版】目录1.概述2.合并有序数组的方法3.实现过程4.示例代码5.总结正文1.概述C++是一种通用的编程语言,其强大的功能和灵活性使其成为许多程序员的首选。
在 C++中,算法是编程的核心,而手写算法则是检验程序员编程能力的重要方式。
本篇文章将介绍如何手写算法来实现两个有序数组的合并。
2.合并有序数组的方法在实现两个有序数组的合并过程中,我们可以采用双指针法。
这种方法使用两个指针,分别指向两个数组的头部,然后比较两个指针所指向的元素,将较小的元素放入到合并后的数组中,同时将指向较小元素的指针向后移动一位。
这个过程一直重复,直到某一个数组被完全合并到另一个数组中。
3.实现过程下面是一个具体的实现过程。
首先,我们需要定义一个新的数组,用于存储合并后的元素。
然后,我们使用双指针法,分别指向两个有序数组的头部。
在每一次循环中,我们比较两个指针所指向的元素,将较小的元素放入到新数组中,然后将指向较小元素的指针向后移动一位。
这个过程一直重复,直到某一个数组被完全合并到另一个数组中。
4.示例代码下面是一个示例代码,用于演示如何手写算法来实现两个有序数组的合并。
```cpp#include <iostream>using namespace std;void merge(int arr1[], int arr2[], int i, int j, int n1, int n2) {int m[n1 + n2], k = 0;for (int p = 0; p < n1; p++) {if (arr1[p] < arr2[j]) {m[k++] = arr1[p];} else {m[k++] = arr2[j++];}}for (int p = n1; p < n1 + n2; p++) {m[k++] = arr2[p];}for (int p = 0; p < n1 + n2; p++) {arr1[p] = m[p];}}int main() {int arr1[] = {1, 3, 5, 7};int arr2[] = {2, 4, 6, 8};int n1 = sizeof(arr1) / sizeof(arr1[0]);int n2 = sizeof(arr2) / sizeof(arr2[0]);merge(arr1, arr2, 0, 0, n1, n2);for (int i = 0; i < n1 + n2; i++) {cout << arr1[i] << " ";}cout << endl;return 0;}```5.总结通过手写算法,我们可以实现两个有序数组的合并。
数据结构合并两个顺序表
数据结构合并两个顺序表合并两个顺序表是在数据结构中常见的操作之一,本文将介绍如何合并两个顺序表,并给出相应的算法实现。
顺序表是一种线性表的存储结构,它使用连续的存储空间存储元素,并按照顺序存放。
合并两个顺序表的意思是将两个顺序表中的元素按照一定的顺序合并到一个新的顺序表中。
假设有两个顺序表A和B,它们的长度分别为m和n。
要合并这两个顺序表,可以使用以下步骤:1. 创建一个新的顺序表C,用于存放合并后的结果。
2. 首先将顺序表A中的元素复制到顺序表C中,保持元素的顺序不变。
3. 然后将顺序表B中的元素依次插入到顺序表C中的合适位置。
插入的位置可以根据需要进行调整,可以选择插入到顺序表C的末尾,也可以选择按照某种规则插入。
4. 最后,顺序表C中的元素就是合并后的结果。
在实现合并两个顺序表的算法时,可以使用两个指针分别指向顺序表A和顺序表B的元素。
比较指针指向的元素大小,然后将较小的元素插入到顺序表C中,并将对应的指针向后移动一位。
重复这个过程,直到遍历完两个顺序表中的所有元素。
下面是一个具体的算法实现示例:```void merge(SeqList A, SeqList B, SeqList C) {int i = 0; // 指向顺序表A的指针int j = 0; // 指向顺序表B的指针int k = 0; // 指向顺序表C的指针// 将顺序表A中的元素复制到顺序表C中while (i < A.length) {C.elements[k++] = A.elements[i++];}// 将顺序表B中的元素插入到顺序表C中while (j < B.length) {int x = B.elements[j++];// 找到插入位置int insertPos = 0;while (insertPos < k && C.elements[insertPos] < x) { insertPos++;}// 将元素插入到合适位置for (int m = k; m > insertPos; m--) {C.elements[m] = C.elements[m - 1];}C.elements[insertPos] = x;k++;}C.length = k; // 更新顺序表C的长度}```这个算法的时间复杂度为O(m+n),其中m和n分别为顺序表A 和顺序表B的长度。
链表实验报告总结doc
链表实验报告总结篇一:顺序表,链表总结实验报告实验报告实验目的:学生管理系统(顺序表)实验要求:1.建表2.求表长3.插入4.查找5.删除6.列表7.退出源程序:#include#include#include#define MaxSize 1000typedef struct{char xh[40];char xm[40];int cj;}DataType; //学生的结构typedef struct {DataType data[MaxSize]; //定义表的数据类型int length; //数据元素分别放置在data[0]到data[length-1]当中} SqList; //表的结构void liebiao(SqList *L)//{int k,n;char q;printf("请输入,输入学生的个数:\n");fflush(stdin);scanf("%d",&n);for(k=0;k {printf("请输入学生学号\n");scanf("%s",L->data[k].xh);printf("请输入学生名字\n");scanf("%s",L->data[k].xm);printf("请输入学生成绩\n");scanf("%d",&L->data[k].cj); 建立表格}L->length=n;}void qb(SqList *L) //全部输出{int k,w;for(k=0;klength;k++){w=k+1;printf("第%d位学生:",w);printf("%s %s%d\n",L->data[k].xh,L->data[k].xm,L->d ata[k].cj);}}int cr(SqList *L,DataType *xs,int i) //插入信息{int j;if(L->length==MaxSize){printf("没有!");return 0;}else if((iL->length)){printf("程序溢出,不符合");return 0;}else{for(j=L->length-1;j>=i;j--){strcpy(L->data[j+1].xh,L->data[j].xh); strcpy(L->data[j+1].xm,L->data[j].xm);L->data[j+1].cj=L->data[j].cj;}strcpy(L->data[i].xh,xs->xh);strcpy(L->data[i].xm,xs->xm);L->data[i].cj=xs->cj;L->length=L->length+1;}return 0;}int cz(SqList *L) //查找信息{char xh[40];char xm[40];int cj;int i=0,u;printf(" 1、按学号查询\n"); printf(" 1、按姓名查询\n"); printf(" 1、按成绩查询\n"); printf("请选择:");fflush(stdin);scanf("%d",&u);if (u==1){printf("请输入要查找学生的学号:");scanf("%s",xh);for(i=0;ilength;i++){篇二:单链表的实验报告辽宁工程技术大学上机实验报告篇三:单链表实验报告实验一线性表基本操作的编程实现--线性表在链表存储下的主要操作实现班级:T523-1 姓名:王娟学号:33完成日期:XX.04.04 地点:5502学时:2学时一、需求分析【实验目的】通过本次实验,对课堂上线性表的知识进行巩固,进一步熟悉线性表的链接存储及相应的基本操作;并熟练掌握VC++ 6.0操作平台,学会调试程序,以及编写电子实验报告【实验要求】编写线性表的基本操作,有构造线性表,线性表的遍历,插入,删除,查找,求表长等基本功能,在此基础上能够加入DOS下的图形界面以及学会文件的操作等功能,为以后的学习打下基础。
链表的合并实验报告
链表的合并实验报告文稿归稿存档编号:[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、实验目的∙熟练掌握线性表的链式存储结构定义及基本操作∙理解循环链表和双链表的特点和基本运算2、实验内容:建立单链表,完成链表(带表头结点)的基本操作:建立链表、插入、删除、查找、输出、求前驱、求后继、两个有序链表的合并操作。
其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。
1.问题描述:利用线性表的链式存储结构,设计一组输入数据(假定为一组整数),能够对单链表进行如下操作:∙初始化一个带表头结点的空链表;∙创建一个单链表是从无到有地建立起一个链表,即一个一个地输入各结点数据,并建立起前后相互链接的关系。
又分为逆位序(插在表头)输入n 个元素的值和正位序(插在表尾)输入n 个元素的值;∙插入结点可以根据给定位置进行插入(位置插入),也可以根据结点的值插入到已知的链表中(值插入),且保持结点的数据按原来的递增次序排列,形成有序链表。
∙删除结点可以根据给定位置进行删除(位置删除),也可以把链表中查找结点的值为搜索对象的结点全部删除(值删除);∙输出单链表的内容是将链表中各结点的数据依次显示,直到链表尾结点;∙求前驱结点是根据给定结点的值,在单链表中搜索其当前结点的后继结点值为给定的值,将当前结点返回;∙求后继结点是根据给定结点的值,在单链表中搜索其当前结点的值为给定的值,将后继结点返回;∙两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中,继续保持结点有序;编写主程序,实现对各不同的算法调用。
其它的操作算法描述略。
2.实现要求:对链表的各项操作一定要编写成为C(C++)语言函数,组合成模块化的形式,还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价。
∙“初始化算法”的操作结果:构造一个空的线性表L,产生头结点,并使L 指向此头结点;∙“建立链表算法”初始条件:空链存在;操作结果:选择逆位序或正位序的方法,建立一个单链表,并且返回完成的结果;∙“链表(位置)插入算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中第i 个位置之前插入元素e;∙“链表(位置)删除算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中,删除第i 个元素,并由e 返回其值;∙“输出算法”初始条件:链表L 已存在;操作结果:依次输出链表的各个结点的值;∙“求前驱算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱;∙“求后继算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继;∙“两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列;操作结果:归并La 和Lb 得到新的单链表。
将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
将两个升序链表合并为⼀个新的升序链表并返回。
新链表是通过拼接给定的两个链表的所有节点组成的。
我们可以⽤迭代的⽅法来实现上述算法。
当 l1 和 l2 都不是空链表时,判断 l1 和 l2 哪⼀个链表的头节点的值更⼩,将较⼩值的节点添加到结果⾥,当⼀个节点被添加到结果⾥之后,将对应链表中的节点向后移⼀位。
class Solution {
public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
ListNode prehead = new ListNode(-1); //哨兵,⽤于最后返回合并后的结果
ListNode minValNode = prehead;
while(l1 != null && l2 != null){
if(l1.val <= l2.val){
minValNode.next = l1;
l1 = l1.next;
}else{
minValNode.next = l2;
l2 = l2.next;
}
minValNode = minValNode.next;
}
minValNode.next = l1 == null?l2 : l1; //两链表长度不⼀,短链表的next先为空,则minValNode的next就是长链表剩下的
return prehead.next; //返回结果链表
}
}
当然还有更好的⽅法,请在评论区留⾔,如果有不懂或者错误的地⽅,也请指出,加以改正。
攻坚实验二 两个有序链表序列的交集
攻坚实验二两个有序链表序列的交集一、实验目的1.熟练掌握循环控制语句。
2.熟练掌握构造新链表方法。
3.熟练掌握链表的遍历查找操作与结点插入操作。
二、实验内容已知两个非降序链表序列S1和S2,设计函数构造出S1与S2的交集新链表S3。
三、实验要求1. 输入说明:输入分2行,分别在每行给出由若干个正整数构成的非降序序列,用-1表示序列的结尾(-1不属于这个序列)。
数字用空格间隔2.输出说明:在一行中输出两个输入序列的交集序列,数字间用空格分开,结尾不能有多余空格;若新链表为空,输出NULL。
四、实验分析(1)问题分析设序列S1与S2的长度分别为N1和N2。
求交集可从两个序列的列首开始比较,不断将相等的值移入新序列,并注意过程中不断更新下一次要比较的链表指针,需O(min(N1,N2))时间。
可以令结点指针P1指向S1的首结点,P2指向S2首结点,不断比较P1与P2所指结点的值:若两结点值相等,则创建新结点将这个值插入到新链表S3的末尾,并将P1与P2分别往前移(P=P->next);若不相等,将较小结点的对应结点指针往前移。
创建结点时,注意用malloc函数申请内存;由于每次总是插入S3末尾,可以用指针变量pRear指向S3尾结点,添加新结点时插入pRear结点之后并更新pRear。
如此反复直到某个链表遍历完,即P1或P2为空为止。
(2)实现要点使用带空头结点的链表结构,可以简化程序。
注意检查边界情况,例如当某个链表序列为空时的情况。
五、主要仪器及耗材计算机及VC6软件六、实验注意事项1.应分析源程序,并注意运行结果是否为预期结果。
2.注意大小写及英文字符(ASCII码)七、思考题1.如果允许利用和修改链表S1和S2,如何在不申请新内存的情况下,构造出其交集序列链表?。
有序顺序表的合并
成绩实验一实验题目:有序顺序表的合并一、实验目的掌握顺序表的基本操作理解并分析算法的时间复杂度二、实验内容实现两个有序(从小到大)顺序表合并成为一个有序顺序表,合并后的结果放在第一个顺序表中(假设这两个有序顺序表中没有相同的元素)。
三、设计与编码1、基本思想大体上的方法与“有序顺序表的插入”方法类似。
创建两个数组,实现两个有序顺序表。
需定义第二个表长length2,逐个将第二个顺序表中的数据与第一个数据表中的数据对比大小,并按大小顺序排列、合并,生成第三个表。
最后输出。
2、编码#include<iostream>using namespace std;const int MaxSize=200;class SeqList{ public:SeqList(int a[],int n);int Length();void Insert(int b[],int length2);void PrintList();private:int data[MaxSize];int length;};SeqList::SeqList(int a[],int n){int i;if(n>MaxSize)throw"参数非法";for(i=0;i<n;i++)data[i]=a[i];length=n;}int SeqList::Length(){return length;}void SeqList::Insert(int b[],int length2) { int j,h,i=0;for( j=0;j<length&&i<length2;++j){if(b[i]<data[j]){ for(h=length;h!=j;--h)data[h]=data[h-1];data[j]=b[i];++length;++i;}else if(j==length-1&&b[i]>data[length-1]) {data[length]=b[i];length++;++i;}}}void SeqList::PrintList(){for(int i=0;i<length;i++)cout<<data[i]<<" ";cout<<endl;}void main(){int a[6]={1,5,8,10,15,21};int b[3]={6,13,18};SeqList s(a,6);SeqList c(b,3);cout<<"合并前的顺序表A"<<endl;s.PrintList();cout<<"合并前的顺序表B"<<endl;c.PrintList();cout<<"合并后的顺序表C"<<endl;int x=c.Length();s.Insert(b,x);s.PrintList();}四、调试与运行1、调试时遇到的主要问题及解决括号、花括号未正确配对,出现混乱导致编译出错;第一次运行成功,由于数组输出语句为cout<<data[i]<<endl;界面如下:经调整数组输出语句为cout<<data[i]<<””;cout<<endl;2、运行结果(输入及输出,可以截取运行窗体的界面)五、实验心得写程序代码时务必认真。
数据结构线性表操作实验报告
《数据结构》实验报告实验题目:线性表的操作实验目的:1.掌握上机调试线性表的基本方法;2.掌握线性表的一些基本操作;实验内容:将两个有序链表合并为一个有序链表一、需求分析1.实验程序中先创建两个有序链表,演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后,由用户在键盘上输入两个链表中的相应数据。
2.将两个链表合并时可按数据从大到小或从小到大合并,用户根据提示可选择一种排序方式。
3.程序执行命令包括:(1)构造链表;(2)输入数据;(3)合并两个链表,根据用户需求选择一种排序方式;(4)将合并结果输出;(5)结束4.测试数据:链表1数据为:2,4,6,7,10链表2数据为:1,3,5,6,7,12按从小到达合并为:1,2,3,4,5,6,6,7,7,10,12;按从大到小合并为:12,10,7,7,6,6,5,4,3,2,1;二、概要设计1.基本操作Linklist creat ()操作结果:构造一个链表,并输入数据,返回头节点指针。
void print(Linklist head)初始条件:链表已存在;操作结果:将链表输出。
void MergeList_1(Linklist La,Linklist Lb)初始条件:有序线性链表La 和Lb 已存在;操作结果:将La 和Lb 两个链表按从小到大的顺序合并。
void MergeList_2(Linklist La,Linklist Lb)初始条件:有序线性链表La 和Lb 已存在;操作结果:将La 和Lb 两个链表按从大到小的顺序合并。
2.本程序包括四个模块:(1)主程序模块;(2)链表数据输入模块;(3)链表合并模块;(4)链表输出模块;三、详细设计1.元素类型,节点类型,指针类型主程序模块 数据输入 按从小到大合并两链表 按从大到小合并两链表 将新链表输出 将新链表输出typedef struct LNode //定义节点{int data;struct LNode *next;}LNode,* Linklist;2.每个模块的分析(1)主函数模块int main(){Linklist head1,head2;int i;printf("请输入链表1数据(由小到大,输入0表示输入结束):\n");head1=creat(); //创建链表1,将头结点指针返回为head1printf("请输入链表2数据(由小到大,输入0表示输入结束):\n");head2=creat();printf("请选择排序方式(输入1则从小到达合并,输入其它整数则按从大到小合并):");scanf("%d",&i); //创建链表2,将头结点指针返回为head2if(i==1) //选择两种排序方式,如果输入1,则合并后按从小到大输出;输入其它数,合成链表按从大到小输出{printf("按小到大将两表合并得:\n");MergeList1(head1,head2); //将创建好的两表的头结点地址head1,head2作为函数参数}else{ printf("按从大到小将两表合并得:\n");MergeList2(head1,head2); //将创建好的两表的头结点地址head1,head2作为函数参数}return 0;}(2)数据输入创建链表模块Linklist creat() //创建链表函数,并将创建链表的头结点指针返回{Linklist head,p,s;int z=1,x;head=(LNode *) malloc(sizeof(LNode));p=head;while(z){scanf("%d",&x);if(x!=0) //输入0表示链表数据输入结束{s=(LNode *)malloc(sizeof(LNode));s->data=x;p->next=s;s->next=NULL;p=s;}elsez=0;}return(head);}(3)合并链表模块,两个函数分别表示两种排序方式,将链表合并后直接在函数中调用链表输出函数void print(Linklist head)将链表输出void MergeList_1(Linklist La,Linklist Lb)//已知链表La和Lb元素都按从小到大排列,将La和Lb合并成新链表,其中元素也按从小到大排列{Linklist pa,pb,pc,Lc;pa = La->next; pb = Lb->next;Lc = pc = La; //把La的头节点作为新建链表Lc的头结点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; //插入剩余段print(Lc); //将链表Lc输出}void MergeList_2(Linklist La,Linklist Lb)//已知链表La和Lb的元素都按从小到大排列,合并La和Lb得到新链表,其中元素按照从大到小的顺序排列{Linklist pa,qa,pb,qb,Lc; //设指针qa,qb,分别作为pa,pb的前驱的指针pa=La->next;pb=Lb->next;Lc=La;Lc->next=NULL;while(pa&&pb){if(pa->data<=pb->data){qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}else{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}}while(pa) //如果pa不为空,则将La链的剩余段倒叙插入到头节点的后面{qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}while(pb) //如果pb不为空,则将Lb链的剩余段倒叙插入到头结点的后面{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}print(Lc); //将新合成的链表Lc输出}(4)链表输出模块,实现最终链表的输出void print(Linklist head) //链表输出函数,将链表输出{LNode *p;p=head->next;if(head!=NULL)do{printf("%d ",p->data);p=p->next;} while (p);printf("\n");四、程序使用说明及测试结果1.程序使用说明(1)本程序的运行环境为VC6.0;(2)进入演示程序后显示提示信息:请输入链表1数据(由小到大,输入0表示输入结束):按要求输入数据请输入链表2数据(由小到大,输入0表示输入结束):按要求输入数据请选择排序方式(输入1则从小到达合并,输入其它整数则按从大到小合并):输入数据选择合并方式2.测试结果对链表1输入数据2,4,6,7,10,0对链表2输入数据1,3,5,6,7,12,0输入数据选择排序方式:如果输入:1 输出结果为:1,2,3,4,5,6,6,7,7,10,12如果输入:3(整数非1)输出结果为:12,10,7,7,6,6,5,4,3,2,13.调试中遇到的错误分析第一次运行时有问题,看以看出它的排序方式是对的,但是输出是多出前面一个很大的数,可能是输出函数void print(Linklist head)有问题,检查程序:此处逻辑出错,直接将p指针指向head,然后就将p->data输出,因此第一个数是头指针head所对应节点的值,所以可将p=head;改为p=head->next;这样p就指向第一个节点。
合并两个有序数组 解题思路
合并两个有序数组解题思路
合并两个有序数组是一个常见的算法问题,通常有多种解决思路。
我将介绍其中一种常见的解题思路。
一种常见的解题思路是使用双指针法。
假设我们有两个有序数
组A和B,我们需要将它们合并成一个有序数组。
我们可以使用两
个指针i和j分别指向数组A和B的起始位置,然后比较A[i]和
B[j]的大小,将较小的元素放入新的数组中,然后将指向较小元素
的指针向后移动一位。
重复这个过程直到其中一个数组的元素全部
被放入新数组中,然后将剩余的数组直接拼接到新数组的末尾。
这种方法的时间复杂度是O(m+n),其中m和n分别是数组A和
B的长度。
这是因为我们只需要一次遍历就可以将两个数组合并成
一个有序数组。
除了双指针法之外,还可以使用其他方法比如直接合并后排序、使用额外的空间等。
每种方法都有其优缺点,选择合适的方法取决
于具体的场景和需求。
总的来说,合并两个有序数组是一个经典的算法问题,有多种
解决思路,选择合适的方法可以提高算法的效率和性能。
希望这个解题思路对你有所帮助。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告文件编码(008-TTIG-UTITD-GKBTT-PUUTI-WYTUI-8256)实验报告课程名称:数据结构与算法分析实验名称:链表的实现与应用实验日期:班级:数媒1401 姓名:范业嘉学号 08一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。
二、实验内容与要求⑴定义线性表的链式存储表示;⑵基于所设计的存储结构实现线性表的基本操作;⑶编写一个主程序对所实现的线性表进行测试;⑷线性表的应用:①设线性表L1和L2分别代表集合A和B,试设计算法求A和B的并集C,并用线性表L3代表集合C;②(选做)设线性表L1和L2中的数据元素为整数,且均已按值非递减有序排列,试设计算法对L1和L2进行合并,用线性表L3保存合并结果,要求L3中的数据元素也按值非递减有序排列。
⑸设计一个一元多项式计算器,要求能够:①输入并建立多项式;②输出多项式;③执行两个多项式相加;④执行两个多项式相减;⑤(选做)执行两个多项式相乘。
三、数据结构设计1.按所用指针的类型、个数、方法等的不同,又可分为:线性链表(单链表)静态链表循环链表双向链表双向循环链表2.用一组任意的存储单元存储线性表中数据元素,用指针来表示数据元素间的逻辑关系。
四、算法设计1.定义一个链表void creatlist(Linklist &L,int n){int i;Linklist p,s;L=(Linklist)malloc(sizeof(Lnode));p=L;L->next=NULL;for(i=0;i<n;i++){s=(Linklist)malloc(sizeof(Lnode));scanf("%d",&s->data);s->next=NULL;p->next=s; p=s;}}2.(1)两个链表的合并void Mergelist(Linklist &La,Linklist &Lb,Linklist &Lc) {Linklist 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=papa:pb;free(Lb);}(2)两个链表的并集Linklist unionlist(Linklist &La,Linklist &Lb){Linklist p1,p2,head,q,s;int flag;head=q=(Linklist)malloc(sizeof(Lnode));p1=La->next;while(p1){flag=0;p2=Lb->next;while(p2){if(p1->data==p2->data){flag=1;break;}p2=p2->next;}if(flag==0){s=(Linklist)malloc(sizeof(Lnode));s->data=p1->data;q->next=s;q=s;}p1=p1->next;}q->next=Lb->next;return head;}3.(1)一元多项式的加法List addpoly(List pa,List pb)3.六、心得体会(包括对于本次实验的小结,实验过程中碰到的问题等)1.首先书上给的链表输入是倒序的,写的时候想都没想就抄上去了,结果运行时发现问题,可是上网百度依然没有把问题解决,导致最后输出链表倒序的,并且链表的合并并集依旧是倒序的。
有序表的合并的标准实验报告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、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验目的及要求:
了解和掌握链表的特点;
掌握链表基本操作的实现;
掌握两个有序链表合并的算法
要求完成链表的初始化、插入、有序表合并、显示操作的实现。
实验设备环境及要求:
PC机一台,内存要求128M以上,VC++6.0集成开发环境。
实验内容与步骤:
1、在VC++6.0环境中新建一个工程和C++文件;
2、实现链表初始化、插入、有序合并算法,代码如下:
#include <stdio.h>
#include <malloc.h>
typedef int ElemType;
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
int InitList_L(LinkList &L){
L= (LinkList)malloc(sizeof(LNode));
L->next=NULL;
return 1;
}
int ListInsert_L(LinkList &L,int i,ElemType e){
LinkList p;
p=L;
int j=0;
while(p&&j<i-1){
p=p->next;
++j;
}
if(!p||j>i-1) return 0;
LinkList s=(LinkList)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return 1;
}
void Disp_L(LinkList L){
LinkList p=L->next;
if(!p) printf("此链表为空!");
while(p){
printf("%d",p->data);
p=p->next;
}
printf("\n");
}
void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc){ LinkList pa=La->next;
LinkList pb=Lb->next;
LinkList pc=Lc=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);
}
void main(){
LinkList La,Lb,Lc;
InitList_L(La);
InitList_L(Lb);
InitList_L(Lc);
ListInsert_L(La,1,2);
ListInsert_L(La,2,3);
ListInsert_L(La,3,5);
Disp_L(La);
ListInsert_L(Lb,1,1);
ListInsert_L(Lb,2,4);
ListInsert_L(Lb,3,6);
ListInsert_L(Lb,4,7);
Disp_L(Lb);
MergeList_L(La,Lb,Lc);
printf("合并之后的链表为:\n");
Disp_L(Lc);
}实验指导与数据处理:
实验结果:235
1467
合并之后的链表为:
1234567
分析讨论:
本次实验通过对链表基本操作和两个有序链表合并算法的实现,加深了对链表特点的理解,并且熟悉了VC++6.0集成环境,虽然在调试过程中遇到一些问题,但经分析后达到了预期的结果。