实验二_线性表的基本操作

合集下载

数据结构实验报告实验总结

数据结构实验报告实验总结

数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。

通过实验,我对这些数据结构的特点、操作和应用有了更深入的了解。

下面对每一部分实验进行总结。

实验一:线性表的基本操作线性表是一种常见的数据结构,本实验要求实现线性表的基本操作,包括插入、删除、查找、遍历等。

在实验过程中,我对线性表的结构和实现方式有了更清晰的认识,掌握了用数组和链表两种方式实现线性表的方法。

实验二:栈的应用栈是一种后进先出(LIFO)的数据结构,本实验要求利用栈实现简单的括号匹配和后缀表达式计算。

通过实验,我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算,有效地解决了对应的问题。

实验三:队列的应用队列是一种先进先出(FIFO)的数据结构,本实验要求利用队列实现银行排队和迷宫求解。

通过实验,我对队列的应用有了更加深入的了解,了解到队列可以解决需要按顺序处理的问题,如排队和迷宫求解等。

实验四:链表的应用链表是一种常用的数据结构,本实验要求利用链表实现学生信息管理系统。

通过实验,我对链表的应用有了更深入的了解,了解到链表可以方便地实现对于数据的插入、删除和修改等操作,并且可以动态地调整链表的长度,适应不同的需求。

通过本次实验,我掌握了线性表、栈、队列和链表的基本操作,并了解了它们的特点和应用方式。

同时,通过实际编程的过程,我对于数据结构的实现方式和效果有了更直观的认识,也锻炼了自己的编程能力和解决问题的能力。

在实验过程中,我遇到了一些问题,如程序逻辑错误和内存泄漏等,但通过调试和修改,最终成功解决了这些问题,对自己的能力也有了更多的信心。

通过本次实验,我深刻体会到了理论与实践的结合的重要性,也对于数据结构这门课程有了更加深入的理解。

总之,本次数据结构实验给予了我很多有益的启发和收获,对于数据结构的概念、特点和应用有了更深入的理解。

在以后的学习中,我会继续加强对数据结构的学习和研究,不断提高自己的编程能力和解决问题的能力。

线性表的存储结构定义及基本操作(实验报告)

线性表的存储结构定义及基本操作(实验报告)

线性表的存储结构定义及基本操作(实验报告)线性表的存储结构定义及基本操作一掌握线性表的逻辑特征掌握线性表顺序存储结构的特点熟练掌握顺序表的基本运算熟练掌握线性表的链式存储结构定义及基本操作理解循环链表和双链表的特点和基本运算加深对顺序存储数据结构的理解和链式存储数据结构的理解逐步培养解决实际问题的编程能力二一基本实验内容顺序表建立顺序表完成顺序表的基本操作初始化插入删除逆转输出销毁置空表求表长查找元素判线性表是否为空1 问题描述利用顺序表设计一组输入数据假定为一组整数能够对顺序表进行如下操作创建一个新的顺序表实现动态空间分配的初始化根据顺序表结点的位置插入一个新结点位置插入也可以根据给定的值进行插入值插入形成有序顺序表根据顺序表结点的位置删除一个结点位置删除也可以根据给定的值删除对应的第一个结点或者删除指定值的所有结点值删除利用最少的空间实现顺序表元素的逆转实现顺序表的各个元素的输出彻底销毁顺序线性表回收所分配的空间对顺序线性表的所有元素删除置为空表返回其数据元素个数按序号查找根据顺序表的特点可以随机存取直接可以定位于第 i 个结点查找该元素的值对查找结果进行返回按值查找根据给定数据元素的值只能顺序比较查找该元素的位置对查找结果进行返回判断顺序表中是否有元素存在对判断结果进行返回编写主程序实现对各不同的算法调用2 实现要求对顺序表的各项操作一定要编写成为C C 语言函数组合成模块化的形式每个算法的实现要从时间复杂度和空间复杂度上进行评价初始化算法的操作结果构造一个空的顺序线性表对顺序表的空间进行动态管理实现动态分配回收和增加存储空间位置插入算法的初始条件顺序线性表L已存在给定的元素位置为i且1≤i ≤ListLength L 1操作结果在L中第i个位置之前插入新的数据元素eL的长度加1位置删除算法的初始条件顺序线性表L已存在1≤i≤ListLength L 操作结果删除L的第i个数据元素并用e返回其值L的长度减1逆转算法的初始条件顺序线性表L已存在操作结果依次对L的每个数据元素进行交换为了使用最少的额外空间对顺序表的元素进行交换输出算法的初始条件顺序线性表L已存在操作结果依次对L的每个数据元素进行输出销毁算法初始条件顺序线性表L已存在操作结果销毁顺序线性表 L置空表算法初始条件顺序线性表L已存在操作结果将L重置为空表求表长算法初始条件顺序线性表L已存在操作结果返回L中数据元素个数按序号查找算法初始条件顺序线性表 L 已存在元素位置为 i且 1≤i≤ListLength L 操作结果返回 L 中第 i 个数据元素的值按值查找算法初始条件顺序线性表 L 已存在元素值为 e 操作结果返回 L 中数据元素值为 e 的元素位置判表空算法初始条件顺序线性表 L 已存在操作结果若 L 为空表则返回 TRUE否则返回 FALSE分析修改输入数据预期输出并验证输出的结果加深对有关算法的理解二基本实验内容单链表建立单链表完成链表带表头结点的基本操作建立链表插入删除查找输出求前驱求后继两个有序链表的合并操作其他基本操作还有销毁链表将链表置为空表求链表的长度获取某位置结点的内容搜索结点1 问题描述利用线性表的链式存储结构设计一组输入数据假定为一组整数能够对单链表进行如下操作初始化一个带表头结点的空链表创建一个单链表是从无到有地建立起一个链表即一个一个地输入各结点数据并建立起前后相互链接的关系又分为逆位序插在表头输入 n 个元素的值和正位序插在表尾输入 n 个元素的值插入结点可以根据给定位置进行插入位置插入也可以根据结点的值插入到已知的链表中值插入且保持结点的数据按原来的递增次序排列形成有序链表删除结点可以根据给定位置进行删除位置删除也可以把链表中查找结点的值为搜索对象的结点全部删除值删除输出单链表的内容是将链表中各结点的数据依次显示直到链表尾结点编写主程序实现对各不同的算法调用其它的操作算法描述略2 实现要求对链表的各项操作一定要编写成为 C C 语言函数组合成模块化的形式还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价初始化算法的操作结果构造一个空的线性表 L产生头结点并使 L 指向此头结点建立链表算法初始条件空链存在操作结果选择逆位序或正位序的方法建立一个单链表并且返回完成的结果链表位置插入算法初始条件已知单链表 L 存在操作结果在带头结点的单链线性表 L 中第 i 个位置之前插入元素 e链表位置删除算法初始条件已知单链表 L 存在操作结果在带头结点的单链线性表 L 中删除第 i 个元素并由 e 返回其值输出算法初始条件链表 L 已存在操作结果依次输出链表的各个结点的值三扩展实验内容顺序表查前驱元素查后继元素顺序表合并等1 问题描述根据给定元素的值求出前驱元素根据给定元素的值求出后继元素对已建好的两个顺序表进行合并操作若原线性表中元素非递减有序排列要求合并后的结果还是有序有序合并对于原顺序表中元素无序排列的合并只是完成 A A∪B 无序合并要求同样的数据元素只出现一次修改主程序实现对各不同的算法调用2 实现要求查前驱元素算法初始条件顺序线性表 L 已存在操作结果若数据元素存在且不是第一个则返回前驱否则操作失败查后继元素算法初始条件顺序线性表 L 已存在操作结果若数据元素存在且不是最后一个则返回后继否则操作失败无序合并算法的初始条件已知线性表 La 和 Lb操作结果将所有在线性表 Lb 中但不在 La 中的数据元素插入到 La 中有序合并算法的初始条件已知线性表 La 和 Lb 中的数据元素按值非递减排列操作结果归并 La 和 Lb 得到新的线性表 LcLc 的数据元素也按值非递减排列四扩展实验内容链表1 问题描述求前驱结点是根据给定结点的值在单链表中搜索其当前结点的后继结点值为给定的值将当前结点返回求后继结点是根据给定结点的值在单链表中搜索其当前结点的值为给定的值将后继结点返回两个有序链表的合并是分别将两个单链表的结点依次插入到第 3 个单链表中继续保持结点有序2 实现要求求前驱算法初始条件线性表 L 已存在操作结果若 cur_e 是 L 的数据元素且不是第一个则用 pre_e 返回它的前驱求后继算法初始条件线性表 L 已存在操作结果若 cur_e 是 L 的数据元素且不是最后一个则用 next_e 返回它的后继两个有序链表的合并算法初始条件线性表单链线性表 La 和 Lb 的元素按值非递减排列操作结果归并 La 和 Lb 得到新的单链表三实验环境和实验步骤实验环境利用CodeBlocks1005集成开发环境进行本实验的操作实验步骤――顺序表的定义与操作1启动CodeBlocks1052按Create a new project 通过file 按CC source选择c然后GO储存文件D\c语言\顺序表c3进行编代码4编好之后搞ctrlshiftF9进行编译然后按ctrlF105如果编译出问题然后进行调试实验步骤――链表的定义与操作1启动CodeBlocks1052按Create a new project 通过file 按CC source选择c然后GO储存文件D\c语言\单链表c3进行编代码4编好之后搞ctrlshiftF9进行编译然后按ctrlF105如果编译出问题然后进行调试四 includeinclude "stdlibh"includedefine LIST_INIT_SIZE 100define ok 1define ERROR 0define OVERFLOW -1define Num 3typedef int DataTypetypedef int Statustypedef structDataType elemint Lengthint ListsizeSeqListSeqList LStatus InitSeqList SeqList LL- elem Da。

北邮数据结构实验报告

北邮数据结构实验报告

北邮数据结构实验报告摘要:本报告基于北邮数据结构实验,通过实际操作和实验结果的分析,总结和讨论了各实验的目的、实验过程、实验结果以及相关的问题和解决方法。

本报告旨在帮助读者了解数据结构实验的基本原理和应用,并为今后的学习和研究提供参考。

1. 实验一:线性表的操作1.1 实验目的本实验旨在掌握线性表的基本操作以及对应的算法实现,包括插入、删除、查找、修改等。

1.2 实验过程我们使用C++语言编写了线性表的相关算法,并在实际编程环境下进行了测试。

通过插入元素、删除元素、查找元素和修改元素的操作,验证了算法的正确性和效率。

1.3 实验结果经过测试,我们发现线性表的插入和删除操作的时间复杂度为O(n),查找操作的时间复杂度为O(n),修改操作的时间复杂度为O(1)。

这些结果与预期相符,并反映了线性表的基本特性。

1.4 问题与解决方法在实验过程中,我们遇到了一些问题,例如插入操作的边界条件判断、删除操作时的内存释放等。

通过仔细分析问题,我们优化了算法的实现,并解决了这些问题。

2. 实验二:栈和队列的应用2.1 实验目的本实验旨在掌握栈和队列的基本原理、操作和应用,并进行实际编程实现。

2.2 实验过程我们使用C++语言编写了栈和队列的相关算法,并在实际编程环境下进行了测试。

通过栈的应用实现表达式求值和逆波兰表达式的计算,以及队列的应用实现图的广度优先遍历,验证了算法的正确性和效率。

2.3 实验结果经过测试,我们发现栈的应用可以实现表达式的求值和逆波兰表达式的计算,队列的应用可以实现图的广度优先遍历。

这些结果证明了栈和队列在实际应用中的重要性和有效性。

2.4 问题与解决方法在实验过程中,我们遇到了一些问题,例如中缀表达式转后缀表达式的算法设计、表达式求值的优化等。

通过查阅资料和与同学的讨论,我们解决了这些问题,并完善了算法的实现。

3. 实验三:串的模式匹配3.1 实验目的本实验旨在掌握串的基本操作和模式匹配算法,并进行实际编程实现。

线性表的存储结构定义及基本操作

线性表的存储结构定义及基本操作

一、实验目的:. 掌握线性表的逻辑特征. 掌握线性表顺序存储结构的特点,熟练掌握顺序表的基本运算. 熟练掌握线性表的链式存储结构定义及基本操作. 理解循环链表和双链表的特点和基本运算. 加深对顺序存储数据结构的理解和链式存储数据结构的理解,逐步培养解决实际问题的编程能力二、实验内容:(一)基本实验内容(顺序表):建立顺序表,完成顺序表的基本操作:初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空;1.问题描述:利用顺序表,设计一组输入数据(假定为一组整数),能够对顺序表进行如下操作:. 创建一个新的顺序表,实现动态空间分配的初始化;. 根据顺序表结点的位置插入一个新结点(位置插入),也可以根据给定的值进行插入(值插入),形成有序顺序表;. 根据顺序表结点的位置删除一个结点(位置删除),也可以根据给定的值删除对应的第一个结点,或者删除指定值的所有结点(值删除);. 利用最少的空间实现顺序表元素的逆转;. 实现顺序表的各个元素的输出;. 彻底销毁顺序线性表,回收所分配的空间;. 对顺序线性表的所有元素删除,置为空表;. 返回其数据元素个数;. 按序号查找,根据顺序表的特点,可以随机存取,直接可以定位于第i 个结点,查找该元素的值,对查找结果进行返回;. 按值查找,根据给定数据元素的值,只能顺序比较,查找该元素的位置,对查找结果进行返回;. 判断顺序表中是否有元素存在,对判断结果进行返回;. 编写主程序,实现对各不同的算法调用。

2.实现要求:对顺序表的各项操作一定要编写成为C(C++)语言函数,组合成模块化的形式,每个算法的实现要从时间复杂度和空间复杂度上进行评价;. “初始化算法”的操作结果:构造一个空的顺序线性表。

对顺序表的空间进行动态管理,实现动态分配、回收和增加存储空间;. “位置插入算法”的初始条件:顺序线性表L 已存在,给定的元素位置为i,且1≤i≤ListLength(L)+1 ;操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1;. “位置删除算法”的初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) ;操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 ;. “逆转算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行交换,为了使用最少的额外空间,对顺序表的元素进行交换;. “输出算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行输出;. “销毁算法”初始条件:顺序线性表L 已存在;操作结果:销毁顺序线性表L;. “置空表算法”初始条件:顺序线性表L 已存在;操作结果:将L 重置为空表;. “求表长算法”初始条件:顺序线性表L 已存在;操作结果:返回L 中数据元素个数;. “按序号查找算法”初始条件:顺序线性表L 已存在,元素位置为i,且1≤i≤ListLength(L)操作结果:返回L 中第i 个数据元素的值. “按值查找算法”初始条件:顺序线性表L 已存在,元素值为e;操作结果:返回L 中数据元素值为e 的元素位置;. “判表空算法”初始条件:顺序线性表L 已存在;操作结果:若L 为空表,则返回TRUE,否则返回FALSE;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

C语言数据结构线性表的基本操作实验报告

C语言数据结构线性表的基本操作实验报告

实验一线性表的基本操作一、实验目的与基本要求1.掌握数据结构中的一些基本概念。

数据、数据项、数据元素、数据类型和数据结构,以及它们之间的关系。

2.了解数据的逻辑结构和数据的存储结构之间的区别与联系;数据的运算与数据的逻辑结构的关系。

3.掌握顺序表和链表的基本操作:插入、删除、查找以及表的合并等运算。

4.掌握运用C语言上机调试线性表的基本方法。

二、实验条件1.硬件:一台微机2.软件:操作系统和C语言系统三、实验方法确定存储结构后,上机调试实现线性表的基本运算。

四、实验内容1.建立顺序表,基本操作包括:初始化,建立一个顺序存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。

2.建立单链表,基本操作包括:初始化,建立一个链式存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。

3.假设有两个按数据元素值非递减有序排列的线性表A和B,均以顺序表作为存储结构。

编写算法将A表和B表归并成一个按元素值非递增有序(允许值相同)排列的线性表C。

(可以利用将B中元素插入A中,或新建C表)4.假设有两个按数据元素值非递减有序排列的线性表A和B,均以单链表作为存储结构。

编写算法将A表和B表归并成一个按元素值递减有序(即非递增有序,允许值相同)排列的线性表C。

五、附源程序及算法程序流程图1.源程序(1)源程序(实验要求1和3)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct arr{int * elem;int length;int listsize;}Sqlist;void menu(); //菜单void InitList(Sqlist *p); // 创建线性表void ShowList(Sqlist *p); // 输出顺序线性表void ListDelete(Sqlist *p,int i,int &e); // 在顺序线性表中删除第i个元素,并用e返回其值void ListInsert(Sqlist *p); // 在顺序线性表中第i个元素前插入新元素evoid ListEmpty(Sqlist *p); // 判断L是否为空表void GetList(Sqlist *p,int i,int &e); // 用e返回L中第i个数据元素的值void ListInsert(Sqlist *p,int i,int e);bool compare(int a,int b);void LocateElem(Sqlist *L,int e); // 在顺序线性表L中查找第1个值与e满足compare()d元素的位序void MergeList_L(Sqlist *La,Sqlist *Lb); // 归并void main(){Sqlist La;Sqlist Lb;int n,m,x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:InitList(&La);break;case 2:ListEmpty(&La);break;case 3:printf("请输入插入的位序:\n");scanf("%d",&m);printf("请出入要插入的数:\n");scanf("%d",&x);ListInsert(&La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(&La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(&La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(&La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(&La);break;case 8:InitList(&Lb);break;case 9:MergeList_L(&La,&Lb);printf("归并成功!");break;}menu();scanf("%d",&n);}}/*菜单*/void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断La是否为空表\n\n");printf(" 3.插入元素(La)\n\n");printf(" 4.删除元素(La)\n\n");printf(" 5.定位元素(La)\n\n");printf(" 6.取元素(La)\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并为一个线性表La\n\n");printf("********************\n\n");}/*创建顺序线性表L*/void InitList(Sqlist *L){int n;int i=0;L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(NULL==L->elem)printf("储存分配失败!\n");else{L->length=0;L->listsize=LIST_INIT_SIZE;printf("输入顺序表a:\n");scanf("%d",&n);while(n){L->elem[i]=n;i++;L->length++;L->listsize=L->listsize-4;scanf("%d",&n);}}}/*输出顺序线性表*/void ShowList(Sqlist *p){int i;if(0==p->length)printf("数组为空!\n");elsefor(i=0;i<p->length;i++)printf("%d ",p->elem[i]);printf("\n");}/*判断L是否为空表*/void ListEmpty(Sqlist *p)if(0==p->length)printf("L是空表!\n");elseprintf("L不是空表!\n");}/*在顺序线性表中第i个元素前插入新元素e */void ListInsert(Sqlist *p,int i,int e){int *newbase;int *q1;int *q2;while(i<1||i>p->length+1){printf("您输入的i超出范围!\n请重新输入要插入的位置\n:");scanf("%d",&i);}if(p->length>=p->listsize){newbase=(int *)realloc(p->elem,(p->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);else{p->elem=newbase;p->listsize+=LISTINCREMENT;}}q1=&(p->elem[i-1]);for(q2=&(p->elem[p->length-1]);q2>=q1;--q2)*(q2+1)=*q2;*q1=e;++p->length;}/*/在顺序线性表中删除第i个元素,并用e返回其值*/void ListDelete(Sqlist *p,int i,int &e){int *q1,*q2;while(i<1||i>p->length){printf("您输入的i超出范围!请重新输入:");scanf("%d",&i);}q1=&(p->elem[i-1]);e=*q1;q2=p->elem+p->length-1;for(++q1;q1<=q2;++q1)*(q1-1)=*q1;--p->length;}/*对比a与b相等*/bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}/*在顺序线性表L中查找第1个值与e满足compare()d元素的位序*/ void LocateElem(Sqlist *L,int e){int i=1;int *p;p=L->elem;while(i<=L->length && !compare(*p++,e))++i;if(i<=L->length)printf("第1个与e相等的元素的位序为%d\n",i);elseprintf("没有该元素!\n");}/*用e返回L中第i个数据元素的值*/void GetList(Sqlist *p,int i,int &e){Sqlist *p1;p1=p;e=p1->elem[i-1];}/* 已知顺序线性表La和Lb是元素按值非递减排列*//* 把La和Lb归并到La上,La的元素也是按值非递减*/void MergeList_L(Sqlist *La,Sqlist *Lb){int i=0,j=0,k,t;int *newbase;Sqlist *pa,*pb;pa=La;pb=Lb;while(i<pa->length && j<pb->length){if(pa->elem[i] >= pb->elem[j]){if(pa->listsize==0){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(k=pa->length-1; k>=i; k--)pa->elem[k+1]=pa->elem[k];pa->length++;pa->elem[i]=pb->elem[j];i++;j++;}elsei++;}while(j<pb->length){if( pa->listsize < pb->length-j ){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(j;j<pb->length;j++,i++){pa->elem[i]=pb->elem[j];pa->length++;}}for(i=0;i<pa->length/2;i++){t=pa->elem[i];pa->elem[i]=pa->elem[pa->length-i-1];pa->elem[pa->length-i-1]=t;}}(2)源程序(实验要求2和4)#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;void menu();LinkList InitList();void ShowList(LinkList L);void ListDelete(LinkList L,int i,int &e);void ListEmpty(LinkList L);void GetList(LinkList L,int i,int &e);void ListInsert(LinkList L,int i,int e);bool compare(int a,int b);void LocateElem(LinkList L,int e);LinkList MergeList_L(LinkList La,LinkList Lb);int total=0;void main(){LinkList La;LinkList Lb;La=(LinkList)malloc(sizeof(struct LNode));La->next=NULL;Lb=(LinkList)malloc(sizeof(struct LNode));Lb->next=NULL;int n;int m;int x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:La->next=InitList();break;case 2:ListEmpty(La);break;case 3:printf("请输入要插入到第几个节点前:\n");scanf("%d",&m);printf("请输入插入的数据:\n");scanf("%d",&x);ListInsert(La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(La);break;case 8:Lb->next=InitList();break;case 9:La=MergeList_L(La,Lb);printf("归并成功\n");break;}menu();scanf("%d",&n);}}void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断是否为空表\n\n");printf(" 3.插入元素\n\n");printf(" 4.删除元素\n\n");printf(" 5.定位元素\n\n");printf(" 6.取元素\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并两线性表\n\n");printf("********************\n\n");}// 创建链式线性表LLinkList InitList(){int count=0;LinkList pHead=NULL;LinkList pEnd,pNew;pEnd=pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);while(pNew->data){count++;if(count==1){pNew->next=pHead;pEnd=pNew;pHead=pNew;}else{pNew->next=NULL;pEnd->next=pNew;pEnd=pNew;}pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);}free(pNew);total=total+count;return pHead;}// 判断L是否为空表void ListEmpty(LinkList L){if(NULL==L->next)printf("此表为空表!\n");elseprintf("此表不为空表!\n");}// 在链式线性表中第i个元素前插入新元素e void ListInsert(LinkList L,int i,int e){LinkList p;LinkList s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("不存在您要找的节点!\n");else{s=(LinkList)malloc(sizeof(int));s->data=e;s->next=p->next;p->next=s;printf("插入节点成功!\n");}}// 输出链式线性表void ShowList(LinkList L){LinkList p;p=L->next;if(p==NULL)printf("此表为空表!\n");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");}// 在链式线性表中删除第i个元素,并用e返回其值void ListDelete(LinkList L,int i,int &e){LinkList p;LinkList q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)printf("没有找到要删除的位置!");else{q=p->next;p->next=q->next;e=q->data;free(q);}}// 用e返回L中第i个数据元素的值void GetList(LinkList L,int i,int &e){LinkList p;p=L->next;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p)||j>i-1)printf("没有找到要查找的位置!");elsee=p->data;}// 对比a与b相等bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}// 在链式线性表L中查找第1个值与e满足compare()d元素的位序void LocateElem(LinkList L,int e){int i=0;LinkList p;p=L;while(p->next && !compare(p->data,e)){p=p->next;i++;}if(NULL==p->next){if(0==compare(p->data,e))printf("没有该元素!\n");elseprintf("第1个与e相等的元素的位序为%d\n",i);}elseif(compare(p->data,e))printf("没有该元素!\n");}LinkList MergeList_L(LinkList La,LinkList Lb){int i,j,k;LinkList pa_1,pb_1,pa_2,pb_2,pc,pd;pa_1=La->next;pc=pa_2=La;pb_1=pb_2=Lb->next;if(pa_1->data > pb_1->data){pc=pa_2=Lb;pa_1=Lb->next;pb_1=pb_2=La->next;}while(pa_1 && pb_1){if(pa_1->data >= pb_1->data){pa_2->next=pb_1;pb_2=pb_1->next;pb_1->next=pa_1;pb_1=pb_2;pa_2=pa_2->next;}else{pa_1=pa_1->next;pa_2=pa_2->next;}}if(pb_1)pa_2->next=pb_1;pd=(LinkList)malloc(sizeof(struct LNode));pd->next=NULL;pa_2=pd;k=total;for(i=0;i<total;i++){pa_1=pc->next;for(j=1;j<k;j++)pa_1=pa_1->next;pb_1=(LinkList)malloc(sizeof(struct LNode));pa_2->next=pb_1;pa_2=pa_2->next;pa_2->data=pa_1->data;k--;}pa_2->next=NULL;return pd;}2.流程图(实验要求1和3)图1 主函数流程图图2创建线性表La流程图图3判断La是否为空表流程图图4 插入元素(La)流程图图5删除元素(La)流程图图6定位元素(La)流程图图7取元素(La)流程图图8输出线性表流程图图9输出线性表流程图流程图(实验要求2和4)图10主函数流程图图11创建线性表La流程图图12判断是否为空表流程图图13插入元素流程图图14删除元素流程图图15定位元素流程图图图16取元素流程图图17创建Lb流程图图18归并两表流程图六、运行结果1. (实验要求1和3)点击运行,首先出现的是菜单界面,选择菜单选项进行操作,如图所示。

数据结构--实验报告 线性表的基本操作

数据结构--实验报告 线性表的基本操作

数据结构..实验报告线性表的基本操作数据结构实验报告线性表的基本操作1.引言本实验报告旨在介绍线性表的基本操作。

线性表是一种常见的数据结构,它是一组有限元素的有序集合,其中每个元素之间存在一个特定的顺序关系。

线性表的操作包括插入、删除、查找等,这些操作对于有效地管理和利用数据非常重要。

2.实验目的本实验的目的是通过实践理解线性表的基本操作,包括初始化、插入、删除、查找等。

通过编写相应的代码,加深对线性表的理解,并掌握相应的编程技巧。

3.实验内容3.1 初始化线性表初始化线性表是指创建一个空的线性表,为后续的操作做准备。

初始化线性表的方法有多种,如顺序表和链表等。

下面以顺序表为例进行说明。

顺序表的初始化包括定义表头指针和设置表的长度等操作。

3.2 插入元素插入元素是指将一个新的元素插入到线性表的指定位置。

插入元素有两种情况:插入到表的开头和插入到表的中间。

插入元素的操作包括移动其他元素的位置以腾出空间,并将新的元素插入到指定位置。

3.3 删除元素删除元素是指将线性表中的某个元素删除。

删除元素有两种情况:删除表的开头元素和删除表的中间元素。

删除元素的操作包括将被删除元素的前一个元素与后一个元素进行连接,断开被删除元素与表的联系。

3.4 查找元素查找元素是指在线性表中寻找指定的元素。

查找元素的方法有多种,如遍历线性表、二分查找等。

查找元素的操作包括比较目标元素与线性表中的元素进行匹配,直到找到目标元素或遍历完整个线性表。

4.实验步骤4.1 初始化线性表根据线性表的类型选择相应的初始化方法,如创建一个空的顺序表并设置表的长度。

4.2 插入元素输入要插入的元素值和插入的位置,判断插入的位置是否合法。

如果合法,移动其他元素的位置以腾出空间,将新的元素插入到指定位置。

如果不合法,输出插入位置非法的提示信息。

4.3 删除元素输入要删除的元素值,判断元素是否在线性表中。

如果在,则找到目标元素的前一个元素和后一个元素,进行连接删除操作。

数据结构--实验报告 线性表的基本操作

数据结构--实验报告 线性表的基本操作

数据结构--实验报告线性表的基本操作数据结构实验报告[引言]在本次实验中,我们将学习线性表的基本操作,包括插入、删除、查找等。

通过实践操作,加深对线性表的理解和掌握。

[实验目的]1.学习线性表的基本概念和操作。

2.熟悉线性表的插入、删除和查找等基本操作。

3.掌握线性表的实现方式及其相应的算法。

[实验内容]1.线性表的定义与表示1.1 线性表的定义1.2 线性表的顺序存储结构1.3 线性表的链式存储结构2.线性表的基本操作2.1初始化线性表2.2判断线性表是否为空2.3 插入操作2.3.1 在指定位置插入元素2.3.2 在表尾插入元素2.4 删除操作2.4.1 删除指定位置的元素2.4.2 删除指定值的元素2.5 查找操作2.5.1 按位置查找元素2.5.2 按值查找元素2.6 修改操作2.6.1修改指定位置的元素 2.6.2 修改指定值的元素2.7 清空线性表2.8 销毁线性表[实验步骤]1.初始化线性表1.1 创建一个空的线性表对象1.2 初始化线性表的容量和长度2.插入操作2.1在指定位置插入元素2.1.1 检查插入位置的合法性2.1.2 将插入位置后的元素依次后移2.1.3在指定位置插入新元素2.2 在表尾插入元素2.2.1 将表尾指针后移2.2.2 在表尾插入新元素3.删除操作3.1 删除指定位置的元素3.1.1 检查删除位置的合法性3.1.2 将删除位置后的元素依次前移3.1.3 修改线性表的长度3.2 删除指定值的元素3.2.1 查找指定值的元素位置3.2.2调用删除指定位置的元素操作4.查找操作4.1 按位置查找元素4.1.1 检查查找位置的合法性4.1.2 返回指定位置的元素4.2 按值查找元素4.2.1 从头到尾依次查找元素4.2.2 返回第一个匹配到的元素5.修改操作5.1修改指定位置的元素5.1.1 检查修改位置的合法性5.1.2修改指定位置的元素值5.2修改指定值的元素5.2.1 查找指定值的元素位置5.2.2调用修改指定位置的元素操作6.清空线性表6.1 设置线性表长度为07.销毁线性表7.1 释放线性表的内存空间[实验结果]使用线性表进行各种基本操作的测试,并记录操作的结果和运行时间。

线性表基本操作的编程实现

线性表基本操作的编程实现

实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求:线性表基本操作的编程实现(2学时,验证型),掌握线性表的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、逆序、排序等操作,存储结构要求是链表存储结构(顺序存储结构建议作为课外实验完成),可以依次完成主要功能来体现功能的正确性,用菜单进行管理完成大部分功能,要求可以重复运行。

还鼓励学生利用基本操作进行一些更实际的应用型程序设计。

【实验性质】验证性实验(学时数:2H)【实验内容】1.线性表的链表存储,实现数据插入、删除运算。

为了体现功能的正常性,同时要编制数据输入函数和遍历函数,数据输入最好同时提供计算机自动产生数据。

2.其他建议改进的功能或细节:存储结构修改为循环链表、双向链表、循环双向链表等。

原始数据从文本文件读入。

结果存入文本文件【注意事项】1.开发语言:使用C++,不能使用C。

至于是否使用对象,初期可以不用,但是建议尽量尽快使用对象。

2.可以自己增加其他功能。

3.如果是自己开发的,请在程序界面上注明 ***原创。

如果是参考他人或改编他人的,则注明:*** 参考他人版。

希望大家诚实对待自己的努力。

如果有小组,版权页上写上全组人员。

4.在实验报告中也应该如实写出哪些程序功能是自己编的,哪些是参考别人的。

5.初始成绩全部学生都是不及格,然后逐步通过提交更好的版本来刷新成绩。

实验当日仅仅是不及格变为及格。

之后通过班长全班学生提交源代码,为了方便,建议把程序做成一个cpp。

之后在实验后的三天时间内提交实验报告。

过时不候。

结合实验当时的检测,实验后源代码的检测,实验报告的书写给出当次的成绩。

分为五级制。

程序提交在实验之后的三天里可以刷新。

但是一般不应该超过二次。

提交的程序必须要语法正确的。

目前由于老师的审查平台是c++6.0,所以为了统一起见,不接受其他平台的开发系统。

程序名一律类似为:T423-2-17-翁靖凯-链表实验程序.cpp所有信息之间为中横线。

线性表的基本操作

线性表的基本操作

实验一线性表的基本操作一、实验目的学习掌握线性表的顺序存储结构、链式存储结构。

设计顺序表的创建、插入、删除等基本操作,设计单链表的建立、插入、删除等基本操作。

二、实验内容1.顺序表的实践(1)顺序表的创建:基于顺序表的动态分配存储结构,创建一个顺序表S,初始状态S=(1,2,3,4,5)。

(2)顺序表的遍历:依次输出顺序表的每个数据元素。

(3)顺序表的插入:在顺序表S=(1,2,3,4,5)的数据元素4和5之间插入一个值为9的数据元素。

(4)顺序表的删除:顺序表S=(1,2,3,4,9,5)中删除指定位置(i=3)的数据元素3。

(5)顺序表的按值查找:查找顺序表S中第1个值等于4的数据元素位序。

(6)顺序表的清空:释放顺序表的存储空间。

2.单链表的实践(1)单链表的创建:创建一个包括头结点和4个元素结点的单链表L=(5,4,2,1)。

(2)单链表的遍历:依次输出顺序表的每个数据元素。

(3)单链表的取值:输出单链表中第i个(i=2)数据元素的值。

(4)单链表的插入:在已建好的单链表的指定位置(i=3)插入一个结点3。

(5)单链表的删除:在一个包括头结点和5个结点的单链表L=(5,4,3,2,1)中,删除指定位置(i=2)的结点,实现的基本操作。

(6)求单链表的表长:输出单链表的所有元素和表长。

(7)单链表的判空:判断单链表是否为空表。

(8)单链表的清空:释放单链表的存储空间。

三、程序源代码1.线性表的基本操作#include <iostream>#include<stdlib.h>using namespace std;#define OK 1#define OVERFLOW -2#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCEREMENT 10typedef int Status;typedef int Elemtype;typedef Elemtype *Triplet;typedef struct { //定义结构体类型:顺序表Elemtype *elem;int length;int listsize;} Sqlist;Status Initlist( Sqlist &L ) { //int n,i;L.elem = (Elemtype*) malloc (LIST_INIT_SIZE*sizeof(Elemtype));if(!L.elem) {return(OVERFLOW);}cout << "输入元素个数和各元素的值:";cin >> n;for(int i=0; i<n; i++) {cin >> L.elem[i];}L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}Status TraverList(Sqlist L) {for(int i=0; i<L.length; i++) {cout << L.elem[i]<<" ";}cout << endl;}Status ListInsert (Sqlist &L,int i,Elemtype e) { //插入Elemtype *newbase,*p,*q;if(i<1||i>L.length+1) return ERROR;//i不合法if(L.length >= L.listsize) { //需要重新分配存储空间newbase = (Elemtype *) realloc(L.elem,(L.listsize + LISTINCEREMENT)*sizeof (Elemtype));if(!newbase) exit(OVERFLOW);//分配失败L.elem = newbase;L.listsize += LISTINCEREMENT;}q = &(L.elem[i-1]);for(p=&(L.elem[L.length-1]); p>=q; --p)*(p+1)=*p;*q=e;++L.length;return OK;}Status ListDelete(Sqlist &L,int i,Elemtype &e) { //删除Elemtype *p,*q;if((i<1)||(i>L.length)) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p; p<=q; ++p)*(p-1)=*p;--L.length;return OK;}Status LocateElem(Sqlist L,Elemtype &e) { //查找int i;Elemtype *p;i=1;p=L.elem;while(i<=L.length&&*(p++)!=e) ++i;if(i<=L.length) return i;else return 0;}Status ClearList(Sqlist &L) {free(L.elem);cout << "该表已被清空!";return OK;}int main() {Sqlist L;int i,z;Elemtype e;if(Initlist(L)==OVERFLOW) {cout << endl << "OVERFLOW";return 0;}TraverList(L);while(1) {cout << "-------------------" << endl;cout << "选择要执行的基本操作:" << endl << "1:插入元素" << endl << "2.删除元素" << endl << "3.查找元素" << endl<< "4.退出" << endl;cin >> z;switch(z) {case 1:cout << "输入要插入元素的位置和值:" << endl;cin >> i >> e;if(ListInsert(L,i,e)==OK)TraverList(L);elsecout << "插入的位置不合法。

数据结构--实验报告 线性表的基本操作

数据结构--实验报告 线性表的基本操作

数据结构--实验报告线性表的基本操作线性表的基本操作实验报告1.引言线性表是最基本的数据结构之一,它可以用来存储一系列具有相同数据类型的元素。

本实验旨在通过实践掌握线性表的基本操作,包括插入、删除、查找和修改元素等。

本文档将详细介绍实验所需的步骤和操作方法。

2.实验目的1.掌握线性表的插入和删除操作。

2.理解线性表的查找和修改元素的方法。

3.熟悉线性表的基本操作在算法中的应用。

3.实验环境本实验使用编程语言/软件名称作为开发环境,具体要求如下:________●操作系统:________操作系统名称和版本●编程语言:________编程语言名称和版本4.实验步骤4.1 初始化线性表在程序中创建一个空的线性表,用于存储元素。

实现方法:________具体的初始化方法和代码示例 4.2 插入元素在线性表中指定位置插入一个新元素。

实现方法:________具体的插入元素方法和代码示例 4.3 删除元素删除线性表中指定位置的元素。

实现方法:________具体的删除元素方法和代码示例 4.4 查找元素在线性表中查找指定元素的位置。

实现方法:________具体的查找元素方法和代码示例 4.5 修改元素修改线性表中指定位置的元素值。

实现方法:________具体的修改元素方法和代码示例5.实验结果在完成上述步骤后,我们得到了一个可以进行插入、删除、查找和修改元素的线性表。

具体操作结果如下:________●插入元素操作结果:________插入元素的具体操作结果●删除元素操作结果:________删除元素的具体操作结果●查找元素操作结果:________查找元素的具体操作结果●修改元素操作结果:________修改元素的具体操作结果6.实验总结通过本次实验,我们深入理解了线性表的基本操作,并且掌握了这些操作的实现方法。

线性表在实际应用中十分常见,熟练掌握线性表的操作对于开发高效的算法和数据结构具有重要意义。

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
2.上机输入、调试实验程序;
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法,1为插入,2为删除,3为查询!4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);

南邮数据结构实验报告

南邮数据结构实验报告

南邮数据结构实验报告实验目的,通过本次实验,我们旨在加深对数据结构的理解,掌握数据结构的基本操作和算法设计能力,提高对数据结构的应用能力和实际问题的解决能力。

一、实验内容。

1. 实验一,线性表的基本操作。

本次实验中,我们首先学习了线性表的基本概念和操作,包括插入、删除、查找等操作,并通过实际编程操作来加深对线性表的理解。

2. 实验二,栈和队列的应用。

在实验二中,我们通过实际编程操作来学习栈和队列的应用,包括中缀表达式转换为后缀表达式、栈的应用、队列的应用等内容。

3. 实验三,树和二叉树的基本操作。

实验三中,我们学习了树和二叉树的基本概念和操作,包括树的遍历、二叉树的建立和遍历等内容,并通过实际编程操作来加深对树和二叉树的理解。

4. 实验四,图的基本操作。

最后,我们学习了图的基本概念和操作,包括图的存储结构、图的遍历等内容,并通过实际编程操作来加深对图的理解。

二、实验过程。

在实验过程中,我们首先对实验内容进行了深入的学习和理解,掌握了数据结构的基本概念和操作方法。

然后,我们通过实际编程操作来加深对数据结构的理解,并通过调试和修改程序来提高对数据结构的应用能力和实际问题的解决能力。

在实验过程中,我们遇到了一些问题,但通过不懈的努力和团队合作,最终顺利完成了实验任务。

三、实验结果与分析。

通过本次实验,我们深入理解了数据结构的基本概念和操作方法,掌握了线性表、栈、队列、树、二叉树和图的基本操作,并通过实际编程操作加深了对数据结构的理解。

同时,我们也提高了对数据结构的应用能力和实际问题的解决能力,为今后的学习和工作打下了坚实的基础。

四、实验总结。

通过本次实验,我们不仅加深了对数据结构的理解,还提高了对数据结构的应用能力和实际问题的解决能力。

在今后的学习和工作中,我们将继续努力,不断提升自己的专业能力,为将来的发展打下坚实的基础。

以上就是本次实验的报告内容,谢谢!。

使用数据结构基础第五版王中华课后实验

使用数据结构基础第五版王中华课后实验

使用数据结构基础第五版王中华课后实验
本次实验是基于《数据结构基础》第五版王中华教授所编写的课本,实验内容包含了
课后习题的部分,并且结合课本中的数据结构实现,加以实践与验证。

实验一:线性表的基本操作
1、目的:加深对线性表基本概念的理解与掌握。

掌握线性表的初始化,清空,判空,获取长度等基本操作。

2、实验步骤:
(1)根据课本提供的线性表结构体定义,编写相应的初始化函数。

(2)编写线性表的清空、判空、获取长度等基本操作函数。

(3)测试以上函数是否正确。

3、实验结果:
测试函数结果均正确。

加深了对线性表基本操作的理解。

实验二:顺序表的插入与删除
1、目的:了解顺序表的插入和删除的实现过程,掌握插入和删除的操作方式和效
果。

(2)实现顺序表的插入(在指定位置插入)和删除(删除指定位置元素)操作。

测试函数结果正确。

了解了单链表和双链表的实现过程,掌握了链表的插入和删除操
作方法。

1、目的:了解栈的基本概念和操作方法,掌握栈的初始化、入栈、出栈、获取栈顶
元素、栈空及栈长等基本操作方法。

(2)实现队列的初始化、入队、出队、获取队头元素、队空及队长等基本操作方法。

总结:通过对《数据结构基础》第五版王中华教授所编写的课本进行实验,加深了对
线性表、顺序表、链表、栈和队列的理解,掌握了这些数据结构的基本操作方法和实现原理。

本次实验让我更有信心在数据结构的学习与实践中取得更好的结果。

数据结构实验与实训教程第4版程序代码

数据结构实验与实训教程第4版程序代码

目录第一部分预备知识 (1)预备知识 (1)预备知识实验 (2)第二部分基础实验 (4)实验1 线性表的基本操作 (4)实验2 链表的基本操作 (9)实验3 栈的基本操作 (15)实验4 队列的基本操作 (22)实验5 数组的基本操作 (32)实验6 字符串的基本操作 (36)实验7 二叉树的基本操作 (41)实验8 树的遍历和哈夫曼树 (46)实验9 图的基本操作 (53)实验10 排序 (59)实验11 查找 (64)第三部分课程设计实验 (69)实验1 航空客运订票系统 (69)实验2 汉诺塔游戏程序 (75)实验3 全屏幕编辑程序设计 (79)实验4 旅游路线安排模拟系统 (90)实验6 最小生成树kruskal算法 (93)第一部分预备知识预备知识例1.1#include <stdio.h>int sumabc(int a, int b, int c) /* 求三个整数之和*/{ int s;a=b+c;s=a+b+c;return s;}void displayLine(void){ printf(”----------------------\n“);}void main( ){ int x,y, z ,sabc;x=y=z=8;display(); /* 画一条线*/printf(“\n sum=%d”,sumabc(x,y,z)); /* 在输出语句中直接调用函数sumabc( ) */ printf(“\n %6d%6d%6d”,x,y,z);display();/* 画一条线*/x=2; y=4; z=6;sabc =sumabc(x, y, z); /* 在赋值语句中调用函数sumabc( ) */printf(“\n “ sum=%d”, sabc);printf(“\n %6d%6d%6d”,x,y,z);display();/* 画一条线*/}例1.2int sumabc(int *a, int b, int c){int s;*a=b+c;s=*a+b+c;return s;}预备知识实验int main(){ //在main函数中调用上述声明的函数int n; //记录个数STUDENT stu[MAXSIZE;// 顺序存储结构,方法一静态一维数组。

线性表的实现及操作(二)

线性表的实现及操作(二)
typedef int DataType;
typedef struct
{
DataType list[MaxSize];
int size;
} SeqList;
void ListInitiate(SeqList *L)/*初始化顺序表L*/
{
L->size = 0;/*定义初始数据元素个数*/
}
int ListLength(SeqList L)/*返回顺序表L的当前数据元素个数*/
ListDelete(&myList, 4, &x);
for(i = 0; i < ListLength(myList); i++)
{
ListGet(myList, i, &x);//此段程序有一处错误
printf("%d ", x);
}
}
测试结果:
线性表的实现及操作(二)
一、实验目的
了解和掌握线性表的链式存储结构;掌握用C语言上机调试线性表的基本方法;掌握线性表的基本操作:插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算,以及对相应算法的性能分析。
p = p->next;
free(p1);
}
*head = NULL;
}
void main(void)
{
SLNode *head;
int i , x;
ListInitiate(&head);/*初始化*/
for(i = 0; i < 10; i++)
{
if(ListInsert(head, i, i+1) == 0)/*插入10个数据元素*/

线性表的基本操作实验报告

线性表的基本操作实验报告

线性表的基本操作实验报告线性表的基本操作1、需求分析:构建一个顺序表并实现顺序表的一些基本操作,例如创建列表,插入、删除元素,求元素的前驱等功能。

(1) 顺序表中数据元素为整形数字,范围属于int型。

(2) 输出部分操作提示以及功能操作所得到的数据(int型)。

(3) 顺序表建立、删除、插入、查询、判空、判满、查询前后驱等功能。

(4) 测试数据:a)b)2、概要设计:用一个结构定义了一个数组,和数组内容的长度。

主程序使用switch语句对将要进行的操作进行选择,调用各个功能函数。

3、实验源代码如下:#include<iostream>using namespace std;typedef struct{int date[100];int length;}SeqList;SeqList L;SeqList SeqListInit()//初始化顺序表 {cout<<"你定义的顺序表的长度(长度小于)"<<endl;cin>>L.length;cout<<"顺序表里面储存数据为"<<endl;for(int i=0;i<L.length;i++){int a;cin>>a;L.date[i]=a;}return L;}void ListClear()/* 清空顺序表*/{L.length=0;}int ListLength()/* 求顺序表长度*/{cout<<L.length<<endl;return 0;}int ListEmpty()/* 检查顺序表是否为空*/ { if(L.length==0)cout<<"为空"<<endl;elsecout<<"不为空"<<endl;return 0;}int ListFull()/*检查顺序表是否为满*/ { if(L.length==100)cout<<"为满"<<endl;elsecout<<"未满"<<endl;return 0;}void ListTraverse()/* 遍历顺序表*/{for(int i=0;i<L.length;i++)cout<<L.date[i]<<" ";cout<<endl;}int ListGet(int i)/* 从顺序表中查找元素*/ { if(i>=0&&i<L.length)cout<<L.date[i-1]<<endl;return 0;}int ListLocate(int x){for(int i=0;i<L.length;i++)if(L.date[i]==x)cout<<L.date[i];return 0;}void ListInsert(int i, int x){if(i>=0&&i<L.length){for(int m=0;i<=L.length-i;m++)L.date[L.length]=L.date[L.length-1];L.date[i-1]=x;L.length++;}}void ListDelete(int i){if(i>=0&&i<L.length){for(i;i<L.length;i++)L.date[i-1]=L.date[i];L.length--;}}int ListPrior(int e){if(e-2>=0&&e-2<L.length)cout<<L.date[e-2]<<endl;return 0;}int ListNext(int e){if(e>=0&&e<L.length)cout<<L.date[e]<<endl; return 0; }int main(){while(1){int i;cout<<"1初始化顺序表"<<endl;cout<<"2清空顺序"<<endl;cout<<"3求顺序表长度"<<endl;cout<<"4检查顺序表是否为空"<<endl;cout<<"5检查顺序表是否为满"<<endl;cout<<"6遍历顺序表"<<endl;cout<<"7从顺序表中查找元素"<<endl;cout<<"8从顺序表中查找与给定元素值相同的元素的位置"<<endl; cout<<"9向顺序表插入元素"<<endl;cout<<"10从顺序表中删除元素"<<endl;cout<<"11求元素前驱"<<endl;cout<<"12求元素后继"<<endl;cin>>i;switch (i){case 1:SeqListInit();break;case 2:ListClear();break;case 3:ListLength();break;case 4:ListEmpty();break;case 5:ListFull();break;case 6:ListTraverse();break;case 7:{int m;cout<<"请输入查找元素的位置"<<endl; cin>>m;ListGet(m);break;}case 8:{int m;cout<<"请输入查找元素"<<endl; cin>>m;ListLocate(m);break;}case 9:{int x;cout<<"请输入插入的元素"<<endl; cin>>x;ListInsert(i,x);break;}case 10:{int m;cout<<"请输入删除的元素"<<endl; cin>>m;ListDelete(m);break;}case 11:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListPrior(m);break;}case 12:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListNext(m);break;}default:break;}}}4、a) 遇见形参与实参搞混问题,改形参里面的内容并不影响其原本数据。

《数据结构》实验书

《数据结构》实验书

目录实验一线性表基本操作的编程实现 (201)实验二堆栈或队列基本操作的编程实现 (49)实验四二维数组基本操作的编程实现 (18)实验五二叉树基操作的编程实现 (20)实验六图基本操作的编程实现 (45)(特别提示:程序设计包含两个方面的错误。

其一是错误,其二是能错误。

为了提高学生的编程和能力,本指导书给出的程序代码并的两种错误。

并且也不保证程序的完整性,有一些语句已经故意删除,就是要求学生自己编制完成,这样才能达到我们的要求。

希望大家以自己所学高级语言的基本功和点为基础,不要过于依赖给出的参考代码,这样才能有所进步。

如果学生能够根据要求完全自己编制,那就不好了。

)实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求:线性表基本操作的编程实现(2学时,验证型),掌握线性表的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、逆序、排序等操作,存储结构可以在顺序结构或链表结分主要功能,也可以用菜单进行管理完成大部分功能。

还鼓励学生利用基本操作进行一些更实际的应用型程序设计。

【实验性质】【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。

建议实现键盘输入数据以实现程序的通据的函数。

【注意事项】【思考问题】1.线性表的顺序存储和链表存储的差异?优缺点分析?2.那些操作引发了数据的移动?3.算法的时间效率是如何体现的?4.链表的指针是如何后移的?如何加强程序的健壮性?【参考代码】(一)利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1)#define ListSize //根据需要自己设定一个班级能够容纳的最大学生数(2)typedef struct Stu{int num; //学生的学号char name[10]; //学生的姓名float wuli; //物理成绩float shuxue; //数学成绩float yingyu; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{stu[ListSize]; //存放学生的数组定义,静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=0;i<m;i++) //输入m个学生的所有信息{printf("please input the %dth student's information:\n",i+1);printf("num=");scanf("%d", ); //输入第i个学生的学号printf("name=");scanf("%s", ); //输入第i个学生的姓名printf("wuli=");scanf("%f", ); //输入第i个学生的物理成绩printf("shuxue=");scanf("%f", ); //输入第i个学生的数学成绩printf("yingyu=");scanf("%f", ); //输入第i个学生的英语成绩Li->length++; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。

数据结构实验二 线性表

数据结构实验二 线性表

数据结构实验二线性表数据结构实验二线性表1. 实验目的1.1 理解线性表的概念和特性1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的基本操作:初始化、插入、删除、查找、修改、遍历等1.4 熟悉线性表的应用场景2. 实验内容2.1 线性表的顺序存储结构实现2.1.1 定义线性表结构体2.1.2 初始化线性表2.1.3 插入元素2.1.4 删除元素2.1.5 查找元素2.1.6 修改元素2.1.7 遍历线性表2.2 线性表的链式存储结构实现2.2.1 定义链表节点结构体2.2.2 初始化链表2.2.3 插入元素2.2.4 删除元素2.2.5 查找元素2.2.6 修改元素2.2.7 遍历链表3. 实验步骤3.1 实现顺序存储结构的线性表3.2 实现链式存储结构的线性表3.3 编写测试程序,验证线性表的各种操作是否正确3.4 进行性能测试,比较两种存储结构的效率差异4. 实验结果与分析4.1 执行测试程序,检查线性表的操作结果是否正确4.2 对比顺序存储结构和链式存储结构的性能差异4.3 分析线性表的应用场景,总结线性表的优缺点5. 实验总结5.1 总结线性表的定义和基本操作5.2 回顾实验中遇到的问题和解决方法5.3 提出对线性表实现的改进方向和思考附件:请参考附件中的源代码和实验报告模板。

法律名词及注释:1. 版权:指对某一作品享有的法律上的权利,包括复制权、发行权、改编权等。

2. 法律责任:指违反法律或合同规定所承担的责任。

3. 保密义务:指个人或组织根据法律、法规、合同等规定需要承担的保密责任。

4.知识产权:指人们在社会实践中所创造的智力劳动成果所享有的权利,包括专利权、著作权、商标权等。

线性表及其实现(实验二)

线性表及其实现(实验二)

实验二线性表及其实现一.实验目的及要求(1)熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现,以线性表的各种操作(建立、插入、删除等)的实现为实验重点;(2)通过本次实验帮助学生加深对顺序表、链表的理解,并加以应用;(3)掌握循环链表和双链表的定义和构造方法二.实验内容:(1)编程实现线性表两种存储结构(顺序存储、链式存储)中的基本操作的实现(线性表的创建、插入、删除和查找等),并设计一个菜单调用线性表的基本操作。

(2)建立一个按元素递增有序的单链表L,并编写程序实现:a)将x插入其中后仍保持L的有序性;b)将数据值介于min和max之间的结点删除,并保持L的有序性;c)将单链表L逆置并输出;(3)编程实现将两个按元素递增有序的单链表合并为一个新的按元素递增的单链表。

三.实验主要流程、基本操作或核心代码、算法片段(该部分如不够填写,请另加附页)(1)编程实现线性表两种存储结构(顺序存储、链式存储)中的基本操作的实现(线性表的创建、插入、删除和查找等),并设计一个菜单调用线性表的基本操作。

➢程序代码:顺序存储:头文件:#define INIT_SIZE 100#define INCREMENT 10#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}Sq;Status Init_Sq(Sq &L);Status Insert_Sq(Sq &L,int i,ElemType e);Status Delete_Sq(Sq &L,int i,ElemType &e);主函数:#include"stdio.h"#include"1.h"#include"stdlib.h"int main(){Sq L;printf("是否建立顺序表?\n");printf("1、建立\n");printf("2、退出程序\n");int a;//选择是否建立scanf("%d",&a);switch(a){case 1:Init_Sq(L);break;case 2:printf("程序结束!\n");exit(OVERFLOW);default:printf("输入错误!\n");}printf("请输入要放入顺序表中的元素个数(不要超过100)\n");scanf("%d",&L.length);int i;//进行用户输入循环printf("请输入具体元素\n");for(i=0;i<L.length;i++){scanf("%d",&L.elem[i]);}int b;//选择操作do{printf("请选择下列操作\n");printf("1、向表中添加元素\n");printf("2、删除表中某一元素\n");printf("3、退出程序\n");scanf("%d",&b);switch(b){case 1:ElemType x;//新元素int c;//新元素位置printf("请输入要添加的元素,和添加的位置(空格隔开)\n");scanf("%d%d",&x,&c);Insert_Sq(L,c,x);int j;//新表输出循环printf("新表为:\n");for(j=0;j<L.length;j++){printf("%d ",L.elem[j]);}printf("\n");break;case 2:int d;//需要删除元素的位置ElemType y;//被删除的元素printf("请输入删除元素的位置\n");scanf("%d",&d);Delete_Sq(L,d,y);printf("被删除的元素是%d\n",y);printf("剩下的元素为:\n");int f;//输出循环for(f=0;f<L.length;f++){printf("%d ",*(L.elem+f));}printf("\n");break;case 3:printf("程序结束!\n");exit(OVERFLOW);default:printf("输入出错!\n");}}while(b!=3);return 0;}功能函数:#include"stdio.h"#include"stdlib.h"#include"1.h"Status Init_Sq(Sq &L){L.elem=(ElemType *)malloc(INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW);L.length=0;L.listsize=INIT_SIZE;return OK;}Status Insert_Sq(Sq &L,int i,ElemType e){if(L.length==100){int *newpase;newpase=(ElemType *)realloc(L.elem,(L.length+INCREMENT)*sizeof(ElemType));if(!newpase) exit(OVERFLOW);L.elem=newpase;L.listsize+=INCREMENT;}if(i<1||i>L.length+1){return ERROR;}L.length+=1;int b=L.length;//用于循环while(i<=b){L.elem[b]=L.elem[b-1];b--;}L.elem[i-1]=e;return OK;}Status Delete_Sq(Sq &L,int i,ElemType &e){if(i<1||i>L.length+1){return ERROR;}e=L.elem[i-1];int j;for(j=i-1;j<L.length-1;j++){L.elem[j]=L.elem[j+1];}L.length-=1;return OK;}链式存储:头文件:#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;void Create_L(int n,LinkList &L);Status Insert_L(LinkList &L,int i,ElemType e); Status Delete_L(LinkList &L,int i,ElemType &e); Status GetElem_L(LinkList L,int i,ElemType &e);主函数:#include"stdio.h"#include"1.h"int main(){printf("是否建立链表\n");int a;//选择printf("1、建立\n");printf("2、退出程序\n");scanf("%d",&a);switch(a){case 1:LinkList L;printf("请输入链表长度(不计算头结点)\n");int n;//数据容纳度scanf("%d",&n);Create_L(n,L);int b;//选择功能printf("请选择以下功能:\n");do{printf("1、查找某位置元素\n");printf("2、在某位置插入元素\n");printf("3、删除某位置元素\n");printf("4、结束程序\n");scanf("%d",&b);switch(b){case 1:{printf("请输入查找位置\n");int c;//查找位置ElemType d;//数据容器scanf("%d",&c);if(c>n){printf("该位置大于数据个数,请重新选择\n");break;}GetElem_L(L,c,d);printf("第%d个数据为:%d\n",c,d);break;}case 2:{printf("请输入在什么位置插入什么数据(空格隔开)\n");int f,g;//位置、数据scanf("%d %d",&f,&g);Insert_L(L,f,g);printf("此时的数据为:\n");int h;n=n+1;LinkList l=L;for(h=0;h<n;h++){printf("%d ",l->next->data);l=l->next;}printf("\n");break;}case 3:{printf("请输入需要删除的位置\n");int m;ElemType o;scanf("%d",&m);Delete_L(L,m,o);n=n-1;printf("此时的数据还有:\n");int q;LinkList r=L;for(q=0;q<n;q++){printf("%d ",r->next->data);r=r->next;}printf("\n");break;}case 4:printf("程序结束\n");break;default:printf("输入出错\n");}}while(b!=4);break;case 2:printf("程序退出\n");break;default:printf("输入错误\n");}}#include"1.h"#include"stdio.h"#include"stdlib.h"void Create_L(int n,LinkList &L){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;printf("请逆序输入相应个数的数据\n");int i;//用于循环LinkList p;for(i=n;i>0;i--){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}Status GetElem_L(LinkList L,int i,ElemType &e) {int j;//用于循环LinkList p=L;if(p){for(j=0;j<i;j++){p=p->next;}e=p->data;}return OK;}Status Insert_L(LinkList &L,int i,ElemType e) {LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;}if(!p||j>i-1)return ERROR;LinkList s;s=(LinkList) malloc (sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}Status Delete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while(p->next&&j<i-1){p=p->next;j++;}if(!(p->next)||j>i-1)return ERROR;LinkList q;q=p->next;p->next=q->next;e=q->data;printf("被删除的元素为:%d\n",e);free(q);return OK;}➢运行结果:(2)建立一个按元素递增有序的单链表L,并编写程序实现:a)将x插入其中后仍保持L的有序性;b)将数据值介于min和max之间的结点删除,并保持L 的有序性;c)将单链表L逆置并输出;程序代码部分:头文件:#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define OVERFLOW -1#define INFEASIBLE -2typedef int ElemType;typedef int Status;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;Status Create(LinkList &L,int n);Status Insert(LinkList &L,ElemType e,int n);Status Delete(LinkList &L,int min,int max,int &n);Status Reverse(LinkList L,int n);主函数:#include"stdio.h"#include"1.h"int main(){printf("是否建立单链表?\n");printf("1、建立\n");printf("2、不建立并结束程序\n");int a;//判断是否建立链表scanf("%d",&a);switch(a){case 1:{LinkList L,p;printf("请确定单链表的节点个数\n");int node_num;//节点个数scanf("%d",&node_num);Create(L,node_num);p=L;printf("现在的单链表为:\n");for(int i=0;i<node_num;i++){p=p->next;printf("%d ",p->data);}printf("\n");printf("请选择下列操作\n");int b;//选择操作do{printf("1、插入一个元素\n");printf("2、删除某个范围内的元素(不删除上下限)\n");printf("3、逆置单链表中的元素\n");printf("4、结束程序\n");scanf("%d",&b);switch(b){case 1:{int insert;//插入的元素printf("请输入要插入的元素\n");scanf("%d",&insert);Insert(L,insert,node_num);LinkList p=L;printf("此时单链表中的元素为:\n");for(int i=0;i<node_num+1;i++){printf("%d ",p->next->data);p=p->next;}printf("\n");}node_num+=1;break;case 2:{printf("请输入删除范围的上下限(空格隔开)\n");int min,max;scanf("%d %d",&min,&max);printf("被删除的元素有:\n");Delete(L,min,max,node_num);printf("此时的单链表元素有:\n");LinkList p=L;for(int i=0;i<node_num;i++){printf("%d ",p->next->data);p=p->next;}printf("\n");}break;case 3:{Reverse(L,node_num);}break;case 4:printf("程序结束!\n");break;default:printf("输入错误!\n");}}while(b!=4);}break;case 2:printf("程序结束!\n");break;default: printf("输入错误!\n");}}功能函数:#include"stdio.h"#include"stdlib.h"#include"1.h"//顺序输入N个元素建立单链表与书上30页的2.10是不同的方法Status Create(LinkList &L,int n){L=(LinkList) malloc (sizeof(LNode));if(!L) exit(OVERFLOW);L->next=NULL;LinkList q=L;printf("请输入具体元素\n");for(int i=0;i<n;i++){LinkList p=(LinkList) malloc (sizeof(LNode));scanf("%d",&p->data);//与30页不同之处q->next=p;p->next=NULL;q=q->next;}return OK;}Status Insert(LinkList &L,ElemType e,int n){LinkList p;p=L;LinkList s=(LinkList) malloc (sizeof(LNode));if(!s) exit(OVERFLOW);s->data=e;for(int i=0;i<n;i++){if(e<=p->next->data){s->next=p->next;p->next=s;break;}p=p->next;}if(p->next==NULL){p->next=s;s->next=NULL;}return OK;}Status Delete(LinkList &L,int min,int max,int &n){ElemType e;//显示被删除的元素int a=n;//判别n是否变化LinkList p=L;for(int i=0;i<a;i++){if(p->next!=NULL){if(min<p->next->data&&max>p->next->data){n--;LinkList q;q=p->next;p->next=q->next;e=q->data;printf("%d ",e);free(q);}else if(p->next->data>=max)break;//如果一个元素大于等于max,说明后面的元素一定大于等于max,就没必要进行比较了}p=p->next;}if(n==a)//说明元素没变化,是min大于等于所有元素(或者max小于等于所有元素)造成的结果{printf("单链表在该范围内没有元素\n");return ERROR;}printf("\n");return OK;}Status Reverse(LinkList L,int n){LinkList w,p,q=L;//用于承载逆置的单链表q=q->next;w=(LinkList) malloc (sizeof(LNode));w->next=NULL;for(int i=n;i>0;i--){p=(LinkList) malloc (sizeof(LNode));p->data=q->data;q=q->next;p->next=w->next;w->next=p;}printf("逆置后的单链表中元素为:\n"); LinkList y;y=w;for(int j=0;j<n;j++){y=y->next;printf("%d ",y->data);}printf("\n");return OK;}➢运行结果:(3)编程实现将两个按元素递增有序的单链表合并为一个新的按元素递增的单链表。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
void Insert(LinkList head);
main()
{ Node *head;
int ok;
printf("creat link,please input value, -1 end.\n");
head=CreatLink();
Display(head);
while (1)
{printf("\n");
{
Node *p;
p=head->next;
while (p)
;,p->data);
p=p->next;}
printf("\n");
}
void Insert(LinkList head)
{
Node *p,*q,*s;
int k,i,j=0;
printf("please input value and position:");
#include <stdio.h>
#include <stdlib.h>
typedef struct Node
{
int data;
struct Node *next;
} Node ,*LinkList;
Node * CreatLink();
void Display(LinkList head);
void Dele( LinkList head);
printf(" 1.insert.\n ");
printf(" 2.delete.\n ");
printf(" 0. exit.\n ");
scanf("%d",&ok);
if (ok==0)
break;
switch (ok)
{
case 1: Insert(head);break;
case 2: Dele(head); break;
while (d!=-1)
{ p=(Node *) malloc(sizeof(Node));
p->data=d;
p->next=NULL;
q->next=p;
q=p;
printf("please input d:");
scanf("%d",&d);
}
return head;
}
void Display(LinkList head)
q->data=k;
p=head->next;
s=head;
while (p&&p->data!=k)
{ s=p;
p=p->next;
}
if (p)
{
s->next=p->next;
free(p);
Display( head);
}
else
{ printf(" no find!");
}
}
scanf("%d,%d",&k,&i);
q=(Node *) malloc(sizeof(Node));
q->data=k;
p=head;
while (j<i-1 && p!=NULL )
{ j++;
p=p->next;
}
if (p)
{
q->next=p->next;
p->next=q;
Display( head);
}
else
{
printf(" position error!");
}
}
void Dele( LinkList head)
{
Node *p,*q,*s;
int k;
printf("please input find value:");
scanf("%d",&k);
q=(Node *) malloc(sizeof(Node));
实验二线性表的基本操作
一、实验目的
1、掌握用Turbo上机调试线性表的基本方法;
2、掌握线性表的基本操作,插入、删除、查找,以及线性表的基本运算在顺序存储结构和链接存储结构上的实现。
二、实验内容
线性表基本操作:产生、插入、删除的实现(顺序、链式存储结构)
三、实验要求
1.分别用函数实现相应功能。
2.在主函数中调用实现。
default: ok=0;
}
}
}
Node * CreatLink()
{
int d;
Node * p,*q,*head;
p=(Node *) malloc(sizeof(Node));
p->next=NULL;
head=p;
q=p;
printf("please input d:");
scanf("%d",&d);
相关文档
最新文档