线性表实验报告:针对链式或顺序存储的线性表实现指定的操作(二份)
线性表ADT的顺序存储与链式存储实验报告
实验报告题目:完成线性表ADT的顺序存储和链式存储方式的实现一、需求分析1、本演示程序中,线性表的数据元素类型限定为整型2、演示程序以用户和计算机的对话方式执行,即在计算机的终端上显示“提示信息”之后由用户在键盘上键入演示程序规定的运算命令,相应的输出结果显示在后面。
3、程序的执行命令包括:创建、撤销、清空、插入、修改、删除、定位等线性表ADT各项基本操作二、概要设计为实现上述功能,我们给出线性表的抽象数据类型定义,具体的有单向链,双向链,顺序表等,同时对于上述功能的实现还采用有/无头结点两种方式来实现1.线性表的抽象数据类型定义为ADT List{数据对象:D={a i|a i∈ElemSet,i=1,2,…,n,n≥0}数据关系:R1={<a i-1,a i>|ai-1,ai∈D,i=2,…,n}基本操作:InitList(&L)操作结果:构造一个空的线性表LDestroyList(&L)初始条件:线性表L已存在。
操作结果:销毁线性表L。
ClearList(&L)初始条件:线性表L已存在。
操作结果:将L重置为空表。
ListEmpty(L)初始条件:线性表L已存在。
操作结果:若L为空表,则返回TRUE,否则返回FALSE。
ListLength(L)初始条件:线性表L已存在。
操作结果:返回L中的i个数据元素的值。
GetElem(L,i,&e)初始条件:线性表L已存在,1≤i≤ListLength(L)。
操作结果:用e返回L中第i个数据元素的值。
LocateElem(L,e,compare())初始条件:线性表L已存在,compare()是数据元素判定函数操作结果:返回L中第一个与e满足compare()的数据元素的位序。
若这样的数据元素不存在,则返回值为0.PriorElem(L,cur_e,&pre_e)初始条件:线性表已存在操作结果:若cur_e是L的数据元素,且不是第一个,则用pre_e返回它的前驱,否则操作失败,pre_e无定义。
线性表实验报告
线性表实验报告一、实验的目的要求1、了解线性表的逻辑结构特性,以及这种结构特性在计算机内的两种存储结构。
2、掌握线性表的顺序存储结构的定义及其C语言实现。
3、掌握线性表的链式存储结构——单链表的定义及其C语言实现。
4、掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5、掌握线性表在链式存储结构——单链表中的各种基本操作。
6、认真阅读和掌握实验的程序。
7、上机运行本程序。
8、保存和打印出程序的运行结果,并结合程序进行分析。
二、实验的主要内容^题目:请编制C语言,利用链式存储方式来实现线性表的创建、插入、删除和查找等操作。
具体地说,就是要根据键盘输入的数据建立一个单链表,并输出该单链表;然后根据屏幕菜单的选择,可以进行数据的插入或删除,并在插入或删除数据后,再输出单链表;最后在屏幕菜单中选择0,即可结束程序的运行。
三、解题思路分析在链表中插入数据,不需要进行大量的数据移动,只需要找到插入点即可,可以采用后插入的算法,在插入点的后面添加结点。
在链表中删除数据,先找到删除点,然后进行指针赋值操作。
四、程序清单#include<>#include<>#include<>typedef int ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode;LNode *L;LNode *creat_L();void out_L(LNode *L);void insert_L(LNode *L,int i,ElemType e); ElemType delete_L(LNode *L,ElemType e);int locat_L(LNode *L,ElemType e);void main(){int i,k,loc;ElemType e,x;char ch;do{printf("\n");printf("\n 1.建立单链表");printf("\n 2.插入元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运行");printf("\n================================"); printf("\n 请输入您的选择(1,2,3,4,0)"); scanf("%d",&k);switch(k){case 1:{L=creat_L();out_L(L);}break;case 2:{printf("\n请输入插入位置:");scanf("%d",&i);printf("\n请输入要插入元素的值:");scanf("%d",&e);insert_L(L,i,e);out_L(L);}break;case 3:{printf("\n请输入要删除元素的位置:"); scanf("%d",&i);x=delete_L(L,i);out_L(L);if(x!=-1){printf("\n删除的元素为:%d\n",x);printf("删除%d后的单链表为:\n",x);out_L(L);}else printf("\n要删除的元素不存在!");}break;case 4:{printf("\n请输入要查找的元素值:"); scanf("%d",&e);loc=locat_L(L,e);if(loc==-1)printf("\n为找到指定元素!");else printf("\n已找到,元素位置是%d",loc); }break;}printf("\n----------------");}while(k>=1&&k<5);printf("\n 按回车键,返回...\n");ch=getchar();}LNode *creat_L(){ LNode *h,*p,*s; ElemType x;h=(LNode *)malloc(sizeof(LNode));h->next=NULL;p=h;printf("\n请输入第一个数据元素:");scanf("%d",&x);while(x!=-999){s= (LNode *)malloc(sizeof(LNode));s->data=x; s->next=NULL;p->next=s; p=s;printf("请输入下一个数据:(输入-999表示结束.)"); scanf("%d",&x);}return(h);}void out_L(LNode*L){ LNode*p;p=L->next; printf("\n\n");while(p!=NULL){printf("%5d",p->data);p=p->next;};}void insert_L(LNode*L,int i,ElemType e){ LNode *s,*p;int j;p=L;j=0;while(p!=NULL&&j<=i-1){p=p->next;j++;}if(p==NULL||i<1) printf("\n插入位置错误!");else { s=(LNode * )malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;}}ElemType delete_L(LNode *L,int i){ LNode *p, *q; int j; ElemType x;p=L;j=0;while(p->next!=NULL&&j<i-1){p=p->next;j++;}if(!p->next||i<1) {printf("\n删除位置错误!");return(-1);} else{ q=p->next; x=q->data;p->next=q->next; free(q);return(x);}}int locat_L(LNode *L,ElemType e){ LNode *p; int j=1;p=L->next;while(p!=NULL && p->data!=e) {p=p->next; j++;}if(p!=NULL)return(j); else return(-1);}五、》六、调试心得及收获。
线性表的操作算法实验报告
实验报告2013学年第一学期任课老师:2、在实验过程中遇到的问题与解决方法:问题有很多,比如局部变量与全局变量的声明,常常顾此失彼,此处概念仍然不清。
填写内容时,可把表格扩大。
附:实验源程序代码顺序表(链表):// 线性表(链表)#include <stdio.h>#include "malloc.h"#include <iostream>using namespace std;typedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;//创建一个长度为n的链表void CreateList(LinkList &L, int n) {L = (LinkList)malloc(sizeof(LNode));L->next = NULL;for (int i=n; i>0; --i){LinkList p = (LinkList)malloc(sizeof(LNode));cin>>p->data;p->next = L->next;L->next = p;}}// 在链表L第i个元素之前插入元素eint ListInsert(LinkList &L, int i, int e) {LinkList 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;}// 在链表L中删除第i个元素,并由e返回其值int ListDelete(LinkList &L, int i, int &e) { LinkList p=L;int j=0;while(p->next&&j<i-1) {p=p->next; ++j;}if(!(p->next)||j>i-1) return 0;LinkList q=p->next;p->next=q->next;e=q->data;free(q);cout<<"被删除的元素数据为"<<e<<"\n"; return 0;}//查找第i个元素,并由e返回其值int GetElem(LinkList &L,int i, int &e) {LinkList p=L->next;int j=1;while (p && j<i) {p=p->next; ++j;}if (!p||j>i) return 0;e=p->data;cout<<"该元素的值为"<<e<<"\n";return 1;}//让链表L中的元素按从小到大的顺序排列LinkList Sort(LinkList L){ LinkList p,q;int temp;for(p=L;p!=NULL;p=p->next){for(q=p->next;q!=NULL;q=q->next){if(p->data>q->data){temp=q->data;q->data=p->data;p->data=temp;}}}return L;}//归并L和La得到新的单链性表Lbvoid MergeList_L(LinkList &L,LinkList &La,LinkList &Lb) { LinkList p,pa,pb;p=L->next;pa=La->next;Lb=pb=L; //用L的头结点作为Lb的头结点while (p&&pa) {if (p->data<=pa->data) {pb->next=p;pb=p;p=p->next;}else {pb->next=pa;pb=pa;pa=pa->next;}}pb->next=p?p:pa;free(La);}int main(){LinkList L;int n,s,e,i,f,g,h;cout<<"输入链表长度n:";cin>>n;cout<<"请输入L中的元素:"<<endl;CreateList( L, n);cout<<"输入的链表为:"<<" ";LNode *q=L->next;while(q){cout<<q->data<<" ";q=q->next;} cout<<endl;int choice;cout<<"请选择功能:"<<endl;cout<<"1.插入元素"<<endl;cout<<"2.删除元素"<<endl;cout<<"3.查找元素"<<endl;cout<<"4.给元素排序"<<endl;cout<<"5.合并链表"<<endl;cout<<"0.退出程序"<<endl;cout<<"PS:若先排序再合并,可将得到新的排序后的合并链表。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告1.简介本实验报告旨在介绍数据结构中线性表的实现和应用。
线性表是一种重要的数据结构,它的特点是数据元素之间存在一对一的前后关系,且具有唯一的起点和终点。
本实验通过实现线性表的基本操作,加深对线性表的理解,并通过实例应用展示线性表在实际问题中的应用。
2.实验环境本次实验采用的是编程语言C,并搭配使用一些常用的开发工具和库。
具体环境如下:________●操作系统:________Windows 10●编程语言:________C●开发工具:________Visual Studio Code●辅助库:________Stdio.h、stdlib.h、conio.h3.实验内容3.1 线性表的定义和基本操作3.1.1 线性表的定义线性表是由n(n ≥ 0)个数据元素组成的有限序列,数据元素之间存在一对一的前后关系。
3.1.2 线性表的基本操作●初始化线性表:________创建一个空的线性表。
●插入元素:________在指定位置插入一个新的元素。
●删除元素:________删除指定位置的元素。
●查找元素:________根据值或位置查找指定元素。
●修改元素:________根据位置修改指定元素的值。
●清空线性表:________将线性表中的所有元素清空。
3.2 线性表的顺序存储结构3.2.1 顺序存储结构的定义顺序存储结构是指使用一段连续的存储空间,依次存储线性表中的元素。
3.2.2 顺序存储结构的实现●初始化顺序表:________创建一个空的顺序表,并指定最大容量。
续元素依次后移。
●删除元素:________删除指定位置的元素,并将后续元素依次前移。
●查找元素:________根据值或位置查找指定元素,并返回其位置或值。
●修改元素:________根据位置修改指定元素的值。
●清空顺序表:________将顺序表中的所有元素清空。
●扩容:________当顺序表容量不足时,自动进行扩容。
数据结构实验报告线性表
数据结构实验报告线性表数据结构实验报告:线性表引言数据结构是计算机科学中非常重要的一个概念,它是用来组织和存储数据的一种方式。
线性表是数据结构中最基本的一种,它是由n个数据元素组成的有限序列。
在本次实验中,我们将对线性表进行深入研究,并进行实验验证。
实验目的1. 了解线性表的基本概念和特性2. 掌握线性表的顺序存储结构和链式存储结构3. 熟练掌握线性表的基本操作:插入、删除、查找等4. 通过实验验证线性表的操作和性能实验内容1. 学习线性表的基本概念和特性2. 熟悉线性表的顺序存储结构和链式存储结构3. 实现线性表的基本操作:插入、删除、查找等4. 对线性表的操作进行性能测试和分析实验步骤1. 学习线性表的基本概念和特性,包括线性表的定义、顺序存储结构和链式存储结构等2. 实现线性表的基本操作:插入、删除、查找等3. 设计实验用例,对线性表的操作进行性能测试4. 对实验结果进行分析和总结实验结果1. 实现了线性表的顺序存储结构和链式存储结构2. 实现了线性表的基本操作:插入、删除、查找等3. 对线性表的操作进行了性能测试,并得出了相应的性能数据4. 对实验结果进行了分析和总结,得出了相应的结论结论通过本次实验,我们深入了解了线性表的基本概念和特性,掌握了线性表的顺序存储结构和链式存储结构,熟练掌握了线性表的基本操作,并对线性表的性能进行了测试和分析。
这些都为我们进一步深入学习和应用数据结构打下了坚实的基础。
总结数据结构是计算机科学中非常重要的一部分,线性表作为数据结构中最基本的一种,对我们学习和应用数据结构具有重要的意义。
通过本次实验,我们对线性表有了更深入的了解,并且掌握了相关的操作和性能测试方法,这将为我们今后的学习和应用提供很大的帮助。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告实验目的:本次实验主要是为了学习和掌握线性表的基本操作和实现方式。
通过实验,我们可以加深对线性表的理解,并能够熟悉线性表的基本操作。
实验设备与环境:本次实验所需的设备包括计算机和编程环境。
我们选择使用C语言来实现线性表的操作,并在Visual Studio Code编程软件中进行编写和调试。
实验内容:1.线性表的定义和基本操作1.1 线性表的定义:线性表是一种有序的数据结构,其中的元素按照一定的顺序存储,可以插入、删除和访问元素。
1.2 线性表的基本操作:1.2.1 初始化线性表:创建一个空的线性表。
1.2.2 判断线性表是否为空:判断线性表是否不含有任何元素。
1.2.3 获取线性表的长度:返回线性表中元素的个数。
1.2.4 在线性表的指定位置插入元素:在线性表的第i个位置插入元素x,原第i个及其之后的元素依次后移。
1.2.5 删除线性表中指定位置的元素:删除线性表中第i个位置的元素,原第i+1个及其之后的元素依次前移。
1.2.6 获取线性表中指定位置的元素:返回线性表中第i个位置的元素的值。
1.2.7 清空线性表:将线性表中的元素全部删除,使其变为空表。
2.线性表的顺序存储结构实现2.1 线性表的顺序存储结构:使用数组来实现线性表的存储方式。
2.2 线性表的顺序存储结构的基本操作:2.2.1 初始化线性表:创建一个指定长度的数组,并将数组中的每个元素初始化为空值。
2.2.2 判断线性表是否为空:判断线性表的长度是否为0。
2.2.3 获取线性表的长度:返回线性表数组的长度。
2.2.4 在线性表的指定位置插入元素:将要插入的元素放入指定位置,并将原位置及其之后的元素依次后移。
2.2.5 删除线性表中指定位置的元素:将指定位置的元素删除,并将原位置之后的元素依次前移。
2.2.6 获取线性表中指定位置的元素:返回指定位置的元素的值。
2.2.7 清空线性表:将线性表数组中的每个元素赋空值。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告引言:数据结构是计算机科学中的一个重要概念,它研究如何组织和存储数据,以便能够高效地访问和操作。
线性表是数据结构中最基本的一种,它是一种有序的数据元素集合,其中的元素之间存在一对一的关系。
本次实验旨在通过实际操作线性表,加深对数据结构的理解,并掌握基本的线性表操作。
实验目的:1. 理解线性表的概念和特点;2. 掌握线性表的基本操作,如插入、删除、查找等;3. 熟悉线性表的顺序存储结构和链式存储结构;4. 分析不同存储结构的优缺点。
实验内容:1. 实现线性表的顺序存储结构顺序存储结构是将线性表的元素按照其逻辑顺序依次存放在一块连续的存储空间中。
我们可以使用数组来实现顺序存储结构。
首先,定义一个固定大小的数组作为线性表的存储空间,然后通过数组的下标来访问和操作线性表中的元素。
在插入和删除元素时,需要移动其他元素的位置,以保持线性表的有序性。
2. 实现线性表的链式存储结构链式存储结构是将线性表的元素存储在一系列的结点中,每个结点包含一个数据元素和一个指向下一个结点的指针。
通过将各个结点用指针连接起来,形成一个链表。
在插入和删除元素时,只需要修改相邻结点之间的指针,而不需要移动其他元素的位置。
实验步骤:1. 实现顺序存储结构的线性表首先,定义一个固定大小的数组,用于存储线性表的元素。
然后,实现插入、删除、查找等基本操作。
在插入元素时,需要判断线性表是否已满,如果已满则需要扩容。
在删除元素时,需要判断线性表是否为空,如果为空则无法删除元素。
通过实现这些基本操作,可以对线性表进行增删查改等操作。
2. 实现链式存储结构的线性表首先,定义一个结点类,包含一个数据元素和一个指向下一个结点的指针。
然后,通过将各个结点用指针连接起来,形成一个链表。
实现插入、删除、查找等基本操作。
在插入元素时,需要找到插入位置,并修改相邻结点之间的指针。
在删除元素时,需要找到待删除元素的前一个结点,并修改前一个结点的指针。
线性表实验报告
线性表实验报告一、实验目的本次实验的主要目的是深入理解线性表的基本概念和操作,通过实际编程实现线性表的存储和基本运算,掌握线性表在数据结构中的应用,提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、实验原理线性表是一种最基本、最简单的数据结构,它是由 n(n≥0)个数据元素组成的有限序列。
在这个序列中,每个数据元素的位置是按照其逻辑顺序排列的。
线性表有两种存储结构:顺序存储结构和链式存储结构。
顺序存储结构是用一组地址连续的存储单元依次存储线性表中的数据元素,使得逻辑上相邻的两个元素在物理位置上也相邻。
其优点是可以随机访问表中的任意元素,时间复杂度为 O(1);缺点是插入和删除操作需要移动大量元素,时间复杂度为 O(n)。
链式存储结构是通过指针将各个数据元素链接起来,每个数据元素由数据域和指针域组成。
其优点是插入和删除操作不需要移动大量元素,时间复杂度为 O(1);缺点是不能随机访问表中的元素,需要从头指针开始遍历,时间复杂度为 O(n)。
四、实验内容本次实验实现了顺序表和链表的基本操作,包括创建、插入、删除、查找、遍历等。
1、顺序表的实现定义顺序表的结构体,包括数据存储数组和表的长度。
实现顺序表的初始化函数,将表的长度初始化为 0。
实现顺序表的插入函数,在指定位置插入元素,如果插入位置非法或表已满,则返回错误。
实现顺序表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。
实现顺序表的查找函数,查找指定元素,如果找到则返回元素的位置,否则返回-1。
实现顺序表的遍历函数,输出表中的所有元素。
2、链表的实现定义链表的结构体,包括数据域和指向下一个节点的指针域。
实现链表的创建函数,创建一个空链表。
实现链表的插入函数,在指定位置插入元素,如果插入位置非法,则返回错误。
实现链表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告1.实验目的1.1 理解线性表的概念和操作方法1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的各种基本操作算法2.实验内容2.1 实现线性表的顺序存储结构a. 定义顺序存储结构的数据类型和长度b. 实现线性表的初始化操作c. 实现线性表的插入操作d. 实现线性表的删除操作e. 实现线性表的查找操作2.1.6 实现线性表的更新操作2.1.7 实现线性表的打印操作2.2 实现线性表的链式存储结构a. 定义链式存储结构的数据类型和长度b. 实现线性表的初始化操作c. 实现线性表的插入操作d. 实现线性表的删除操作e. 实现线性表的查找操作2.2.6 实现线性表的更新操作2.2.7 实现线性表的打印操作2.3 实现线性表的其他操作a. 实现线性表的长度计算b. 实现线性表的合并操作c. 实现线性表的排序操作3.实验步骤3.1 初始化线性表a. 选择合适的存储结构b. 设置线性表的初始状态c. 完成线性表的初始化工作3.2 插入操作a. 根据线性表的存储结构选择插入点b. 将要插入的元素放入插入点位置c. 调整线性表的长度和位置3.3 删除操作a. 根据线性表的存储结构选择删除点b. 删除指定位置的元素c. 调整线性表的长度和位置3.4 查找操作a. 根据线性表的存储结构选择查找方法b. 实现线性表的按值查找3.4.3 实现线性表的按位置查找3.5 更新操作a. 根据线性表的存储结构选择更新点b. 更新指定位置的元素c. 调整线性表的长度和位置3.6 打印操作a. 根据线性表的存储结构选择打印方法b. 实现线性表的打印功能4.实验结果4.1 实现了线性表的顺序存储结构,包括初始化、插入、删除、查找、更新和打印功能4.2 实现了线性表的链式存储结构,包括初始化、插入、删除、查找、更新和打印功能4.3 实现了线性表的其他操作,包括长度计算、合并和排序操作5.实验总结5.1 通过本次实验,掌握了线性表的基本概念和操作方法5.2 熟悉了线性表的顺序存储结构和链式存储结构的实现方式5.3 熟练使用了线性表的各种基本操作算法附件:●附件1:代码实现●附件2:实验数据法律名词及注释:1.著作权:著作权是指作者对其创作的文学、艺术和科学等作品享有的法律权利。
线性表的实验报告
线性表的实验报告线性表的实验报告概述:线性表是一种常见的数据结构,它是由一组具有相同数据类型的元素组成的序列。
本次实验旨在通过实际操作线性表,掌握线性表的基本操作以及了解其应用场景。
实验目的:1. 理解线性表的概念和基本操作;2. 掌握线性表的顺序存储结构和链式存储结构;3. 熟悉线性表的常见应用场景。
实验材料:1. 计算机;2. 编程软件(如C、C++、Java等);3. 实验教材或参考资料。
实验步骤:一、线性表的顺序存储结构实验1. 创建一个空的线性表;2. 向线性表中插入若干元素;3. 删除线性表中的某个元素;4. 根据索引查找线性表中的元素;5. 遍历线性表,输出所有元素。
二、线性表的链式存储结构实验1. 创建一个空的链表;2. 向链表中插入若干节点;3. 删除链表中的某个节点;4. 根据节点值查找链表中的节点;5. 遍历链表,输出所有节点。
实验结果:1. 顺序存储结构实验结果:- 成功创建空的线性表;- 成功插入若干元素;- 成功删除某个元素;- 成功根据索引查找元素;- 成功遍历线性表,输出所有元素。
2. 链式存储结构实验结果:- 成功创建空的链表;- 成功插入若干节点;- 成功删除某个节点;- 成功根据节点值查找节点;- 成功遍历链表,输出所有节点。
实验分析:1. 顺序存储结构适用于元素个数固定或变化不大的情况,插入和删除操作需要移动大量元素,效率较低;2. 链式存储结构适用于元素个数不固定的情况,插入和删除操作只需修改指针,效率较高;3. 线性表的应用场景包括但不限于:图书馆图书管理系统中的图书列表、学生信息管理系统中的学生列表等。
实验总结:通过本次实验,我深入了解了线性表的概念、基本操作以及两种常见存储结构。
顺序存储结构适用于元素个数固定的情况,而链式存储结构适用于元素个数不固定的情况。
线性表在实际应用中有着广泛的应用场景,如图书馆管理系统、学生信息管理系统等。
在以后的学习和工作中,我将灵活运用线性表,为解决实际问题提供便利。
实验一线性表操作实验报告
实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作,包括插入、删除、查找等。
3.通过实验,提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。
线性表具有以下特点:1.元素之间一对一的顺序关系。
2.除第一个元素外,每个元素都有一个直接前驱。
3.除最后一个元素外,每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。
节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。
3.删除节点:删除链表中的一个指定节点。
4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。
5.遍历链表:从头节点开始,依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。
3.删除节点结果:我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。
查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。
遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。
通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。
数据结构线性表实验报告五篇
数据结构线性表实验报告五篇第一篇:数据结构线性表实验报告实验报告课程名:数据结构实验名:线性表及其操作姓名:班级:学号:撰写时间:2014.09.24一实验目的与要求1.掌握线性表的实现2.掌握线性表的基本操作的实现二实验内容• 分别完成线性表的顺序表示及链式表示• 在两种表示上, 分别实现一些线性表的操作, 至少应该包括–在第i个位置插入一个元素–删除第i个元素–返回线性表长–返回第i个元素的值三实验结果与分析#include #include //---------线性表链式表示-----------struct V//声明一个结构体类型struct V { int value;struct V * next;//定义结构体变量};void PrintLink(struct V*p)//定义一个结构体指针{ while(p!=NULL)//只要指针指向的变量不为NULL;就会一直循环链表指向下一个结构体{printf(“%d, ”,(*p).value);p=(*p).next;//指针指向下一个结构体} printf(“n”);} void Link(){struct V*head;head=(struct V*)malloc(sizeof(struct V));//开辟一个长度为size的内存(*head).value=-100;//表头为-100(*head).next=NULL;printf(“------------线性表链式表示------------n”);int i,n=10;struct V*p=head;printf(“10个数据:n”);for(i=0;i(*p).next=(struct V*)malloc(sizeof(struct V));p=(*p).next;(*p).value=2*i;(*p).next=NULL;} PrintLink(head);//调用PrintLink函数printf(“删除第四个数据:n”);int k=4;p=head;for(i=1;ip=(*p).next;} struct V*temp=(*p).next;//k表示插入和删除的位置(*p).next=(*temp).next;free(temp);PrintLink(head);printf(“插入第十个数据:n”);k=10;p=head;for(i=1;ip=(*p).next;} temp=(*p).next;(*p).next=(struct V*)malloc(sizeof(struct V));(*(*p).next).value=-99;(*(*p).next).next=temp;PrintLink(head);}//---------线性表顺序表示-----------void seq1(){ int i,n=10,k=4;int a[10];//---------输出数组元素------------printf(“-------------线性表顺序表示---------n”);for(i=0;ia[i]=i;} printf(“数组元素为:n”);for(i=0;iprintf(“%3d”,a[i]);} printf(“n”);//--------插入一个数组元素---------int m=n+1,j=12;//插入元素12 int b[20];for(i=0;i if(i{b[i]=a[i];}else if(i==k){b[i]=j;}else{b[i]=a[i-1];} } printf(“输出插入一个元素的数组:n”);for(i=0;i{if(i{c[i]=a[i];}else{c[i]=a[i+1];} } printf(“输出删除一个元素的数组:n”);for(i=0;i printf(“数组元素为:n”);for(i=1;i<=a[0];i++){a[i]=i;} for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-----在k 位置插入一个元素------------for(i=a[0];i>=k;i--){a[i+1]=a[i];} a[k]=-100;++a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-------在k---------------for(i=0;i>k;i++){a[i]=a[i+1];} a[k]=-1;a[0]=n;--a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);} int main(int argc,char *argv[]){ seq1();seq2();Link();return 0;} 图1:实验结果截图实验分析:已在程序中按规定格式标注。
实验二-顺序存储的线性表实验报告
实验二-顺序存储的线性表实验报告宁波大红鹰学院实验报告实验名称:实验二顺序存储的线性表学院:信息工程学院专业:信息管理与信息系统年级:2012级小组成员1:于益锋学号:1211060544 职责:编程和报告设计小组成员2:学号:职责:小组成员3:学号:职责:实验时间:年月日实验类型:综合性实验地点:XX—405 成绩:指导教师签字:实验报告基本内容要求:一、实验目的和要求;二、实验内容和原理;三、主要仪器设备;四、操作方法与实验步骤;五、实验数据记录和处理;六、实验结果与分析;七、讨论、心得一、实验目的1.复习并掌握算法设计的要点2.了解线性表的逻辑结构特性,以及这种特性在计算机内的两种存储结构。
3. 重点是线性表的基本操作在两种存储结构上的实现;本次实验以顺序存储的操作为侧重点;并进一步学习结构化的程序设计方法。
二、实验内容1、课堂讨论1)数据结构是抽象的一种组织,是由数据类型组织成的。
数据类型是组成数据结构的元素。
2)线性结构是最简单最常用的一种数据结构,线性结构的特点是结构中的元素之间满足线性关系,按这个关系可以把所有元素排成一个线性序列.线性表,串,栈和队列都属于线性结构.而非线性结构是指在该类结构中至少存在一个数据元素,它具有两个或者两个以上的前驱或后继.如树和二叉树等3)目的是评价算法的效率,通过评价可以选用更加好更加适合的算法来完成4) O(m*n);O(n²)三、主要仪器设备计算机四、实验步骤(将2、3的源程序粘贴进来)2.#include<stdio.h>#define MAXSIZE 20typedef struct{int a[MAXSIZE];int length;}SeqList;int main(){int i=0,x;int min;printf("请输入原始数据(输入0表示结束):\n");while(1){scanf("%d",&x);if(x==0)break;else L.a[i]=x;i++;}L.length=i;min=L.a[0];for(i=1;i<L.length;i++)if(min>L.a[i])min=L.a[i];printf("这%d个数中最小的数为:%d\n",L.length,min); }3.#include<stdio.h>#define MAXSIZE 20typedef struct{int a[MAXSIZE];int length;}SeqList;int main(){int i=0,j,x;int min;printf("请输入原始数据(输入0表示结束):\n");while(1){scanf("%d",&x);if(x==0)break;else L.a[i]=x;i++;}L.length=i;printf("请输入需要删除的元素:");scanf("%d",&x);for(i=0;i<L.length;i++)if(L.a[i]==x){for(j=i;j<L.length-1;j++)L.a[j]=L.a[j+1];L.length--;i--;}printf("删除元素后的顺序表为:\n");for(i=0;i<L.length;i++)printf("%d",L.a[i]);}五、实验结果(写出1的题目及答案,粘贴2、3的截图。
数据结构线性表单链表实验报告
数据结构实验报告班级姓名同组者/ 成绩日期2020.3.25指导教师实验名称线性表及其应用一、实验目的:1、深刻理解线性表的逻辑特性及其顺序、链式存储方式的特点。
2、熟练掌握线性表的常用操作(建立、插入、删除、遍历等)在顺序、链式存储上的实现。
3、加深对C/C++、Java等编程语言的相关知识点的理解(如结构体/类、指针/引用、函数/方法、引用参数等)。
二、实验内容:1、题目根据给定的整型数组,以尾插法建立一个单链表,并实现以下操作:①查找:输入一个欲查找的整数,找到则显示第一个相匹配的整数在单链表中所处的位置,若不存在,则显示提示信息。
②删除:输入一个欲删除的整数e,若存在则在单链表中删除第一个值为e的元素。
③插入:输入一个欲插入位置i和欲插入元素e,将e插入到第i个整数之前(注意i的合法性)。
源码#include<stdio.h>#include<stdlib.h>typedef int Elemtype;typedef int Status;typedef struct node// 定义存储节点{int data;// 数据域struct node *next;// 结构体指针} *linklist,node;//结构体变量,结构体名称linklist creat (int n)//创建单链表{linklist head,r,p;// 定义头指针r,p,指针int x,i;head=(node *)malloc(sizeof(node));// 生成头结点r=head;//r指向头结点printf(" 输入数字:\n");for(i=n;i>0;i--)//for循环用于生成第一个节点并读入数据{scanf("%d",&x);p=(node *)malloc(sizeof(node));p->data=x;//读入第一个节点的数据r->next=p;//把第一个节点连在头结点的后面r=p;//循环以便于生成第二个节点}r->next=0;//生成链表后的断开符return head;// 返回头指针}void output (linklist head) //输出链表{linklist p;p=head->next;do{printf("%3d",p->data);p=p->next;}while(p);printf("\n");}Status insert ( linklist &l,int i, Elemtype e)// 插入操作{int j=0;linklist p = l,s;while(j<i-1 && p){p=p->next;++j;}if(!p || j>i-1)return -1;else{s=(node *)malloc(sizeof(node));s->data=e;s->next=p->next;p->next=s;return 1;}}Status delect ( linklist &l,int i, Elemtype &e) //删除操作{int j=0;linklist p=l,q;while(j<i-1 && p->next){p=p->next;++j;}if(!p->next || j>i-1)return -1;else{q=p->next;p->next=q->next;e=q->data;free(q);return 1;}}void combine(linklist la,linklist lb)//合并单链表{node *pa,*pb,*pc;linklist lc;pa=la->next;pb=lb->next;lc=pc=la;while(pa && pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else{pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;free(lb);}Status GetElem(linklist l,int i,Elemtype &e )//查找操作{linklist p;int j;p=l->next;j=1;while(p && j<i){p=p->next;++j;}if(!p || j>i)return -2;e=p->data;return e;}void main(){linklist la,lb;int n;int i,j;Elemtype e;printf(" 请输入第一个链表:\n");printf(" 输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf(" 输出链表:\n");output(la);printf(" 请输入要查找元素的位置:\n");scanf("%d",&i);j=GetElem(la,i,e);printf(" 所要查找的元素是%d\n",j);printf(" 请输入插入位置和元素:\n");scanf("%d%d",&i,&e);insert(la,i,e);printf(" 插入后的链表:\n");output(la);printf(" 请输入要删除的位置:\n");scanf("%d",&i);delect(la,i,e);printf(" 删除的那个元素是:%d\n",e);printf(" 输出删除后的顺序表:\n");output(la);printf(" 请输入第一个非递减链表:\n");printf(" 输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf(" 输出链表:\n");output(la);printf(" 请输入第二个非递减链表:\n");printf(" 输入链表元素个数:\n");scanf("%d",&n);lb=creat(n);printf(" 输出链表:\n");output(lb);combine(la,lb);printf(" 输出合并后的链表:\n");output(la);}运行结果:2、题目分别创建两个有序的顺序表(每个表的元素个数及每个元素的值在运行时由键盘输入),现将两个有序表合并,并保证新表依然为有序的顺序表。
线性表实验报告
线性表实验报告导言:线性表是数据结构中最基本也是最常用的一种结构之一。
它以一种线性的方式存储和组织数据,简单而高效。
本实验旨在通过对线性表的实践操作,加深对线性表概念的理解,并掌握其基本操作。
实验目的:1. 了解线性表的基本概念和特点;2. 掌握线性表的基本操作,如插入、删除、查找等;3. 熟悉线性表的顺序存储和链式存储结构;4. 学会通过编程实现线性表的基本操作。
实验内容:本次实验分为两个部分,分别是线性表的顺序存储和链式存储结构。
一、顺序存储结构的线性表操作1. 初始化线性表:定义一个固定大小的数组,用于存储线性表中的元素;2. 插入元素:从表尾开始,逐个向前移动元素,为新元素腾出位置;3. 删除元素:从指定位置开始,逐个向后移动元素,覆盖待删除元素;4. 查找元素:按照线性表的顺序依次比较元素,直到找到目标元素或遍历结束;5. 获取表长度:通过记录插入和删除操作的次数,得到线性表的长度。
二、链式存储结构的线性表操作1. 定义结点:创建一个结点类,包含数据域和指向下一结点的指针;2. 初始化链表:定义一个头指针,将其初始化为 NULL,表示链表为空;3. 插入元素:找到插入位置的前一个结点,将新结点插入到其后面;4. 删除元素:找到待删除结点的前一个结点,将其指针指向待删除结点的下一个结点;5. 查找元素:从链表头部开始遍历,逐个比较结点中的数据,直到找到目标元素或遍历结束;6. 获取表长度:通过遍历链表中的结点,计数来获取表长度。
实验过程:1. 根据实验目的,在 C/C++ 环境下创建一个项目,并命名为"LinearList";2. 依次完成顺序存储结构和链式存储结构的线性表操作函数的编写;3. 调用这些函数,对线性表进行初始化、插入、删除、查找等操作;4. 验证线性表操作的正确性,并检查函数是否能正确处理各种边界情况;5. 根据实验内容,编写实验报告,记录实验过程和结果。
数据结构线性表实验报告
数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法,并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、实验内容(一)线性表的顺序存储结构顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。
其特点是逻辑上相邻的元素在物理位置上也相邻,便于随机存取,但插入和删除操作需要移动大量元素,效率较低。
(二)线性表的链式存储结构链表是通过指针将一组零散的存储单元链接成一个线性序列。
常见的链表有单链表、双向链表和循环链表。
链表的插入和删除操作只需修改指针,无需移动元素,但随机存取效率较低。
(三)线性表的基本操作实现1、初始化线性表2、销毁线性表3、清空线性表4、判断线性表是否为空5、获取线性表的长度6、获取指定位置的元素7、查找指定元素在线性表中的位置8、在线性表指定位置插入元素9、删除线性表指定位置的元素四、实验步骤(一)顺序表的实现1、定义顺序表的结构体,包括数据存储数组和表的长度。
2、实现顺序表的初始化函数,分配初始存储空间并设置表长度为0。
3、销毁顺序表函数,释放存储空间。
4、清空顺序表函数,将表长度置为 0。
5、判断顺序表是否为空,根据表长度判断。
6、获取顺序表长度,直接返回表长度。
7、获取指定位置元素,检查位置合法性后返回对应元素。
8、查找指定元素位置,遍历表进行比较。
9、插入元素函数,检查插入位置合法性,若合法则移动后续元素,插入新元素并更新表长度。
10、删除元素函数,检查删除位置合法性,若合法则移动后续元素,更新表长度。
(二)链表的实现1、定义链表节点结构体,包含数据域和指针域。
2、实现链表的初始化函数,创建头节点。
3、销毁链表函数,遍历链表释放节点内存。
4、清空链表函数,遍历链表删除节点但保留头节点。
5、判断链表是否为空,检查头节点的指针域是否为空。
线性表与链表实验报告
数据结构实验报告实验0:顺序表与链表专业:班级:姓名:学号:指导教师:日期:一、实验目的(1)掌握顺序表的存储结构形式及其描述和基本运算的实。
(2)熟练掌握动态链表结构及有关算法的设计。
(3)掌握用链表表示特定形式的数据的方法,并能编写出有关运算的算法。
(4)理解单循环链表及双循环链表的特点。
二、实验内容(1)顺序表的应用(2)链表的应用三、需求分析1.输入的形式和输入值的范围2.建立链表时输入的都是整数,输入0代表输入的结束,插入元素时需要输入插入的位置和元素的值,删除元素时输入删除元素的值。
3.输出形式4.所有操作在出现错误时都会有提示,并且在任意一个操作结束后都会输出操作后的链表。
5.程序所能达到的功能6.完成链表的生成,任意位置插入元素、删除,实现链表数据的排序,删除链表中相同的元素,并且比较两个链表是否相等以及将两链表合成一个有序的链表。
7. 4.测试数据:见第八部分。
四、概要设计实验一:(1) 本程序包含的函数如下:其中main函数负责操作其他的函数。
(2)各函数的功能设计为:Creat(student & L):建立一个链表L(尾部插入建立的链表),并且返回这个链表的头指针。
find(student L,int e):在链表L中寻找一样元素e。
print(student L):依次输出链表 L 的内容。
insert(student & L):插入元素。
spilt(student & L):从后向前寻找奇数在偶数前的情况,如果一个奇数或偶数之后还是一个奇数和偶数,就让代表奇数和偶数的变量自增,在每次所有符合连续情况的奇偶数交换完成后,偶数要从新计数。
symmetry(student L):判断是否是对称的链表。
unite(student L1, student L2, Student & L3):将链表A和B合成一个非递减的链表,返回新链表的头指针.五、详细设计(1)结点类型和指针类型:typedef struct{int *elem;//数组指针elem指示线性表的基地址。
线性表实验报告:针对链式或顺序存储的线性表实现指定的操作(二份)修改
实验报告的基本内容、格式已经给出,请同学们参考书写。
其中,第一项可补充,第二、三项不修改,第四项为可选项,第六项为参考程序,第五、七、八项需自己上机调试程序书写。
注意:红色字体为提示内容,大家不要往实验报告上抄。
实验一:线性表的顺序存储结构的表示和实现——学生成绩管理系统一、实验目的:通过上机调试程序,充分理解和掌握有关线性表的定义、实现及操作。
二、实验环境Win2003/win xp +Visual C++三、基本要求:利用顺序表来制作一个学生成绩表1、建立头文件,包含数据类型定义和基本操作。
2、建立程序文件利用顺序表表完成一个班级的一个学期的所有课程的管理:能够增加、删除、修改学生的成绩记录。
四、简要的需求分析与概要设计(本项为可选项,选作时参考课本P230:“程序的规范说明”书写)五、详细的算法描述:六、实验步骤(以下为参考程序,已经调试运行通过)#include<iostream>#include<fstream>using namespace std;const int LISTINITSIZE=100;const int LISTINCREMENT=10;struct student{char no[20];char name[20];int english;int math;};typedef student elemtype;struct sqlist{elemtype *elem;int length;int listsize;int incrementsize;};//初始化顺序表lvoid initlist(sqlist &l,int maxsize=LISTINITSIZE,int incresize=LISTINCREMENT){l.elem=new elemtype[maxsize];l.length=0;l.listsize=maxsize;l.incrementsize=incresize;}//当线性表空间不足时,进行扩容操作void increment(sqlist &l){elemtype *a=new elemtype[l.listsize+l.incrementsize];for(int i=0;i<l.length ;i++){a[i]=l.elem[i];}delete []l.elem;l.elem=a;l.listsize+=l.incrementsize;}//在第i个元素之前插入元素evoid insertlist(sqlist &l,int i,elemtype e){//判断i的合法性1<=i<=l.length+1if(i<1||i>l.length +1){cout<<"插入位置不合法";exit(0);}//判断顺序表l是否有空闲空间if(l.length==l.listsize ) increment(l);//移动元素for(int j=l.length -1;j>=i-1;j--){l.elem [j+1]=l.elem [j];}//插入元素e到第i个元素之前l.elem [i-1]=e;//修改顺序表的长度l.length ++;}//输出线性表中指定元素evoid outputelem(elemtype e){cout<<"学号:"<<e.no<<" 姓名:"<< <<" 英语:"<<e.english <<" 数学:"<<e.math <<endl;}//输出整个线性表void outputlist(sqlist l){for(int i=0;i<l.length ;i++){outputelem(l.elem [i]);}}//在顺序表l中删除第i个元素,用e带回其值void deletelist(sqlist &l,int i,elemtype &e){//判断i值的合法性1<=i<=l.lengthif(i<1 || i>l.length ){cout<<"i值不合法!";exit(0);}//取被删的元素置于e中e=l.elem [i-1];//移动元素for(int j=i;j<l.length ;j++){l.elem [j-1]=l.elem [j];}//修改顺序表的长度l.length --;}//用f替换顺序表的第i个元素Void tihuanlist(sqlist &l,int i,elemtype &e,elemtype &f){//判断i值的合法性1<=i<=l.lengthif(i<1 || i>l.length ){cout<<"i值不合法!";exit(0);}//取被删的元素置于e中e=l.elem [i-1];将e 和f的值互换F=e;}//根据学号查找学生的位序int locateelembyno(sqlist l,elemtype e){for(int i=0;i<l.length ;i++){if(strcmp(l.elem [i].no ,e.no)==0)return i+1;}return 0;}//根据位序查找学生的信息elemtype locateelembypos(sqlist l,int i){return l.elem [i-1];}//将当前顺序表中的信息保存void save(sqlist l){ofstream out;out.open ("scorefile",ios::binary);for(int i=0;i<l.length;i++)out.write((char *)&l.elem[i],sizeof student);out.close ();}// 读取scorefile文件中的数据到顺序表l中,如果文件不存在,则创建该文件void openorcreate(sqlist &l){//以读取的方式打开指定的文件scorelist,若存在,则将文件中的内容//读出并插入到顺序表l中,若不存在,则根据用户的选择,决定是否创建该文件ifstream in;elemtype e;char answer;int i=0;in.open ("e:\\scorelist",ios_base::binary);{while(in.peek()!=EOF){in.read((char *)&e,sizeof(student));insertlist(l,l.length +1,e);}}else{//创建该文件cout<<"文件scorelist不存在,要创建它吗?(y/n)";cin>>answer;if(answer=='Y' || answer=='y'){ofstream out("e:\\scorelist",ios_base::binary);if(out){do{cout<<"请输入学生的学号、姓名、英语成绩和数学成绩:"<<endl;cin>>e.no>>>>e.english>>e.math;out.write((char *)&e,sizeof(elemtype));insertlist(l,++i,e);cout<<"要继续输入吗?(y/n):";cin>>answer;}while(answer=='Y' || answer=='y');}else{cout<<"文件打开失败!";return;}}elsereturn;}}//逆置顺序表lvoid invertlist(sqlist &l){elemtype temp;for(i=0;i<l.length/2;i++){temp=l.elem [i];l.elem [i]=l.elem [l.length -i-1];l.elem [l.length -i-1]=temp;}}//将顺序表l中前m个元素和后n个元素互换void exchange1(sqlist &l,int m,int n){int k,j;elemtype temp;for(k=1;k<=n;k++){temp=l.elem [m+k-1];for(j=m+k-2;j>=k-1;j--)l.elem [j+1]=l.elem [j];l.elem [k-1]=temp;}}//将数组R中下标从s到t的元素逆置void invert(elemtype R[],int s,int t){elemtype temp;for(int k=s;k<=(s+t)/2;k++){temp=R[k];R[k]=R[t-k+s];R[t-k+s]=temp;}}//将顺序表l中前m个元素和后n个元素互换void exchange2(sqlist &l,int m,int n){invert(l.elem ,0,m+n-1);invert(l.elem ,0,n-1);invert(l.elem ,n,m+n-1);}//将非纯集合变成纯集合void purge(sqlist &lb){sqlist la;initlist(la);int i,j;for(i=0;i<lb.length ;i++){for(j=0;j<la.length ;j++)if(strcmp(lb.elem [i].no,la.elem [j].no)==0) break;if(j==la.length ){la.elem [la.length ]=lb.elem [i];la.length ++;}}delete []lb.elem ;lb.elem=la.elem;lb.length=la.length;}#include"SqList_h.h"#include<iostream>using namespace std;void main(){sqlist l;initlist(l);elemtype e;int m,n;int choice,pos;do{cout<<endl;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<<"请选择要进行的操作(1--10):";cin>>choice;switch(choice){case 1:cout<<"请输入要插入学生的学号、姓名、英语、数学:"<<endl;cin>>e.no>>>>e.english>>e.math;cout<<"请输入插入位置:"<<endl;cin>>pos;insertlist(l,pos,e);break;case 2:cout<<"请输入要删除学生的学号:";cin>>e.no;pos=locateelembyno(l,e);if(pos==0){cout<<"要删除的学生不在该表中.";}else{cout<<"要删除的是表中的第"<<pos<<"个学生。
线性表的基本操作实验报告
线性表的基本操作实验报告实验一:线性表的基本操作【实验目的】学习掌握线性表的顺序存储结构、链式存储结构的设计与操作。
对顺序表建立、插入、删除的基本操作,对单链表建立、插入、删除的基本操作算法。
【实验内容】1.顺序表的实践1) 建立4个元素的顺序表s=sqlist[]={1,2,3,4,5},实现顺序表建立的基本操作。
2) 在sqlist []={1,2,3,4,5}的元素4和5之间插入一个元素9,实现顺序表插入的基本操作。
3) 在sqlist []={1,2,3,4,9,5}中删除指定位置(i=5)上的元素9,实现顺序表的删除的基本操作。
2.单链表的实践3.1) 建立一个包括头结点和4个结点的(5,4,2,1)的单链表,实现单链表建立的基本操作。
2) 将该单链表的所有元素显示出来。
3) 在已建好的单链表中的指定位置(i=3)插入一个结点3,实现单链表插入的基本操作。
4) 在一个包括头结点和5个结点的(5,4,3,2,1)的单链表的指定位置(如i=2)删除一个结点,实现单链表删除的基本操作。
5) 实现单链表的求表长操作。
【实验步骤】1.打开VC++。
2.建立工程:点File->New,选Project标签,在列表中选Win32 Console Application,再在右边的框里为工程起好名字,选好路径,点OK->finish。
至此工程建立完毕。
3.创建源文件或头文件:点File->New,选File标签,在列表里选C++ Source File。
给文件起好名字,选好路径,点OK。
至此一个源文件就被添加到了刚创建的工程之中。
4.写好代码5.编译->链接->调试1、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef int ElemType;typedef int Status;typedef struct {ElemType *elem;int length;int listsize;} SqList;Status InitList( SqList &L ) {int i,n;L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof (ElemType)); if (!L.elem) return(OVERFLOW);printf("输入元素的个数:");scanf("%d",&n);printf("输入各元素的值:");for(i=0;i<n;i++)scanf("%d",&L.elem[i]);L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L, int i, ElemType e) {ElemType *newbase,*p,*q;if (i < 1 || i > L.length+1) return ERROR;if (L.length >= L.listsize) {newbase = (ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof (ElemType));if (!newbase) return(OVERFLOW);L.elem = newbase;L.listsize += LISTINCREMENT;}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;}void VisitList(SqList L){ int i;for(i=0;i<L.length;i++)printf("%d\t",L.elem[i]);}void main(){int i,e;SqList L;InitList(L) ;VisitList(L);printf("输入插入位置和值:");scanf("%d,%d",&i,&e);printf("插入元素后,表中的值:"); ListInsert(L,i,e);VisitList(L);printf("输入删除位置:");scanf("%d",&i);printf("删除元素后,表中的值:"); ListDelete(L,i,e);VisitList(L);}2、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef int ElemType;typedef int Status;typedef struct {ElemType *elem;int length;int listsize;} SqList;Status InitList( SqList &L ) {int i,n;L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof (ElemType)); if (!L.elem) return(OVERFLOW);printf("输入元素的个数:");scanf("%d",&n);printf("输入各元素的值:");for(i=0;i<n;i++)scanf("%d",&L.elem[i]);L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}void VisitList(SqList L){ int i;for(i=0;i<L.length;i++)printf("%d\t",L.elem[i]);}void main(){SqList L;InitList(L) ;VisitList(L);}3、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define ERROR 0typedef int Status;typedef int ElemType;typedef struct LNode {ElemType data;struct LNode *next;} LNode,*LinkList;Status ListInsert(LinkList &L,int i,ElemType e){ LinkList p,s;int j;p=L;j=0;while(p&&j<i-1) {p=p->next;++j;}if(!p||j>i) return ERROR;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDelete(LinkList &L,int i,ElemType &e){ LinkList p,q;int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1) return ERROR;q=p->next;p->next=q->next;e=q->data;free(q);return OK;}Status CreateList(LinkList &L, int n) {int i;LinkList p;L = (LinkList) malloc (sizeof (LNode));L->next = NULL;printf("输入元素的个数和相应值:");scanf("%d",&n);for (i = n; i > 0; --i) {p = (LinkList) malloc (sizeof (LNode));//生成新结点 scanf("%d",&p->data);//输入指针p指出i=n时所对应的数值 p->next = L->next;L->next = p;}return OK;}void VisitList(LinkList L){LNode *p;p=L->next;while(p){printf("%d\t",p->data);p=p->next;}}void main(){int i,n;LinkList L;ElemType e;CreateList(L,n);VisitList(L);printf("输入插入位置和值:");scanf("%d,%d",&i,&e);printf("插入元素后,表中的值:");ListInsert(L,i,e);VisitList(L);printf("输入删除位置:");scanf("%d",&i);printf("删除元素后,表中的值:");ListDelete(L,i,e);VisitList(L);}【实验心得】今天是本学期的第一次上机实验课,老师先给我们发了本次上机的内容以及部分实验代码,因为是第一次接触这门课程,还没有理解这门学科的特点和学习方法,所以同学们都觉得无从下手。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
、格式已经给出,请同学们参考书写。
其中,第一项可补充,第二、三项不修改,第四项为可选项,第六项为参考程序,第五、七、八项需自己上机调试程序书写。
注意:红色字体为提示内容,大家不要往实验报告上抄。
实验一:线性表的顺序存储结构的表示和实验——学生成绩管理系统一、实验目的:通过上机调试程序,充分理解和掌握有关线性表的定义、实现及操作。
二、实验环境Win2003/win xp +Visual C++三、基本要求:利用顺序表来制作一个学生成绩表1、建立头文件,包含数据类型定义和基本操作。
2、建立程序文件利用顺序表表完成一个班级的一个学期的所有课程的管理:能够增加、删除、修改学生的成绩记录。
四、简要的需求分析与概要设计(本项为可选项,选作时参考课五、详细的算法描述:六、实验步骤(以下为参考程序,已经调试运行通过)#include<iostream>#include<fstream>using namespace std;const int LISTINITSIZE=100;const int LISTINCREMENT=10;struct student{char no[20];char name[20];int english;int math;};typedef student elemtype;struct sqlist{elemtype *elem;int length;int listsize;int incrementsize;};//初始化顺序表lvoid initlist(sqlist &l,int maxsize=LISTINITSIZE,int incresize=LISTINCREMENT){l.elem=new elemtype[maxsize];l.length=0;l.listsize=maxsize;l.incrementsize=incresize;//当线性表空间不足时,进行扩容操作void increment(sqlist &l){elemtype *a=new elemtype[l.listsize+l.incrementsize];for(int i=0;i<l.length ;i++){a[i]=l.elem[i];}delete []l.elem;l.elem=a;l.listsize+=l.incrementsize;}//在第i个元素之前插入元素evoid insertlist(sqlist &l,int i,elemtype e){//判断i的合法性1<=i<=l.length+1if(i<1||i>l.length +1){cout<<"插入位置不合法";exit(0);}//判断顺序表l是否有空闲空间if(l.length==l.listsize ) increment(l);//移动元素for(int j=l.length -1;j>=i-1;j--){l.elem [j+1]=l.elem [j];}//插入元素e到第i个元素之前l.elem [i-1]=e;//修改顺序表的长度l.length ++;}//输出线性表中指定元素evoid outputelem(elemtype e){cout<<"学号:"<<e.no<<" 姓名:"<< <<" 英语:"<<e.english <<" 数学:"<<e.math <<endl;}//输出整个线性表void outputlist(sqlist l){for(int i=0;i<l.length ;i++){outputelem(l.elem [i]);}}//在顺序表l中删除第i个元素,用e带回其值void deletelist(sqlist &l,int i,elemtype &e){//判断i值的合法性1<=i<=l.lengthif(i<1 || i>l.length ){cout<<"i值不合法!";exit(0);}//取被删的元素置于e中e=l.elem [i-1];//移动元素for(int j=i;j<l.length ;j++){l.elem [j-1]=l.elem [j];}//修改顺序表的长度l.length --;}//根据学号查找学生的位序int locateelembyno(sqlist l,elemtype e) {for(int i=0;i<l.length ;i++){if(strcmp(l.elem [i].no ,e.no)==0)return i+1;}return 0;}根据位序查找学生的信息elemtype locateelembypos(sqlist l,int i){return l.elem [i-1];}//将当前顺序表中的信息保存void save(sqlist l){ofstream out;out.open ("scorefile",ios::binary);for(int i=0;i<l.length;i++)out.write((char *)&l.elem[i],sizeof student);out.close ();}// 读取scorefile文件中的数据到顺序表l中,如果文件不存在,则创建该文件void openorcreate(sqlist &l){//以读取的方式打开指定的文件scorelist,若存在,则将文件//读出并插入到顺序表l中,若不存在,则根据用户的选择,决定是否创建该文件ifstream in;elemtype e;char answer;int i=0;in.open ("e:\\scorelist",ios_base::binary);if(in){while(in.peek()!=EOF){in.read((char *)&e,sizeof(student));insertlist(l,l.length +1,e);}}else{//创建该文件cout<<"文件scorelist不存在,要创建它吗?(y/n)";cin>>answer;if(answer=='Y' || answer=='y'){ofstream out("e:\\scorelist",ios_base::binary);if(out){do{cout<<"请输入学生的学号、姓名、英语成绩和数学成绩:"<<endl;cin>>e.no>>>>e.english>>e.math;out.write((char *)&e,sizeof(elemtype));insertlist(l,++i,e);cout<<"要继续输入吗?(y/n):";cin>>answer;}while(answer=='Y' || answer=='y');}else{cout<<"文件打开失败!";return;}}elsereturn;}}//逆置顺序表lvoid invertlist(sqlist &l){int i;elemtype temp;for(i=0;i<l.length/2;i++){temp=l.elem [i];l.elem [i]=l.elem [l.length -i-1];l.elem [l.length -i-1]=temp;}}//将顺序表l中前m个元素和后n个元素互换void exchange1(sqlist &l,int m,int n){int k,j;elemtype temp;for(k=1;k<=n;k++){temp=l.elem [m+k-1];for(j=m+k-2;j>=k-1;j--)l.elem [j+1]=l.elem [j];l.elem [k-1]=temp;}}//将数组R中下标从s到t的元素逆置void invert(elemtype R[],int s,int t) {elemtype temp;for(int k=s;k<=(s+t)/2;k++){temp=R[k];R[k]=R[t-k+s];R[t-k+s]=temp;}}//将顺序表l中前m个元素和后n个元素互换void exchange2(sqlist &l,int m,int n){invert(l.elem ,0,m+n-1);invert(l.elem ,0,n-1);invert(l.elem ,n,m+n-1);}//将非纯集合变成纯集合void purge(sqlist &lb){sqlist la;initlist(la);int i,j;for(i=0;i<lb.length ;i++){for(j=0;j<la.length ;j++)if(strcmp(lb.elem [i].no,la.elem [j].no)==0) break;if(j==la.length ){la.elem [la.length ]=lb.elem [i];la.length ++;}}delete []lb.elem ;lb.elem=la.elem;lb.length=la.length;}#include"SqList_h.h"#include<iostream>using namespace std;void main(){sqlist l;initlist(l);elemtype e;int m,n;int choice,pos;do{cout<<endl;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<<"请选择要进行的操作(1--10):";cin>>choice;switch(choice){case 1:cout<<"请输入要插入学生的学号、姓名、英语、数学:"<<endl;cin>>e.no>>>>e.english>>e.math;cout<<"请输入插入位置:"<<endl;cin>>pos;insertlist(l,pos,e);break;case 2:cout<<"请输入要删除学生的学号:";cin>>e.no;pos=locateelembyno(l,e);if(pos==0){cout<<"要删除的学生不在该表中.";}else{cout<<"要删除的是表中的第"<<pos<<"个学生。