数据结构实验一 实验报告
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一,它是一种有序的数据元素集合,其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式,其中顺序存储结构是最简单的一种,它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素,但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现,数组的长度应该大于等于线性表的长度,以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时,需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作:________在指定位置插入一个元素时,需要将插入位置之后的元素依次后移,给待插入的元素腾出位置。
●删除操作:________删除指定位置的元素时,需要将删除位置之后的元素依次前移,覆盖删除位置上的元素。
●修改操作:________修改指定位置的元素时,直接对该位置上的元素进行修改即可。
●查找操作:________根据指定的元素值,查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素,可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点:________可以快速地访问任意位置的元素,节省存储空间。
2.缺点:________插入和删除操作需要移动大量的元素,不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中,我们以顺序存储结构为基础,实现了线性表的增删改查操作,并进行了遍历操作。
通过实验,我们发现顺序存储结构在查询操作上有较好的性能,但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
数据结构实验报告2篇
数据结构实验报告数据结构实验报告精选2篇(一)实验目的:1. 熟悉数据结构的基本概念和基本操作;2. 掌握线性表、栈、队列、链表等经典数据结构的实现方法;3. 掌握数据结构在实际问题中的应用。
实验内容:本次实验主要包括以下几个部分:1. 线性表的实现方法,包括顺序表和链表,分别使用数组和链表来实现线性表的基本操作;2. 栈的实现方法,包括顺序栈和链式栈,分别使用数组和链表来实现栈的基本操作;3. 队列的实现方法,包括顺序队列和链式队列,分别使用数组和链表来实现队列的基本操作;4. 链表的实现方法,包括单链表、双链表和循环链表,分别使用指针链、双向链和循环链来实现链表的基本操作;5. 综合应用,使用各种数据结构来解决实际问题,例如使用栈来实现括号匹配、使用队列来实现马铃薯游戏等。
实验步骤及结果:1. 线性表的实现方法:a) 顺序表的基本操作:创建表、插入元素、删除元素、查找元素等;b) 链表的基本操作:插入节点、删除节点、查找节点等;c) 比较顺序表和链表的优缺点,分析适用场景。
结果:通过实验,确认了顺序表适用于频繁查找元素的情况,而链表适用于频繁插入和删除节点的情况。
2. 栈的实现方法:a) 顺序栈的基本操作:进栈、出栈、判空、判满等;b) 链式栈的基本操作:进栈、出栈、判空、判满等。
结果:通过实验,掌握了栈的基本操作,并了解了栈的特性和应用场景,例如括号匹配。
3. 队列的实现方法:a) 顺序队列的基本操作:入队、出队、判空、判满等;b) 链式队列的基本操作:入队、出队、判空、判满等。
结果:通过实验,掌握了队列的基本操作,并了解了队列的特性和应用场景,例如马铃薯游戏。
4. 链表的实现方法:a) 单链表的基本操作:插入节点、删除节点、查找节点等;b) 双链表的基本操作:插入节点、删除节点、查找节点等;c) 循环链表的基本操作:插入节点、删除节点、查找节点等。
结果:通过实验,掌握了链表的基本操作,并了解了链表的特性和应用场景。
数据结构实验-集合的并交差运算实验报告
实验报告实验课程:数据结构实验项目:实验一集合的并交差运算专业:计算机科学与技术班级:姓名:学号:指导教师:目录一、问题定义及需求分析(1)实验目的(2)实验任务(3)需求分析二、概要设计:(1)抽象数据类型定义(2)主程序流程(3) 模块关系三、详细设计(1)数据类型及存储结构(2)模块设计四、调试分析(1)调试分析(2)算法时空分析(3)经验体会五、使用说明(1)程序使用说明六、测试结果(1)运行测试结果截图七、附录(1)源代码一、问题定义及需求分析(1)实验目的设计一个能演示集合的并、交、差运算程序。
(2)实验任务1)采用顺序表或链表等数据结构。
2)集合的元素限定为数字和小写英文字母。
(3)需求分析:输入形式为:外部输入字符串;输入值限定范围为:数字和小写英文字母;输出形式为:字符集;程序功能:计算两个集合的交、并、差以及重新输入集合功能;二、概要设计:(1)抽象数据类型定义:线性表(2)主程序流程:调用主菜单函数初始化两个线性表作为集合给两个集合输入数据输出集合数据元素信息另初始化两个线性表创建选择功能菜单界面通过不同选项调用不同功能函数在每个功能函数里面加结束选择功能,实现循环调用功能菜单计算完毕退出程序;(3)模块关系:差运算并运算交运算新建集合结束/返回结束三、详细设计抽象数据类型定义:typedef struct{ElemType *elem;int length;int listsize;}SqList;存储结构:顺序表;模块1-在顺序表的逻辑为i的位置插入新元素e的函数;算法如下:/**在顺序表的逻辑为i的位置插入新元素e的函数**/Status ListInsert_Sq(SqList &L,int i,ElemType e){ElemType *newbase,*p,*q;if(i < 1 || i > L.length + 1) return 0; //i的合法值为(1 <= i <= L.length_Sq(L) + 1)if(L.length >= L.listsize){ //当前储存空间已满,增加分配newbase = (ElemType *)realloc(L.elem,(L.listsize + LISTINCREMENT) * sizeof(ElemType));if(!newbase) exit(-1); //储存分配失败L.elem = newbase; //新基址L.listsize += LISTINCREMENT; //增加储存容量}q = &(L.elem[i - 1]); //q为插入位置for(p = &(L.elem[L.length - 1]); p >= q; --p)(p + 1) = p; //插入位置及之后的元素往右移q = e; //插入e++L.length; //表长加1return 1;}模块二在顺序线性表L中查找第1个与e满足compare()的元素位序,若找到,则返回其在L中的位序,否则返回0算法如下:/**在顺序线性表L中查找第1个与e满足compare()的元素位序,若找到,则返回其在L中的位序,否则返回0**/int LocateElem_Sq(SqList L,ElemType e,Status(* compare)(ElemType,ElemType)){ElemType *p;int i;i = 1; //i的初值为第1个元素的位序p = L.elem; //p的初值为第1个元素的储存位置while(i <= L.length && !(* compare)(*p++,e))++i; //从表L中的第一个元素开始与e比较,直到找到L中与e相等的元素时返回该元素的位置if(i <= L.length) return i; //若i的大小小于表长,则满足条件返回ielsereturn 0; //否则,i值不满足条件,返回0}模块三集合交运算算法如下:/**求集合的交集的函数**/void Mix_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0; //将表Lc的长度设为0for(i = 1; i <= La.length; i++){ //依次查看表La的所有元素elem = La.elem[i-1]; //将表La中i位置的元素赋值给elemif(LocateElem_Sq(Lb,elem,Equal)) //在表Lb中查找是否有与elem相等的元素ListInsert_Sq(Lc,Lc.length+1,elem); //将表La与Lb 中共同的元素放在Lc中}}模块四集合并运算算法如下:/**求集合的并集的函数**/void Union_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length=0; //将表Lc的长度初设为0for(i = 0; i < La.length; i++) //先将表La 的元素全部复制到表Lc中Lc.elem[Lc.length++]=La.elem[i];for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //依次将表Lb 的值赋给elemif(!LocateElem_Sq(La,elem,Equal)) //判断表La 中是否有与elem相同的值ListInsert_Sq(Lc,Lc.length+1,elem); //若有的话将elem放入表Lc中}}模块五集合的差运算算法如下:/**求集合的差集函数**/void Differ_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0;for(i = 1; i <= La.length; i++){elem = La.elem[i-1]; //把表La 中第i个元素赋值给elemif(!LocateElem_Sq(Lb,elem,Equal)) //判断elem在表Lb中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem); //若有,则把elem放入表Lc中,否则,就不存放}for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //把表Lb 中第i个元素赋值给elemif(!LocateElem_Sq(La,elem,Equal)) //判断elem在表La中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem); //若有,则把elem放入表Lc中,否则,就不存放}}四、调试分析问题分析及解决:首先,在编写程序时没有设置线性表的初始长度,导致集合元素输入错误;然后通过#define LIST_INIT_SIZE 100和#define LISTINCREMENT 10解决;时空分析:int LocateElem_Sq(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))时间复杂度为O(n);Status ListInsert_Sq(SqList &L,int i,ElemType e) 时间复杂度为O(n);void Union_Sq(SqList La,SqList Lb,SqList &Lc) 时间复杂度为O(m*n);void Mix_Sq(SqList La,SqList Lb,SqList &Lc) 时间复杂度为O(m*n);void Differ_Sq(SqList La,SqList Lb,SqList &Lc) 时间复杂度为O(2*m*n);改进设想:当同时求两个以上的结合间的运算是需要先进性两个集合间的运算,然后在于另外的集合进行运算;若要同事进行多个集合的运算需要建立多个顺序表;经验体会:顺序表使用起来比较简单,但长度不可随意变化,适用于大量访问元素,而不适用于大量增添和删除元素;在内存中存储地址连续;五、使用说明第一步:点击运行按钮;第二步: 根据提示输入集合A(可以连续输入,只限输入小写字母和数字);第三步:程序自动显示输入结果;第四步:输入集合B(同第二步);第五步:跳出主菜单界面;第六步:根据选项输入对应运算项的数字序号;第七步:显示运算结果,并可继续进行选择运算还是退出;第八步:若继续运算则返回主菜单,否则退出;第九步:循环第六、七、八步,直至选择退出;六、测试结果输入界面:并运算结果:交运算结果:差运算结果:重新建立集合并运算:七、附录#include<stdio.h>#include<stdlib.h>#define LIST_INIT_SIZE 100//初始表空间大小#define LISTINCREMENT 10//表长增量typedef int Status; /**Status是函数类型**/typedef char ElemType;/*ElemType类型根据实际情况而定,这里假设为char*/typedef struct{ElemType *elem; /**储存空间基地址**/int length; /**当前长度**/int listsize;/**当前分配的储存容量(以sizeof(Elemtype)为单位)**/}SqList;SqList La,Lb,Lc,Ld;/**定义全局变量**//**构造一个空的线性表L**/Status InitList_Sq(SqList &L){L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if(!L.elem) exit(-1); /**储存分配失败**/L.length = 0;L.listsize = LIST_INIT_SIZE;/**初始储存容量**/return 1;}/**在顺序表的逻辑为i的位置插入新元素e的函数**/Status ListInsert_Sq(SqList &L,int i,ElemType e){ElemType *newbase,*p,*q;if(i < 1 || i > L.length + 1)return 0;if(L.length >= L.listsize)//当前储存空间已满,增加分配{newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT )*sizeof(ElemType));if(!newbase) exit(-1);//储存分配失败L.elem = newbase;L.listsize += LISTINCREMENT;//增加储存容量}q = &(L.elem[i - 1]);//q为插入位置for(p = &(L.elem[L.length - 1]); p >= q; --p)*(p + 1) = *p;//插入位置及之后的元素往右移*q = e;//插入e++L.length;return 1;}/**创建一个线性表,输入数据**/void CreateList_Sq(SqList &L){ElemType ch='\0';int inlist =0,j;while((ch) != '\n'){scanf("%c",&ch);//输入数据for(j = 0; j < L.length; j++)if(ch == L.elem[j])//判断表L中是否有与ch相等的元素 {inlist = 1; //若有,则inlist置1break; //跳出本轮循环}elseinlist =0; //否则inlist为0if(!inlist && ch != '\n')//若inlist为0且ch不为”\n” ListInsert_Sq(L,L.length+1,ch);//则将ch存入表L中 }}/*判断两元素是否相等,若相等则返回1;否则返回0*/Status Equal(ElemType a,ElemType b){if(a == b)return 1;//相等,返回1elsereturn 0;//否则,返回0}/*在顺序线性表L中查找第1个与e满足compare()的元素位序,若找到,则返回其在L中的位序,否则返回0*/int LocateElem_Sq(SqList L,ElemType e,Status(* compare)(ElemType,ElemType)){ElemType *p;int i;i = 1;p = L.elem;//p的初值为第1个元素的储存位置while(i <= L.length && !(* compare)(*p++,e))//循环查找表L 找出其中与e相等的元素的位置++i;if(i <= L.length)//若i小于表长return i;//则i满足条件,返回i的值elsereturn 0;//否则返回0}/*销毁线性表的函数*/Status Clear_Sq(SqList &L){ElemType elem;free(L.elem);L.elem = NULL;return 1;}/*打印顺序表函数*/void Print_Sq(SqList L){int i;for(i = 0; i < L.length; i++)printf("%2c",L.elem[i]);//通过for循环将表元素全部输出 if(L.length == 0) printf("空集");//若表长为0,则输出空表 printf("\n\t\t\t此集合中的个数 n = %d\n\n",L.length);}/*求集合的并集的函数*/void Union_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length=0; //将表Lc的长度初设为0for(i = 0; i < La.length; i++) //先将表La的元素全部复制到表Lc中Lc.elem[Lc.length++]=La.elem[i];for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //依次将表Lb 的值赋给elemif(!LocateElem_Sq(La,elem,Equal)) //判断表La 中是否有与elem相同的值ListInsert_Sq(Lc,Lc.length+1,elem); //若有的话将elem放入表Lc中}}/*求集合的交集的函数*/void Mix_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0; //将表Lc的长度设为0for(i = 1; i <= La.length; i++){ //依次查看表La的所有元素elem = La.elem[i-1]; //将表La中i位置的元素赋值给elemif(LocateElem_Sq(Lb,elem,Equal)) //在表La中查找是否有与elem相等的元素ListInsert_Sq(Lc,Lc.length+1,elem); //将表La与Lb中共同的元素放在Lc中}}/*求集合的差集函数*/void Differ_Sq(SqList La,SqList Lb,SqList &Lc){int i;ElemType elem;Lc.length = 0;for(i = 1; i <= La.length; i++){elem = La.elem[i-1]; //把表La中第i个元素赋值给elemif(!LocateElem_Sq(Lb,elem,Equal)) //判断elem在表Lb中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem);//若有,则把elem放入表Lc中,否则,就不存放}for(i = 1; i <= Lb.length; i++){elem = Lb.elem[i-1]; //把表Lb中第i个元素赋值给elem if(!LocateElem_Sq(La,elem,Equal)) //判断elem在表La中是否有相同的元素ListInsert_Sq(Lc,Lc.length+1,elem); //若有,则把elem放入表Lc中,否则,就不存放}}void Index_Sq(){//主菜单函数char s;int l=1;InitList_Sq(La);//初始化表Laprintf("\n\t\t 请输入集合A:");CreateList_Sq(La);//创建表Laprintf("\t\t\t集合A为");Print_Sq(La);printf("\n\n");InitList_Sq(Lb);//初始化表Lbprintf("\t\t 请输入集合B:");CreateList_Sq(Lb);//创建表Lbprintf("\t\t\t集合B为");Print_Sq(Lb);printf("\n\n");InitList_Sq(Lc);//初始化表LcInitList_Sq(Ld);//初始化表Ldwhile(l){printf("\t\t ******* 请输入您的操作选项 1、2、3、4. ****** \n\n");printf("\t\t 1、进行集合的并运算\n");printf("\t\t 2、进行集合的交运算\n");printf("\t\t 3、进行集合的差运算\n");printf("\t\t 4、重新建立两个集合\n");printf("\t\t\t");scanf("%c",&s);switch(s){case '1' : system("cls");Union_Sq(La,Lb,Lc);//调用集合的并运算函数printf("\t\t\t集合A与集合B的并集为:");print_Sq(Lc);printf("\n");break;case '2' :system("cls");Mix_Sq(La,Lb,Lc);//调用集合的交集运算函数printf("\t\t\t集合A与集合B的交集为:");print_Sq(Lc);printf("\n");break;case '3' : system("cls");Differ_Sq(La,Lb,Lc);//调用集合的差集运算函数 printf("\t\t\t集合A与集合B的差集为:");print_Sq(Lc);printf("\n");break;case '4' :system("cls");Clear_Sq(La);//销毁表LaClear_Sq(Lb);//销毁表LbClear_Sq(Lc);//销毁表LcClear_Sq(Ld);//销毁表Ldgetchar();Index_Sq();//递归调用此函数break;default : printf("\t\t\t#\tenter data error!\n");printf("\n");}printf("\t\t 继续计算请输入1,停止计算请输入0 \n");printf("\t\t\t");scanf("%d",&l);getchar();system("cls");}printf("\n\t\t**************** 谢谢使用!*****************\n");}int main(){printf("\t\t************* 欢迎使用集合操作运算器************\n");Index_Sq();//调用主菜单函数return 0;}。
《数据结构》实验1实验报告
南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。
一、实验目的1.熟悉上机环境,进一步掌握语言的结构特点。
2.掌握线性表的顺序存储结构的定义及实现。
3.掌握线性表的链式存储结构——单链表的定义及实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插入元素68。
3.建立一个带头结点的单链表,结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长:{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素:");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素:", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据:\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获,体会及问题(写得越详细、越个性化、越真实越好,否则我不知道你做这个实验的心路历程,也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手,才刚上了几节课,对于线性表、链式表都不是理解的很透彻,不知道用哪个软件编写程序。
数据结构实验一 实验报告
班级:姓名:学号:实验一线性表的基本操作一、实验目的1、掌握线性表的定义;2、掌握线性表的基本操作;如建立、查找、插入和删除等..二、实验内容定义一个包含学生信息学号;姓名;成绩的顺序表和链表二选一;使其具有如下功能:1 根据指定学生个数;逐个输入学生信息;2 逐个显示学生表中所有学生的相关信息;3 根据姓名进行查找;返回此学生的学号和成绩;4 根据指定的位置可返回相应的学生信息学号;姓名;成绩;5 给定一个学生信息;插入到表中指定的位置;6 删除指定位置的学生记录;7 统计表中学生个数..三、实验环境Visual C++四、程序分析与实验结果#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<string.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status; // 定义函数返回值类型typedef struct{char num10; // 学号char name20; // 姓名double grade; // 成绩}student;typedef student ElemType;typedef struct LNode{ElemType data; // 数据域struct LNode *next; //指针域}LNode;*LinkList;Status InitListLinkList &L // 构造空链表L {L=struct LNode*mallocsizeofstruct LNode; L->next=NULL;return OK;}Status GetElemLinkList L;int i;ElemType &e // 访问链表;找到i位置的数据域;返回给 e{LinkList p;p=L->next;int j=1;whilep&&j<i{p=p->next;++j;}ifp||j>i return ERROR;e=p->data;return OK;}Status SearchLNode L;char str;LinkList &p // 根据名字查找{p=L.next;whilep{ifstrcmpp->;str==0return OK;p=p->next;}return ERROR;}Status ListInsertLinkList L;int i;ElemType e // 在i个位置插入某个学生的信息{LinkList p;s;p=L;int j=0;whilep&&j<i-1{p=p->next;++j;}ifp||j>i-1 return ERROR;s=struct LNode*mallocsizeofLNode;s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDeleteLinkList p;int i // 删除i位置的学生信息{int j=0;whilep->next&&j<i-1{p=p->next;++j;}ifp->next||j>i-1 return ERROR;LinkList q;q=p->next;p->next=q->next;delete q;return OK;}void InputElemType *e{printf"姓名:"; scanf"%s";e->name;printf"学号:"; scanf"%s";e->num;printf"成绩:"; scanf"%lf";&e->grade;printf"输入完成\n\n";}void OutputElemType *e{printf"姓名:%-20s\n学号:%-10s\n成绩:%-10.2lf\n\n";e->name;e->num;e->grade;}int main{LNode L;LinkList p;ElemType a;b;c;d;printf"\n********************************\n\n";puts"1. 构造链表";puts"2. 录入学生信息";puts"3. 显示学生信息";puts"4. 输入姓名;查找该学生";puts"5. 显示某位置该学生信息";puts"6. 在指定位置插入学生信息";puts"7. 在指定位置删除学生信息";puts"8. 统计学生个数";puts"0. 退出";printf"\n********************************\n\n"; int x;choose=-1;whilechoose=0{puts"请选择:";scanf"%d";&choose;switchchoose{case 1:ifInitListpprintf"成功建立链表\n\n";elseprintf"链表建立失败\n\n";break;case 2:printf"请输入要录入学生信息的人数:";scanf"%d";&x;forint i=1;i<=x;i++{printf"第%d个学生:\n";i;Input&a;ListInsert&L;i;a;}break;case 3:forint i=1;i<=x;i++{GetElem&L;i;b;Output&b;}break;case 4:char s20;printf"请输入要查找的学生姓名:";scanf"%s";s;ifSearchL;s;pOutput&p->data;elseputs"对不起;查无此人";puts"";break;case 5:printf"请输入要查询的位置:";int id1;scanf"%d";&id1;GetElem&L;id1;c;Output&c;break;case 6:printf "请输入要插入的位置:";int id2;scanf"%d";&id2;printf"请输入学生信息:\n";Input&d;ifListInsert&L;id2;d{x++;puts"插入成功";puts"";}else{puts"插入失败";puts"";}break;case 7:printf"请输入要删除的位置:";int id3;scanf"%d";&id3;ifListDelete&L;id3{x--;puts"删除成功";puts"";}else{puts"删除失败";puts"";}break;case 8:printf"已录入的学生个数为:%d\n\n";x;break;}}printf"\n\n谢谢您的使用;请按任意键退出\n\n\n"; system"pause";return 0;}用户界面:(1)根据指定学生个数;逐个输入学生信息:(2)逐个显示学生表中所有学生的相关信息:(3)根据姓名进行查找;返回此学生的学号和成绩:(4)根据指定的位置可返回相应的学生信息学号;姓名;成绩:(5)给定一个学生信息;插入到表中指定的位置:(6)删除指定位置的学生记录:(7)统计表中学生个数:五、实验总结数据结构是一门专业技术基础课..它要求学会分析研究计算机加工的数据结构的特性;以便为应用涉及的数据选择适当的逻辑结构;存储结构及相应的算法;并初步掌握算法的时间分析和空间分析技术..不仅要考虑具体实现哪些功能;同时还要考虑如何布局;这次的实验题目是根据我们的课本学习进程出的;说实话;我并没有真正的读懂书本的知识;所以刚开始的时候;感到很棘手;于是又重新细读课本;这一方面又加强了对书本的理解;在这上面花费了一些心血;觉得它并不简单;是需要花大量时间来编写的....在本次实验中;在程序构思及设计方面有了较大的锻炼;能力得到了一定的提高..。
数据结构实验报告1-线性结构的顺序存储
教师签名: 2008 年 月 日
第2页共2页
2、参照课本,定义一个向量类模板,编写它的成员函数模板,对类模板加以实现;编写向量的并、 交运算功能函数;编写主程序,对两个向量进行分别进行合并、交运算。
3、通过阅读课本栈类板代码,理解栈类操作特点;编写一个借助于栈,将二进制数转换为十进制数 字串的程序;编写汉诺塔问题程序,理解函数的递归调用。
4、参照课本,定义一个顺序队列类模板,编写它的成员函数模板 ,对类模板加以实现;编写主程序, 对队列进行各种基本操作,理解队列的操作特性。
五、 实验总结(包括心得体会、问题回答及实验改进意见,可附页)
通过本次实验,基本上能够理解线性结构的顺序存储方式及各种不同线性结构的操作方式;顺序存 储方式主要用于线性的数据结构,它把逻辑上相邻的数据元素存储在物理上相邻的存储单元里结点之间 的关系由存储单元的邻接关系来体现。线性表、向量、栈、队列都属于线性结构的顺序存储,各结点的 物理地址是相邻的,每一次插入、删除运算会引起相应结点物理地址的重新排列;栈的操作特点是先进 后出,而队列的操作特点是先进先出。
2、 对两个向量进行合并、交运算,结果如下: 输入向量 La 的结点元素:1 2 3 4 5,输入 Lb 的结点元素:1 2 3 4 5 6,则两向量的交集为:1 2 3 4 5;并集为:1 2 3 4 5 6。
3、(1)将二进制数转换为十进制数字串的程序,结果如下: 输入要转换的带符号整数 x:+3;则 x 转换成十进制数字串输出为:+3
Байду номын сангаас
第1页共2页
四、 实验结果(包括程序或图表、结论陈述、数据记录及分析等,可附页)
1、 对线性表进行插入、删除、定位等操作,结果如下: 输入线性表元素:1 2 3 4 5,(1)选择插入,输入插入位置 2,插入值 9,则新的线性表为:1 2 9 3 4 5;(2)选择删除,输入删除元素序号 5,则新的线性表为:1 2 9 3 4;(3)选择取值,输入要求 值元素序号 2,则屏幕输出:第2个元素的值为 9;(4)选择查找,输入要查找的元素值 9,则屏幕输 出:要查找元素的序号为 2。
数据结构上机实验报告
数据结构实验报告课程数据结构 _ 院系专业班级实验地点姓名学号实验时间指导老师数据结构上机实验报告1一﹑实验名称:实验一——链表二﹑实验目的:1.了解线性表的逻辑结构特性;2.熟悉链表的基本运算在顺序存储结构上的实现,熟练掌握链式存储结构的描述方法;3.掌握链表的基本操作(建表、插入、删除等)4. 掌握循环链表的概念,加深对链表的本质的理解。
5.掌握运用上机调试链表的基本方法三﹑实验内容:(1)创建一个链表(2)在链表中插入元素(3)在链表中删除一个元素(4)销毁链表四﹑实验步骤与程序#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的链表均为带头结点。
void CreatLinkList(LinkList &L,int j){//建立一个链表L,数据为整数,数据由键盘随机输入。
LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"请输入一个链表:"<<endl;for(int i=0;i<j;i++){ p=(LinkList)malloc(sizeof(Lnode));cin>>p->data;p->next=q->next;q->next=p;q=p;}}int PrintLinkList(LinkList &L){//输出链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算链表L的数据元素个数。
数据结构--实验报告 线性表的基本操作
一、实验目的二、实验内容和要求三、源代码1)顺序表的代码2)单链表的代码四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现。
4、掌握顺序表的存储结构形式及其描述和基本运算的实现。
5、熟练掌握动态链表结构及有关算法的设计二、实验内容题目一:顺序表的基本操作[问题描述]实现顺序表的建立、求长度,取元素、修改元素、插入、删除等顺序表的基本操作。
[基本要求](1)依次从键盘读入数据,建立带头结点的顺序表;(2)输出顺序表中的数据元素(3)求顺序表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法,将两个有序的顺序表合并成一个有序顺序表。
[测试数据] 由学生任意指定。
题目二:单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求](1)依次从键盘读入数据,建立带头结点的单链表;(2)输出单链表中的数据元素(3)求单链表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。
(6)根据算法,将两个有序的单链表合并成一个有序单链表。
[测试数据]由学生任意指定。
三、源代码(一)顺序表的基本操作#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(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 Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++)L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(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 Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度:";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void chaxun(SqList &L1) //取第i个位置的元素{ int j;ElemType e1;cout<<"请选择所要取出元素的位置:";while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>j; }GetElem(L1,j,e1);cout<<"取出的元素为:"<<e1<<endl; }void xiugai(SqList &L1) //修改第i个位置的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要修改元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要修改元素的位置:";cin>>j; }cout<<"要修改成的元素:";cin>>e1;Listxiugei(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度:"; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度:"; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下:"; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<" 顺序表的基本操作"<<endl;cout<<" 1.顺序表的创建"<<endl;cout<<" 2.顺序表的显示"<<endl;cout<<" 3.顺序表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到顺序表里"<<endl;cout<<" 7.删除顺序表里的元素"<<endl;cout<<" 8.合并两个顺序表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break; case 4: chaxun(Lx);break;case 5: xiugai(Lx);break;case 6: charu(Lx);break;case 7: shanchu(Lx);break;case 8: hebing(Lx);break;case 9: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误,请重新选择"<<endl;break; }}}(二)单链表的基本操作#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在 e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点 if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点,并令p指向其前驱p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) { //合并两个顺序链表LinkList pa,pc,pb;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;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共("<<a<<"个):"<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共("<<b<<"个):"<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下:"<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);default : cout<<"输入有误,请重新输入"<<endl;break;}}}四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时,我有点惊讶,才学了不到一个月,就要写实验报告。
数据结构实验报告(一)线性表的应用
数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。
⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。
(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。
(3)当给定x的值时,能计算表达式相加或相减的结果。
(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。
(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。
2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。
(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。
因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。
综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。
3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。
数据结构实验报告(实验)
深 圳 大 学 实 验 报 告课程名称: 数据结构实验与课程设计 实验项目名称: 实验一:顺序表的应用 学院: 计算机与软件学院 专业: 指导教师: **报告人: 文成 学号: ********** 班级: 5 实验时间: 2012-9-17实验报告提交时间: 2012-9-24教务部制一、实验目的与要求:目的:1.掌握线性表的基本原理2.掌握线性表地基本结构3.掌握线性表地创建、插入、删除、查找的实现方法要求:1.熟悉C++语言编程2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法二、实验内容:Problem A: 数据结构——实验1——顺序表例程Description实现顺序表的创建、插入、删除、查找Input第一行输入顺序表的实际长度n第二行输入n个数据第三行输入要插入的新数据和插入位置第四行输入要删除的位置第五行输入要查找的位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行插入操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行删除操作后,顺序表内的所有数据,数据之间用空格隔开第四行输出指定位置的数据Sample Input611 22 33 44 55 66888 352Sample Output11 22 33 44 55 6611 22 888 33 44 55 6611 22 888 33 55 6622HINT第i个位置是指从首个元素开始数起的第i个位置,对应数组内下标为i-1的位置Problem B: 数据结构——实验1——顺序表的数据交换Description实现顺序表内的元素交换操作Input第一行输入n表示顺序表包含的·n个数据第二行输入n个数据,数据是小于100的正整数第三行输入两个参数,表示要交换的两个位置第四行输入两个参数,表示要交换的两个位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行第一次交换操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行第二次交换操作后,顺序表内的所有数据,数据之间用空格隔开注意加入交换位置的合法性检查,如果发现位置不合法,输出error。
数据结构实验报告(实验)
数据结构实验报告(实验)数据结构实验报告(实验)1. 实验目的1.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统:Windows 102.2 编程语言:C++2.3 开发工具:Visual Studio3. 实验内容3.1 实验一:线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二:栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三:树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法(前序、中序、后序遍历)3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一:实验源代码附件二:实验数据7. 法律名词及注释7.1 版权:著作权法规定的对原创作品享有的权利7.2 专利:国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标:作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议:指允许他人在一定条件下使用自己的知识产权的协议。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。
(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。
(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。
数据结构实验报告实验1
数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见的数据结构,如线性表、栈、队列等,并能够运用所学知识解决实际问题。
二、实验环境本次实验使用的编程环境为Visual Studio 2019,编程语言为C++。
三、实验内容与步骤(一)线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。
实现插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体,包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
(二)栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。
实现入栈、出栈、栈顶元素获取等操作。
2、栈的应用利用栈实现表达式求值。
(三)队列的实现与应用1、队列的实现使用循环数组或链表实现队列。
实现入队、出队、队头元素获取等操作。
2、队列的应用模拟银行排队系统。
四、实验结果与分析(一)线性表1、顺序表插入操作:在指定位置插入元素时,需要移动后续元素,时间复杂度为 O(n)。
删除操作:删除指定位置的元素时,同样需要移动后续元素,时间复杂度为 O(n)。
查找操作:可以直接通过索引访问元素,时间复杂度为 O(1)。
2、链表插入操作:只需修改指针,时间复杂度为 O(1)。
删除操作:同样只需修改指针,时间复杂度为 O(1)。
查找操作:需要遍历链表,时间复杂度为 O(n)。
(二)栈1、表达式求值能够正确计算简单的四则运算表达式,如 2 + 3 4。
对于复杂表达式,如(2 + 3) 4,也能得到正确结果。
(三)队列1、银行排队系统模拟了客户的到达、排队和服务过程,能够反映出队列的先进先出特性。
五、实验中遇到的问题及解决方法(一)线性表1、顺序表的空间浪费问题问题描述:当预先分配的空间过大而实际使用较少时,会造成空间浪费。
解决方法:可以采用动态分配空间的方式,根据实际插入的元素数量来调整存储空间。
2、链表的指针操作错误问题描述:在链表的插入和删除操作中,容易出现指针指向错误,导致程序崩溃。
数据结构实验一(完整版)
数据结构实验一:线性表实验报告#include <string.h>#include <ctype.h>#include <malloc.h> // malloc()等#include <limits.h> // INT_MAX等#include <stdio.h> // EOF(=^Z或F6),NULL#include <stdlib.h> // atoi()#include <io.h> // eof()#include <math.h> // floor(),ceil(),abs()#include <process.h> // exi t()#include <iostream.h> // cout,cin// 函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1// #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSEtypedef int ElemType;#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LISTINCREMENT 2 // 线性表存储空间的分配增量struct SqListElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)};/**********************************************************/ /* 顺序表示的线性表的基本操作(12个) *//**********************************************************/ Status InitList(SqList &L){ // 操作结果:构造一个空的顺序线性表---------------1L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量return OK;}Status DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表,将当前元素个数置为0。
3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。
- 判断要删除的位置是否合法,若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。
- 若找到目标值,则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。
6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。
四、实验结果经过实验,顺序表的各项操作均能正确实现。
在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。
在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。
在查找操作中,可以正确返回目标值的位置。
在输出操作中,可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。
在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。
国开数据结构(本)数据结构课程实验报告(一)
国开数据结构(本)数据结构课程实验报告一、实验目的本实验旨在帮助学生掌握数据结构的基本概念,熟练掌握数据结构的基本操作,进一步提高学生的编程能力和数据处理能力。
二、实验内容1. 数据结构的基本概念在实验中,我们首先介绍了数据结构的基本概念,包括数据的逻辑结构和物理结构,以及数据结构的分类和应用场景。
2. 数据结构的基本操作接着,我们介绍了数据结构的基本操作,包括插入、删除、查找等操作,通过具体的案例和代码演示,让学生理解和掌握这些基本操作的实现原理和方法。
3. 编程实践在实验的第三部分,我们组织学生进行数据结构的编程实践,要求学生通过实际编写代码来实现各种数据结构的基本操作,加深对数据结构的理解和掌握。
三、实验过程1. 数据结构的基本概念在本部分,我们通过课堂讲解和案例分析的方式,向学生介绍了数据结构的基本概念,包括线性结构、树形结构、图形结构等,让学生对数据结构有一个整体的认识。
2. 数据结构的基本操作在这一部分,我们通过具体的案例和代码演示,向学生介绍了数据结构的基本操作,包括插入、删除、查找等操作的实现原理和方法,让学生掌握这些基本操作的具体实现。
3. 编程实践最后,我们组织学生进行数据结构的编程实践,要求他们通过实际编写代码来实现各种数据结构的基本操作,加深对数据结构的理解和掌握,同时也提高了他们的编程能力和数据处理能力。
四、实验结果与分析通过本次实验,学生们对数据结构有了更深入的理解和掌握,他们能够熟练地使用各种数据结构的基本操作,编写出高效、稳定的代码,提高了他们的编程能力和数据处理能力。
五、实验总结本实验对于学生掌握数据结构的基本概念和操作起到了很好的辅助作用,通过实际的编程实践,学生们不仅加深了对数据结构的理解和掌握,同时也提高了他们的编程能力和数据处理能力。
这对于他们今后的学习和工作都具有重要的意义。
六、参考文献1. 《数据结构与算法分析》2. 《数据结构(C语言版)》3. 《数据结构与算法》以上是我对“国开数据结构(本)数据结构课程实验报告”的详细报告,希望能够满足您的要求。
(完整版)数据结构实验报告全集
数据结构实验报告全集实验一线性表基本操作和简单程序1.实验目的(1)掌握使用Visual C++ 6.0上机调试程序的基本方法;(2)掌握线性表的基本操作:初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。
2.实验要求(1)认真阅读和掌握和本实验相关的教材内容。
(2)认真阅读和掌握本章相关内容的程序。
(3)上机运行程序。
(4)保存和打印出程序的运行结果,并结合程序进行分析。
(5)按照你对线性表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果实验代码:1)头文件模块#include iostream.h>//头文件#include<malloc.h>//库头文件-----动态分配内存空间typedef int elemtype;//定义数据域的类型typedef struct linknode//定义结点类型{elemtype data;//定义数据域struct linknode *next;//定义结点指针}nodetype;2)创建单链表nodetype *create()//建立单链表,由用户输入各结点data域之值,//以0表示输入结束{elemtype d;//定义数据元素dnodetype *h=NULL,*s,*t;//定义结点指针int i=1;cout<<"建立一个单链表"<<endl;while(1){cout <<" 输入第"<< i <<"结点data域值:";cin >> d;if(d==0) break;//以0表示输入结束if(i==1)//建立第一个结点{h=(nodetype*)malloc(sizeof(nodetype));//表示指针hh->data=d;h->next=NULL;t=h;//h是头指针}else//建立其余结点{s=(nodetype*) malloc(sizeof(nodetype));s->data=d;s->next=NULL;t->next=s;t=s;//t始终指向生成的单链表的最后一个节点}i++;}return h;}3)输出单链表中的元素void disp(nodetype*h)//输出由h指向的单链表的所有data域之值{nodetype *p=h;cout<<"输出一个单链表:"<<endl<<" ";if(p==NULL)cout<<"空表";while(p!=NULL){cout<<p->data<<" ";p=p->next;}cout<<endl;}4)计算单链表的长度int len(nodetype *h)//返回单链表的长度{int i=0;nodetype *p=h;while(p!=NULL){p=p->next;i++;}return i;}5)寻找第i个节点nodetype *find(nodetype *h,int i)//返回第i个节点的指针{nodetype *p=h;int j=1;if(i>len(h)||i<=0)return NULL;//i上溢或下溢celse{while (p!=NULL&&j<1)//查找第i个节点,并由p指向该节点{j++;p=p->next;}return p;} }6)单链表的插入操作nodetype *ins(nodetype *h,int i,elemtype x)//在单链表head中第i个节点//(i>=0)之后插入一个data域为x的节点{nodetype *p,*s;s=(nodetype*)malloc(sizeof(nodetype));//创建节点ss->data=x;s->next=NULL;if(i==0)//i=0:s作为该单链表的第一个节点{s->next=h;h=s;}else{p=find(h,i);//查找第i个节点,并由p指向该节点if(p!=NULL){s->next=p->next;p->next=s;}return h;}}7)单链表的删除操作nodetype *del(nodetype *h,int i)//删除第i个节点{nodetype *p=h, *s;int j=1;if(i==1)//删除第1个节点{h=h->next;free(p);}else{p=find(h,i-1);//查找第i-1个节点,并由p指向该节点 if(p!=NULL&&p->next!=NULL){s=p->next;//s指向要删除的节点p->next=s->next;free(s);}else cout<<"输入i的值不正确"<<endl;}return h;}8)释放节点空间void dispose(nodetype *h)//释放单链表的所有节点占用的空间{nodetype *pa=h,*pb;if(pa!=NULL){pb=pa->next;if(pb==NULL)//只有一个节点的情况free(pa);else{while (pb!=NULL)//有两个及以上节点的情况{free(pa);pa=pb;pb=pb->next;}free(pa);}}}9)主程序模块:#include"slink.h"//包含头文件slinkvoid main(){nodetype *head;//定义节点指针变量head=create();//创建一个单链表disp(head);//输出单链表cout<<"单链表长度:"<<len(head)<<endl;ins(head, 2,0);//在第二个节点之后插入以0为元素的节点 disp(head);//输出新链表del(head,2);//删除第二个节点disp(head);//输出新链表}5.实验结果建立一个单链表:输入第1结点data域值:1输入第2结点data域值:2输入第3结点data域值:3输入第4结点data域值:4输入第5结点data域值:5输入第6结点data域值:6输入第7结点data域值:7输入第8结点data域值:8输入第9结点data域值:9输入第10结点data域值0:输出一个单链表:1 2 3 4 5 6 7 8 9单链表长度:9输出一个单链表:1 02345678 9输出一个单链表:1 2 3 4 5 6 7 8实验二顺序栈的实现1.实验目的掌握顺序栈的基本操作:初始化栈、判栈空否、入栈、出栈、取栈顶数据元素等运算以及程序实现方法。
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解线性表的顺序存储结构,并通过编程实现其基本操作,包括创建线性表、插入元素、删除元素、查找元素以及输出线性表等。
通过实际操作,掌握顺序存储结构的特点和优势,同时也了解其在不同情况下的性能表现。
二、实验环境本次实验使用的编程语言为C++,编译环境为Visual Studio 2019。
三、实验原理1、线性表的定义线性表是由 n(n≥0)个数据元素组成的有限序列。
在顺序存储结构中,线性表的元素存储在一块连续的存储空间中,通过数组来实现。
2、顺序存储结构的特点存储密度高,无需额外的指针来表示元素之间的关系。
可以随机访问表中的任意元素,时间复杂度为 O(1)。
插入和删除操作需要移动大量元素,平均时间复杂度为 O(n)。
四、实验内容及步骤1、定义线性表的数据结构```cppdefine MAX_SIZE 100 //定义线性表的最大长度typedef struct {int dataMAX_SIZE; //存储线性表元素的数组int length; //线性表的当前长度} SeqList;```2、初始化线性表```cppvoid InitList(SeqList L) {L>length = 0; //初始时线性表长度为 0}```3、判断线性表是否为空```cppbool ListEmpty(SeqList L) {return (Llength == 0);}```4、求线性表的长度```cppint ListLength(SeqList L) {return Llength;}```5、按位查找操作```cppint GetElem(SeqList L, int i) {if (i < 1 || i > Llength) {printf("查找位置不合法!\n");return -1;}return Ldatai 1;}```6、按值查找操作```cppint LocateElem(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}return 0; //未找到返回 0}```7、插入操作```cppbool ListInsert(SeqList L, int i, int e) {if (L>length == MAX_SIZE) {//表已满printf("表已满,无法插入!\n");return false;}if (i < 1 || i > L>length + 1) {//插入位置不合法printf("插入位置不合法!\n");return false;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;//表长加 1return true;}```8、删除操作```cppbool ListDelete(SeqList L, int i) {if (L>length == 0) {//表为空printf("表为空,无法删除!\n");return false;}if (i < 1 || i > L>length) {//删除位置不合法printf("删除位置不合法!\n");return false;}for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length; //表长减 1return true;}```9、输出线性表```cppvoid PrintList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```10、测试用例```cppint main(){SeqList L;InitList(&L);ListInsert(&L, 1, 10);ListInsert(&L, 2, 20);ListInsert(&L, 3, 30);ListInsert(&L, 4, 40);ListInsert(&L, 5, 50);printf("线性表的长度为:%d\n", ListLength(L));printf("查找第 3 个元素:%d\n", GetElem(L, 3));int loc = LocateElem(L, 30);if (loc) {printf("元素 30 的位置为:%d\n", loc);} else {printf("未找到元素 30\n");}ListDelete(&L, 3);printf("删除第 3 个元素后的线性表:");PrintList(L);return 0;}```五、实验结果及分析1、实验结果成功创建并初始化了线性表。
数据结构实验报告一-约瑟夫环问题
实验1约瑟夫环问题1.需求分析(1)输入的形式和输入值的范围:每一次输入的值为两个正整数,中间用逗号隔开。
若分别设为n,m,则输入格式为:“n,m”。
不对非法输入做处理,即假设输入都是合法的。
(2)输出的形式:输出格式1:在字符界面上输出这n个数的输出序列输出格式2:将这n个数的输出序列写入到文件中(3)程序所能达到的功能:对于输入的约瑟夫环长度n和间隔m,输出约瑟夫环的出列顺序。
(4)测试数据:包括正确的输入及其输出结果和含有错误的输入及其输出结果。
正确:输入:10,3输出:3 6 9 2 7 1 8 5 10 4输入:41,3输出:3 6 9 12 15 18 21 24 27 30 33 36 39 1 5 10 14 19 23 28 32 37 41 7 13 20 2634 40 8 17 29 38 11 25 2 22 4 35 16 31错误:输入:10 3输出:6 8 7 1 3 4 2 9 5 102.概要设计(1)抽象数据类型的定义:为实现上述程序的功能,可以用整数存储用户的输入。
并将用户输入的值存储于线性表中。
线性表ADT定义如下:ADT list数据对象:整形数据关系:线性关系,即<ai,ai+1>(0≤a<n)。
基本操作:bool remove(int &elem)//移除一个元素,被移除的元素赋给elem//如果操作成功,返回true,否则返回falsebool isEmpty()//判断数组的元素是否清空,空返回true,否则返回falsebool setPos(int place)//设置当前元素的位置,设置成功返回true,否则返回falseint getLength()//获取数组的实际长度(2)算法的基本思想:约瑟夫环问题中的数据是人所在的位置,而这种数据是存在“第一元素、最后元素”,并且存在“唯一的前驱和后继的”,符合线性表的特点。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
班级: 姓名: 学号:实验一线性表的基本操作一、实验目的1、掌握线性表的定义;2、掌握线性表的基本操作,如建立、查找、插入与删除等。
二、实验内容定义一个包含学生信息(学号,姓名,成绩)的顺序表与链表(二选一),使其具有如下功能:(1) 根据指定学生个数,逐个输入学生信息;(2) 逐个显示学生表中所有学生的相关信息;(3) 根据姓名进行查找,返回此学生的学号与成绩;(4) 根据指定的位置可返回相应的学生信息(学号,姓名,成绩);(5) 给定一个学生信息,插入到表中指定的位置;(6) 删除指定位置的学生记录;(7) 统计表中学生个数。
三、实验环境Visual C++四、程序分析与实验结果#include<stdio、h>#include<malloc、h>#include<stdlib、h>#include<string、h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status; // 定义函数返回值类型typedef struct{char num[10]; // 学号char name[20]; // 姓名double grade; // 成绩}student;typedef student ElemType;typedef struct LNode{ElemType data; // 数据域struct LNode *next; //指针域}LNode,*LinkList;Status InitList(LinkList &L) // 构造空链表L{L=(struct LNode*)malloc(sizeof(struct LNode));L->next=NULL;return OK;}Status GetElem(LinkList L,int i,ElemType &e) // 访问链表,找到i位置的数据域,返回给 e{LinkList p;p=L->next;int j=1;while(p&&j<i){p=p->next;++j;}if(!p||j>i) return ERROR;e=p->data;return OK;}Status Search(LNode L,char str[],LinkList &p) // 根据名字查找{p=L、next;while(p){if(strcmp(p->data、name,str)==0)return OK;p=p->next;}return ERROR;}Status ListInsert(LinkList L,int i,ElemType e) // 在i个位置插入某个学生的信息{LinkList p,s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1) return ERROR;s=(struct LNode*)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDelete(LinkList p,int i) // 删除i位置的学生信息{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;delete q;return OK;}void Input(ElemType *e){printf("姓名:"); scanf("%s",e->name);printf("学号:"); scanf("%s",e->num);printf("成绩:"); scanf("%lf",&e->grade);printf("输入完成\n\n");}void Output(ElemType *e){printf("姓名:%-20s\n学号:%-10s\n成绩:%-10、2lf\n\n",e->name,e->num,e->grade);}int main(){LNode L;LinkList p;ElemType a,b,c,d;printf("\n********************************\n\n"); puts("1、构造链表");puts("2、录入学生信息");puts("3、显示学生信息");puts("4、输入姓名,查找该学生");puts("5、显示某位置该学生信息");puts("6、在指定位置插入学生信息");puts("7、在指定位置删除学生信息");puts("8、统计学生个数");puts("0、退出");printf("\n********************************\n\n"); int x,choose=-1;while(choose!=0){puts("请选择:");scanf("%d",&choose);switch(choose){case 1:if(InitList(p))printf("成功建立链表\n\n");elseprintf("链表建立失败\n\n");break;case 2:printf("请输入要录入学生信息的人数:");scanf("%d",&x);for(int i=1;i<=x;i++){printf("第%d个学生:\n",i);Input(&a);ListInsert(&L,i,a);}break;case 3:for(int i=1;i<=x;i++){GetElem(&L,i,b);Output(&b);}break;case 4:char s[20];printf("请输入要查找的学生姓名:");scanf("%s",s);if(Search(L,s,p))Output(&(p->data));elseputs("对不起,查无此人");puts("");break;case 5:printf("请输入要查询的位置:");int id1;scanf("%d",&id1);GetElem(&L,id1,c);Output(&c);break;case 6:printf ("请输入要插入的位置:");int id2;scanf("%d",&id2);printf("请输入学生信息:\n");Input(&d);if(ListInsert(&L,id2,d)){x++;puts("插入成功");puts("");}else{puts("插入失败");puts("");}break;case 7:printf("请输入要删除的位置:");int id3;scanf("%d",&id3);if(ListDelete(&L,id3)){x--;puts("删除成功");puts("");}else{puts("删除失败");puts("");}break;case 8:printf("已录入的学生个数为:%d\n\n",x);break;}}printf("\n\n谢谢您的使用,请按任意键退出\n\n\n"); system("pause");return 0;}用户界面:(1)根据指定学生个数,逐个输入学生信息:(2)逐个显示学生表中所有学生的相关信息:(3)根据姓名进行查找,返回此学生的学号与成绩:(4)根据指定的位置可返回相应的学生信息(学号,姓名,成绩):(5)给定一个学生信息,插入到表中指定的位置:(6)删除指定位置的学生记录:(7)统计表中学生个数:五、实验总结数据结构就是一门专业技术基础课。
它要求学会分析研究计算机加工的数据结构的特性,以便为应用涉及的数据选择适当的逻辑结构,存储结构及相应的算法,并初步掌握算法的时间分析与空间分析技术。
不仅要考虑具体实现哪些功能,同时还要考虑如何布局,这次的实验题目就是根据我们的课本学习进程出的,说实话,我并没有真正的读懂书本的知识,所以刚开始的时候,感到很棘手,于就是又重新细读课本,这一方面又加强了对书本的理解,在这上面花费了一些心血,觉得它并不简单,就是需要花大量时间来编写的。
在本次实验中,在程序构思及设计方面有了较大的锻炼,能力得到了一定的提高。