顺序表上机实验报告
上机实验报告(精选11篇)
![上机实验报告(精选11篇)](https://img.taocdn.com/s3/m/2bc0c5e964ce0508763231126edb6f1afe007149.png)
上机实验报告篇1用户名se××××学号姓名学院①实验名称:②实验目的:③算法描述(可用文字描述,也可用流程图):④源代码:(.c的文件)⑤用户屏幕(即程序运行时出现在机器上的画面):2.对c文件的要求:程序应具有以下特点:a可读性:有注释。
b交互性:有输入提示。
c结构化程序设计风格:分层缩进、隔行书写。
3.上交时间:12月26日下午1点-6点,工程设计中心三楼教学组。
请注意:过时不候哟!四、实验报告内容0.顺序表的插入。
1.顺序表的删除。
2.带头结点的单链表的\'插入。
3.带头结点的单链表的删除。
注意:1.每个人只需在实验报告中完成上述4个项目中的一个,具体安排为:将自己的序号对4求余,得到的数即为应完成的项目的序号。
例如:序号为85的同学,85%4=1,即在实验报告中应完成顺序表的删除。
2.实验报告中的源代码应是通过编译链接即可运行的。
3.提交到个人空间中的内容应是上机实验中的全部内容。
上机实验报告篇2一、《软件技术基础》上机实验内容1.顺序表的建立、插入、删除。
2.带头结点的单链表的建立(用尾插法)、插入、删除。
二、提交到个人10m硬盘空间的内容及截止时间1.分别建立二个文件夹,取名为顺序表和单链表。
2.在这二个文件夹中,分别存放上述二个实验的相关文件。
每个文件夹中应有三个文件(.c文件、.obj文件和.exe文件)。
3. 截止时间:12月28日(18周周日)晚上关机时为止,届时服务器将关闭。
三、实验报告要求及上交时间(用a4纸打印)1.格式:《计算机软件技术基础》上机实验报告用户名se××××学号姓名学院①实验名称:②实验目的:③算法描述(可用文字描述,也可用流程图):④源代码:(.c的文件)⑤用户屏幕(即程序运行时出现在机器上的画面):2.对c文件的要求:程序应具有以下特点:a 可读性:有注释。
b 交互性:有输入提示。
顺序表实验报告
![顺序表实验报告](https://img.taocdn.com/s3/m/6e014eb1bb0d4a7302768e9951e79b8969026865.png)
顺序表实验报告
摘要:
一、实验背景及目的
二、实验对象与方法
三、实验结果与分析
四、实验总结与建议
正文:
一、实验背景及目的
随着科技的不断发展,顺序表在各种领域的应用越来越广泛。
为了进一步了解顺序表的性能和特点,本实验对顺序表进行了相关测试。
实验旨在通过对比分析,评估顺序表在不同条件下的表现,为后续研究与应用提供参考依据。
二、实验对象与方法
1.实验对象:某品牌顺序表产品
2.实验方法:
(1)根据实验需求,制定实验方案,明确实验步骤与评价标准;
(2)将顺序表产品置于不同环境下,如高温、低温、湿度等,观察其性能变化;
(3)通过数据记录与分析,评估顺序表在不同环境下的稳定性、可靠性和适用性。
三、实验结果与分析
1.顺序表在不同环境下的性能表现:
(1)在高温环境下,顺序表表现稳定,数据传输速率较快;
(2)在低温环境下,顺序表仍能正常工作,性能略有下降;
(3)在湿度较大的环境下,顺序表出现一定程度的性能波动,但整体表现良好。
2.分析:
(1)顺序表在不同环境下性能表现差异较小,说明产品具有较强的适应性;
(2)在湿度较大环境下,性能略有波动,可能与产品内部结构有关,需进一步优化;
(3)实验结果符合预期,顺序表产品具备较好的稳定性和可靠性。
顺序表实验报告
![顺序表实验报告](https://img.taocdn.com/s3/m/163dd860ddccda38376baf1a.png)
实验报告实验项目名称实验一线性表的操作所属课程名称数据结构实验类型验证实验实验日期2010-11-19院系数学与信息科学学院实验一线性表的操作一.实验目的1、掌握用上机调试线性表的基本方法;2、掌握线性表的基本操作,插入、删除、查找,以及线性表合并等简单操作在顺序存储结构上的运算。
二.实验环境硬件:计算机、256M以上内存,40G以上硬盘;软件:Windows XP , C++三.实验内容线性表基本操作的实现:构造一空线性表,将线性表置空,对线性表进行判空,求线性表的长度,查询线性表的第i个数据元素的值,查询要查询元素的上个元素的值,查询要查询元素的下个元素的值,删除线性表中的某个元素,将某元素插入线性表,对线性表进行查访并返回一特定的值。
给出两个线性表将其合并成一个线性表,销毁线性表。
四.实验步骤1、本实验的程序及头文件如下:SqlistMain.cpp#include"iostream.h"#include"stdio.h"#include"malloc.h"#include"stdlib.h"#include"SqListOperation.h"#include"function.h"#include "SqList.h"void main(){SqList L1,L2,L3;SqList *La=&L1,*Lb=&L2,*Lc=&L3;ElemType e;int m;InitList_Sq(La);InitList_Sq(Lb);cout<<"请输入线性表a"<<endl;EnterList_Sq(La);cout<<"输出线性表a"<<endl;PrintSqList(La);cout<<"输出线性表a长:"<<ListLength(La)<<endl;cout<<"验线性表a是否空表(空为1,不空为0):"<<ListEmpty(La)<<endl;cout<<"输入查询线性表a中元素的位置:";cin>>m;cout<<"输出线性表a中第m个元素:"<<GetElem(La,m)<<endl;cout<<"输入要查询元素的上个元素:";cin>>m;cout<<"输出性表a中第m个元素上个元素:"<<PriorElem(La,m)<<endl;cout<<"输入要查询元素的下个元素:";cin>>m;cout<<"输出线性表a中第m个元素下个元素:"<<NextElem(La,m)<<endl;cout<<"输入插入元素e及其位置m:";cin>>m>>e;ListInsert_Sq(La,e,m);cout<<"输出插入元素后的线性表a:"<<endl;PrintSqList(La);cout<<"输入删除元素位置m:";cin>>m;cout<<"除线性表a中第"<<m<<"个元素并输出其值:"<<ListDelete_Sq(La,m)<<endl;cout<<"输出删除元素后的线性表a:"<<endl;PrintSqList(La);cout<<"输入线性表b"<<endl;EnterList_Sq(Lb);cout<<"输出线性表b"<<endl;PrintSqList(Lb);cout<<"给线性表La按递增排序并输出:"<<endl;Sort_Increase(La);PrintSqList(La);cout<<"给线性表La按递增排序并输出:"<<endl;Sort_Increase(Lb);PrintSqList(Lb);cout<<"把线性表a和线性表b按非递减排列归并到线性表c,并输出线性表c:"<<endl;MergeList(La,Lb,Lc);PrintSqList(Lc);cout<<"删除线性表Lc"<<endl;ClearList(Lc);DestroyList(Lc);cout<<"输出删除线性表Lc后的表长:"<<ListLength(Lc)<<endl;}Function.hStatus InitList_Sq(SqList *L);Status DestroyList(SqList *L);Status ClearList(SqList *L);Status ListEmpty(SqList *L);int ListLength(SqList *L);Status GetElem(SqList *L,int i,ElemType *e);ElemType GetElem(SqList *L,int i);int LocateElem(SqList *L,ElemType e,Status (*compare)(ElemType a,ElemType e));Status PriorElem(SqList *L,ElemType cur_e,ElemType *pre_e);ElemType PriorElem(SqList *L,ElemType cur_e);Status NextElem(SqList *L,ElemType cur_e,ElemType *next_e);ElemType NextElem(SqList *L,ElemType cur_e);Status ListInsert_Sq(SqList *L,int i,ElemType e);Status ListDelete_Sq(SqList *L,int i,ElemType *e);ElemType ListDelete_Sq(SqList *L,int i);void PrintSqList(SqList *L);Status ListTraverse(SqList *L,Status (*visit)(ElemType *a));Status EnterList_Sq(SqList *L);Status compare(ElemType a,ElemType e);Status visit(ElemType *a);Status Union(SqList *La,SqList *Lb);Status MergeList(SqList *La,SqList *Lb,SqList *Lc);//Status MergeList_Sq(SqList *La,SqList *Lb,SqList *Lc);Status Sort_Increase(SqList *L);Status Sort_Reduce(SqList *L);SqlistOperation.h#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define ERROR 0#define TURE 1#define FALSE 0#define OVERFLOW 0#define INFEASIBLE 0typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;const int n=10;Sqlist.h//初始条件:已申明线性表类型为SqListStatus InitList_Sq(SqList *L){//构造一个空的顺序表L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem) exit(ERROR);//存储分配失败L->length=0;//空表长度为零L->listsize=LIST_INIT_SIZE;//初始存储容量return OK;}//InitList_SqStatus EnterList_Sq(SqList *L){//初始条件:已存在空的顺序表//操作结果:给顺序表输入元素,并记录元素个数int i,m;ElemType *newbase;cout<<"输入所需输入线性表元素的个数"<<endl;cin>>m;newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(Ele mType));if(!newbase) exit(OVERFLOW);//存储分配失败L->elem=newbase;//新基址L->listsize+=LISTINCREMENT;//增加存储容量cout<<"依次输入所需元素:"<<endl;for(i=0;i<m;i++){cin>>L->elem[i];L->length++;}return OK;}Status DestroyList(SqList *L){//初始条件:顺序线性表L已存在。
软基上机实验报告-顺序表
![软基上机实验报告-顺序表](https://img.taocdn.com/s3/m/ab7a8a72a45177232f60a268.png)
一、实验项目名称:ex1_1——基本题:1)首先创建一个顺序表:从键盘读入一组整数(长度小于等于20),按输入顺序放入顺序表,输入以-1结束(注意-1不放到顺序表内);将创建好的顺序表元素依次输出到屏幕上。
2)在已创建好的顺序表中插入一个元素:从键盘读入需插入的元素值和插入位置,调用插入函数完成插入操作;然后将顺序表元素依次输出到屏幕上。
3)在已创建好的顺序表中删除一个元素:从键盘读入欲删除的元素位置(序号),调用删除函数完成删除操作;然后将顺序表元素依次输出到屏幕上。
软件技术基础实验table.cpp二、程序代码#include "stdafx.h"#include "mystruct.h"#include "ui.h"/******************************************************************************************* ** Function name: init_table()** Descriptions : 初始化顺序表,顺序表利用数组作为基础,其特点是需要事先获得全部元素空间,因此本函数的主要功能就是向系统申请足够的空间作为顺序表的存储空间。
涉及的系统函数为:malloc()** 此外,良好的习惯是将空间内的各项数据进行适当的初始化** Input: NONE** Output: NONE** return: 类型:table_t *,返回顺序表的结构指针** Created by :** Created Date :**-------------------------------------------------------------------------** Modified by :** Modified Date:**-------------------------------------------------------------------------*******************************************************************************************/ table_t * init_table( ){table_t * t;t=(table_t *)malloc(sizeof(table_t));t->length = 0;return t;}/******************************************************************************************* ** Function name: free_table()** Descriptions : 释放顺序表空间** 当程序结束时会通过本函数来释放通过malloc获得的顺序表空间** Input: table_t * t; 顺序表指针** Output: NONE** return: 类型:void** Created by :** Created Date :**------------------------------------------------------------------------------------------** Modified by :** Modified Date:**------------------------------------------------------------------------------------------*******************************************************************************************/ void free_table(table_t * t){free(t);}/******************************************************************************************* ** Function name: get_table()** Descriptions : 查询顺序表** 查询顺序表中第i个元素** Input:** table_t * table; 顺序表指针** int index; 查询位置,即第i个元素** Output:** element_t * elem; 元素域指针,用来存放被查询到的元素内容,** (注意,需要将元素全部内容拷贝到该指针所记录的空间中,即,使用memcpy())** return: 类型:int,返回查询是否成功,为0表示找到指定元素,为-1表示没有找到,一般是因为** index指示的位置超出了顺序表的范围** Created by :** Created Date :**-------------------------------------------------------------------------** Modified by :** Modified Date:**-------------------------------------------------------------------------*******************************************************************************************/ int get_table(table_t * table,int index, element_t * elem){//判断index是否超出顺序表范围if(index <= 0 || index > table->length){return -1;}//复制元素内容到指定空间中;memcpy(elem,&(table->data[index-1]),sizeof(element_t));//errorreturn 0;}/******************************************************************************************* ** Function name: add_table()** Descriptions : 将指定元素放入到顺序表的末尾** Input:** table_t * table; 顺序表指针** element_t data; 待放入的元素** Output:** table_t * table; 添加新元素后的顺序表指针** return: 类型:int; 为-1表示放入失败,一般是因为顺序表已经放满,为0表示正确放入** Created by :** Created Date :**-------------------------------------------------------------------------** Modified by :** Modified Date:**-------------------------------------------------------------------------*******************************************************************************************/ int add_table(table_t * table, element_t data){table->data[table->length] = data;table->length ++;return 0;}/******************************************************************************************* ** Function name: insert_table()** Descriptions : 将指定元素插入到顺序表的指定位置之前** Input:** table_t * table; 顺序表指针** element_t data; 待放入的元素** int location; 插入位置,语义是:第X个元素前,,当location大于链表元素总数时,该元素** 将插入到表尾。
实验报告一 顺序表的操作
![实验报告一 顺序表的操作](https://img.taocdn.com/s3/m/48e13bccb14e852458fb574e.png)
《数据结构》实验报告一系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:顺序表的查找、插入与删除。
设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。
具体实现要求:从键盘输入10个整数,产生顺序表,并输入结点值。
从键盘输入1个整数,在顺序表中查找该结点的位置。
若找到,输出结点的位置;若找不到,则显示“找不到”。
从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出顺序表所有结点值,观察输出结果。
从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。
二、程序设计的基本思想,原理和算法描述:(包括程序的结构,数据结构,输入/输出设计,符号名说明等)三、源程序及注释:#include <stdio.h>/*顺序表的定义:*/#define ListSize 100 /*表空间大小可根据实际需要而定,这里假设为100*/ typedef int DataType; /*DataType可以是任何相应的数据类型如int, float或char*/ typedef struct{ DataType data[ListSize]; /*向量data用于存放表结点*/int length; /*当前的表长度*/}SeqList;/*子函数的声明*/void CreateList(SeqList * L,int n); /*创建顺序表函数*/int LocateList(SeqList L,DataType x); /*查找顺序表*/void InsertList(SeqList * L,DataType x,int i); /*在顺序表中插入结点x*/void DeleteList(SeqList * L,int i);/*在顺序表中删除第i个结点*/void PrintList(SeqList L,int n); /*打印顺序表中前n个结点*/void main(){SeqList L;int n=10,x,i; /*欲建立的顺序表长度*/L.length=0;/*调用创建线性表函数*/printf("create function:\n");CreateList(&L,n); /*建立顺序表*/PrintList(L,n); /*打印顺序表*//*调用查找函数*/printf("search function:\n");printf("input the data you want to search:");scanf("%d",&x);i=LocateList(L,x); /*顺序表查找*/if (i==0)printf("sorry,don't find %d!\n\n",x);elseprintf("i have find the %d,it locate in %d!\n\n",x,i);/*调用插入函数*/printf("Insert function:\n");printf("输入要插入的位置:(input the position:)");scanf("%d",&i);printf("输入要插入的元素:(input the data:)");scanf("%d",&x);InsertList(&L,x,i); /*顺序表插入 */PrintList(L,n); /*打印顺序表 *//*调用删除函数*/printf("delete function:\n");printf("输入要删除的位置:(input the position:)");scanf("%d",&i);DeleteList(&L,i); /*顺序表删除 */PrintList(L,n); /*打印顺序表 */}/*顺序表的建立:*/void CreateList(SeqList *L,int n){ int i;for (i=0;i<n;i++){ printf("\ninput the %d data:",i+1);scanf("%d",&(*L).data[i]);}(*L).length=n;}/*顺序表的查找:*/int LocateList(SeqList L,DataType x){ int i=0;while (i<L.length&&x!=L.data[i])++i;if (i<L.length) return i+1;else return 0;}/*顺序表的插入:*/void InsertList(SeqList *L,DataType x,int i){/*将新结点x插入L所指的顺序表的第i个结点的位置上 */ int j;if (i<0||i>(*L).length){printf("插入位置非法");exit(0);}if ((*L).length>=ListSize){printf("表空间溢出,退出运行");exit(0);}for (j=(*L).length-1;j>=i-1;j--)(*L).data[j+1]=(*L).data[j]; /*顺序表元素从后向前依次后移*/ (*L).data[i-1]=x; /*将x插入第i个结点位置*/(*L).length++; /*表长自增1*/}/*顺序表的删除:*/void DeleteList(SeqList *L,int i){/*从L所指的顺序表中删除第i个结点 */int j;if (i<0 || i>(*L).length){printf("删除位置非法");exit(0);}for (j=i;j<=(*L).length-1;j++)(*L).data[j]=(*L).data[j+1]; /*顺序表自第i个结点开始,依次前移*/ (*L).length--; /*表长自减1*/}/*顺序表的打印:*/void PrintList(SeqList L,int n){ int i;printf("the sequal list data is:");for (i=0;i<n;i++)printf("%d ",L.data[i]);printf("\n\n");}四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:六、对算法的程序的讨论、分析,改进设想,其它经验教训:七、对实验方式、组织、设备、题目的意见和建议:。
顺序表的操作实验报告
![顺序表的操作实验报告](https://img.taocdn.com/s3/m/3a960c3103768e9951e79b89680203d8ce2f6a8c.png)
顺序表的操作实验报告顺序表的操作实验报告一、引言顺序表是一种常见的数据结构,它在计算机科学中被广泛应用。
本实验旨在通过实际操作顺序表,探索其基本操作和性能。
二、实验目的1. 理解顺序表的基本原理和数据结构;2. 掌握顺序表的插入、删除、查找等操作;3. 分析顺序表操作的时间复杂度。
三、实验过程1. 初始化顺序表:首先,我们创建一个空的顺序表,并设定其初始长度为10。
2. 插入元素:在顺序表中插入若干个元素,观察插入操作的效果。
我们可以通过在表尾插入元素,或者在表中间插入元素来测试插入操作的性能。
3. 删除元素:从顺序表中删除指定位置的元素,并观察删除操作的效果。
我们可以选择删除表尾元素或者表中间元素来测试删除操作的性能。
4. 查找元素:在顺序表中查找指定元素,并返回其位置。
我们可以选择查找表头元素、表尾元素或者表中间元素来测试查找操作的性能。
5. 扩容操作:当顺序表的长度不足以容纳更多元素时,我们需要进行扩容操作。
在实验中,我们可以在插入元素时观察到扩容操作的效果。
四、实验结果与分析1. 初始化顺序表:成功创建了一个长度为10的空顺序表。
2. 插入元素:通过在表尾插入10个元素,我们观察到插入操作的时间复杂度为O(1)。
然而,当我们在表中间插入元素时,需要将插入位置之后的所有元素后移,时间复杂度为O(n)。
3. 删除元素:从表尾删除元素的时间复杂度为O(1),而从表中间删除元素需要将删除位置之后的所有元素前移,时间复杂度为O(n)。
4. 查找元素:在顺序表中查找元素的时间复杂度为O(n),因为需要逐个比较每个元素。
5. 扩容操作:当顺序表的长度不足以容纳更多元素时,我们需要进行扩容操作。
在实验中,我们观察到扩容操作的时间复杂度为O(n),因为需要将原有元素复制到新的更大的空间中。
五、实验总结通过本次实验,我们深入了解了顺序表的基本操作和性能。
顺序表的插入、删除和查找操作的时间复杂度与操作位置有关,需要注意选择合适的操作位置以提高效率。
顺序表实验报告
![顺序表实验报告](https://img.taocdn.com/s3/m/5b069f5c974bcf84b9d528ea81c758f5f61f29de.png)
顺序表实验报告1. 简介顺序表是一种常用的数据结构,它在计算机科学中有着重要的应用。
本实验旨在通过实践操作顺序表,深入理解其原理和实现方式。
2. 实验目的本次实验有以下几个目的:- 学习使用顺序表来存储和操作数据;- 掌握顺序表的插入、删除、查找等基本操作;- 理解顺序表的实现原理,并分析其优缺点。
3. 实验环境和工具本实验所用环境为Windows系统,编程语言为C++。
编程工具可以选择Visual Studio或者其他C++开发工具。
4. 实验步骤4.1 实验准备首先,我们需要定义顺序表的数据结构。
例如,我们可以定义一个结构体,其中包含一个数组和一个指示当前表中元素个数的变量。
4.2 插入操作接下来,我们可以编写插入操作的函数。
插入操作的目的是将一个元素插入到指定位置,并保持表中其他元素的顺序。
可以使用循环将需要移动的元素逐个后移,然后将新元素插入到指定位置。
4.3 删除操作与插入操作类似,删除操作也需要保持表中其他元素的顺序。
可以使用循环将需要删除的元素之后的元素逐个前移,然后将最后一个元素的位置置为空。
4.4 查找操作查找操作可以通过循环遍历表中的元素,并与目标元素进行比较,直到找到相等的元素或者遍历到表尾。
5. 实验结果与分析经过实验,我们可以发现使用顺序表存储数据的效率较高。
顺序表的插入和删除操作时间复杂度为O(n),其中n为表中元素个数。
这是因为插入或删除一个元素后,需要移动其他元素以保持顺序。
而查找操作的时间复杂度为O(n),在最坏的情况下需要遍历整个表才能找到目标元素。
此外,顺序表还具有便于随机访问的优点。
由于顺序表中元素在内存中连续存储,可以直接通过索引访问表中的任意元素,因此查找效率较高。
然而,顺序表也有一些缺点。
首先,插入和删除操作需要移动大量元素,当表中元素个数较大时,操作的时间复杂度会较高。
其次,由于顺序表必须预先分配一定大小的连续空间,因此当表中元素个数超过初始大小时,需要进行动态扩容操作。
数据结构实验一顺序表实验报告
![数据结构实验一顺序表实验报告](https://img.taocdn.com/s3/m/e13d5d13a517866fb84ae45c3b3567ec102ddc27.png)
数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作,深入理解线性表的逻辑结构和存储结构,掌握顺序表的插入、删除、查找等操作的实现方法,提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为 C 语言,编程环境为 Visual Studio 2019。
三、实验原理顺序表是一种线性表的存储结构,它使用一组连续的存储单元依次存储线性表中的元素。
在顺序表中,元素的逻辑顺序与物理顺序是一致的。
顺序表的基本操作包括初始化、插入、删除、查找、遍历等。
在实现这些操作时,需要考虑顺序表的存储空间是否已满、插入和删除元素时元素的移动等问题。
四、实验内容(一)顺序表的定义```cdefine MAXSIZE 100 //定义顺序表的最大长度typedef struct {int dataMAXSIZE; //存储顺序表的元素int length; //顺序表的当前长度} SeqList;```(二)顺序表的初始化```cvoid InitList(SeqList L) {L>length = 0;}```(三)顺序表的插入操作```cint InsertList(SeqList L, int i, int e) {if (L>length == MAXSIZE) {//顺序表已满return 0;}if (i < 1 || i > L>length + 1) {//插入位置不合法return 0;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;return 1;}```(四)顺序表的删除操作```cint DeleteList(SeqList L, int i, int e) {if (L>length == 0) {//顺序表为空return 0;}if (i < 1 || i > L>length) {//删除位置不合法}e = L>datai 1; //取出被删除的元素for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length;return 1;}```(五)顺序表的查找操作```cint SearchList(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}}```(六)顺序表的遍历操作```cvoid TraverseList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```五、实验步骤1、打开 Visual Studio 2019,创建一个新的 C 语言项目。
数据结构实验一顺序表问题及实验报告模板 - Copy
![数据结构实验一顺序表问题及实验报告模板 - Copy](https://img.taocdn.com/s3/m/043d86691eb91a37f1115c80.png)
else l = m + 1;
}
return NONE;
}
public static void main(String[] args) {
String[] word1 = {"dog", "cat", "rat", "pig", "fox", "eel"};
for (int t = 0; t < testcases.length; t++) {
String target = testcases[t];
System.out.println(target
+ " " + linearSearch1(word1, left1, right1, target) + " "
}
public static int linearSearch2(Comparable[] a, int left, int right, Comparable val)
{
for (int i = left; i <= right; i++)
{ int comp = pareTo(a[i]);
String target = testcases[t];
System.out.println(target
+ " " + linearSearch1(word1, left1, right1, target) + " "
+ linearSearch2(word2, left2, right2, target)
数据结构上机报告-范例
![数据结构上机报告-范例](https://img.taocdn.com/s3/m/7c89c80b763231126edb114f.png)
intDelete_Sq(SqList &L, ElemType x) //删除找到的第一个元素x
intDeleteAll_Sq(SqList &L,ElemType x) //删除所有值为x的元素
intListDelete_Sq(SqList &L,inti,int&e) //删除第i个元素
intLocateElem_Sq(SqList L, ElemType e) //查找元素e,若存在,返回位置,否则返回0
voidMergeList_Sq(SqList La,SqList Lb,SqList &Lc) //合并两个有序表
基本要求
1.实现顺序表的基本操作,包括顺序表的初始化、第i个元素前插入一个新的元素、删除第i个元素、查找某元素、顺序表的销毁。
2.写一个函数,建立并显示含有n个整数的顺序表
3.写一个函数,实现对有序表(非递减)插入一个元素的功能
4.写一个函数,实现两个有序(非递减)表合并生成新的有序表的功能
5.编写一个界面友好的测试程序,能够对各种边界条件进行测试,验证上述算法的正确性。
《数据结构》上机报告
2011年月日
姓名:
学号:
班级:
得分:
试验题目
顺序表
实验目的
理解顺序表的逻辑结构和存储结构,熟练掌握顺序表的相关操作。
问题描述
顺序表是指采用顺序存储结构的线性表,它利用内存中的一片连续存储区域存放表中的所有元素。可以根据需要对表中的所有数据进行访问,元素的插入和删除可以在表中的任何位置进行。
数据结构第一次上机实验报告
![数据结构第一次上机实验报告](https://img.taocdn.com/s3/m/5f9b26c0bb4cf7ec4afed0a8.png)
数据结构第一次上机实验报告(线性表)实验要求:1、实现顺序表结构的创建、插入、删除、查找等操作;2、利用上述顺序表操作实现如下程序:建立两个顺序表表示的集合(集合中无重复的元素),并求这样的两个集合的并、交和源程序://C++实现//visual studi o 2010下编译通过#include<iostream>#include<vector>#include<algorithm>using namespace std;const size_t MaxSize=20;//顺序表初始分配量class SqList//顺序表类{//privata:int data[MaxSize];int length;//顺序表长度public:void InitList();//初始化void CreatList(int a[],int n);//创建void SearhList();//查找void InsertList();//插入void DeleteList(); //删除};//初始化线性表void SqList::InitList(){length=0;}//创建线性表void SqList::CreatList(int a[],int n){ cout<<"创建的顺序表:\n";for(int i=0;i<n;++i){data[i]=a[i];cout<<data[i]<<" ";}cout<<endl;length=n;}//顺序表的查找void SqList::SearhList(){int k=0;int number;//要查找的数据if(length==0)cout<<"空表"<<endl;else{cout<<"输入要查找的数据:"<<endl;cin>>number;for(int i=0;i<length;++i){if(data[i]==number){k=1;cout<<"查找成功,下标为:"<<i<<endl;break;}//if}//for}//el se}//顺序表的插入void SqList::InsertList(){int i,number;cout<<"请输入要插入的数据:"<<endl;cin>>number;cout<<"输入插入的位置:"<<endl;cin>>i;while(i<1||i>length){cout<<"越界,请重新输入插入位置:"<<endl;cin>>i;}i=i-1;for(int j=length+1;j>i;--j)data[j]=data[j-1];//插入位置后面的元素后移一位data[i]=number;//插入元素length=length+1;//表长加1cout<<"插入元素的线性表:\n";for(int k=0;k<length;++k)cout<<data[k]<<" ";cout<<endl;}//顺序表的删除void SqList::DeleteList(){int i;cout<<"输入要删除的位置:"<<endl;cin>>i;while(i<1||i>length){cout<<"越界,请重新输入要删除的位置:"<<endl;cin>>i;}i=i-1;for(int j=i;j<length-1;++j)data[j]=data[j+1];length=length-1;cout<<"删¦除后的顺序表:\n";for(int k=0;k<length;++k)cout<<data[k]<<" ";cout<<endl;}int main(){SqList L;L.InitList();//初始化int a[10];cout<<"向线性表输入数据(10个各不相等Ì的整数):"<<endl;for(int m=0;m<10;++m)cin>>a[m];L.CreatList(a,10);L.SearhList();L.InsertList();L.DeleteList();cout<<"线性表集合操作"<<endl;vector<int> ivec1;vector<int> ivec2;cout<<"向线性表输入数据(10个各不相等的整数):"<<endl;//以矢量容器的形式存储线性表for(int n=0;n<10;++n){while(cin>>a[n]){ivec1.push_back(a[n]);break;}}cin.clear();cout<<"向线性表输入数据(10个各不相等的整数):"<<endl;for(int n=0;n<10;++n){while(cin>>a[n]){ivec2.push_back(a[n]);break;}}//对线性表进行排序sort(ivec1.begin(),ivec1.end());sort(ivec2.begin(),ivec2.end());cout<<"线性表1排序后:"<<endl;for(vector<int>::iterator iter1=ivec1.begin();iter1!=ivec1.end();++iter1) cout<<*iter1<<" ";cout<<endl;cout<<"线性表2排序后¨:"<<endl;for(vector<int>::iterator iter2=ivec2.begin();iter2!=ivec2.end();++iter2) cout<<*iter2<<" ";cout<<endl;//两线性表的交void AND(vector<int> &ivec1,vector<int> &ivec2);{vector<int> ivec;for(vector<int>::iterator it1=ivec1.begi n();it1!=ivec1.end();++it1){for(vector<int>::iterator it2=ivec2.begi n();it2!=ivec2.end();++it2){if(*it1==*it2)ivec.push_back(*it1);}}cout<<"两线性表的交:"<<endl;if(ivec.empty()) cout<<"为空";else{for(vector<int>::iterator it=ivec.begin();it!=ivec.end();++it)cout<<*it<<" ";}cout<<endl;}//两线性表的并void OR(vector<int> &ivec1,vector<int> &ivec2);{vector<int> ivec;for(vector<int>::iterator it1=ivec1.begi n();it1!=ivec1.end();++it1)ivec.push_back(*it1);for(vector<int>::iterator it2=ivec2.begin();it2!=ivec2.end();++it2)ivec.push_back(*it2);sort(ivec.begin(),ivec.end());vector<int>::iterator end_unique=unique(ivec.begin(),ivec.end());//uni que函数将相同数据中的一个放入最后ivec.erase(end_unique,ivec.end());//erase删除unique函数返回位置到表最后的所有元素cout<<"两线性表的并:"<<endl;for(vector<int>::iterator it=ivec.begin();it!=ivec.end();++it)cout<<*it<<" ";cout<<endl;}//两线性表的差void cha(vector<int> &ivec1,vector<int> &ivec2);{vector<int>::iterator iter1;vector<int>::iterator iter2;int flag = 0;cout<<"线性表1对线性表2的差:"<<endl;for(iter1=ivec1.begin();iter1!=ivec1.end();++iter1){flag = 0;for(iter2=ivec2.begin();iter2!=ivec2.end();++iter2){if((*iter1)==(*iter2)){flag = 1;}}if(flag==0){cout << *iter1 << " ";}}if(flag==1)cout << "为空" << endl;else cout << endl;}}结果:。
数据结构上机报告(二)
![数据结构上机报告(二)](https://img.taocdn.com/s3/m/2b7f4c1203d8ce2f01662303.png)
数据结构上机报告(二)顺序表相关功能的实现小组成员一.问题提出:实现顺序表中的基本功能:(1)初始化(2)求顺序表长度(3)获取表中元素(4)查询表中元素(5)添加元素(6)删除元素二.问题分析及算法设计:这是一个关于顺序表的最基本的程序操作问题,按照顺序表的相关定义,正常编写程序即可,并没有特别之处。
三.程序设计:1.建立顺序表的数组定义Data、List;2.建立相关功能函数的定义:(1)初始化函数:Initiate(List );(2)求长度函数: Length( List );(3)取元素函数: Get( List, i, x );(4)元素复制函数:Copy( );(5)找元素函数: Locate( List, x );(6)插入元素函数: Insert( List, i, x );(7)删除元素函数: Delete( List, i );3.建立主函数main函数,实现数组的输入与输出,同时利用switch函数,调取上述功能函数;4.定义Display()函数,在运行界面上显示出功能表。
四.用户手册:(1)运行程序;(2)根据屏幕菜单,通过输入1-6,选择运行相关顺序表功能;(3)输入7,结束程序;(4)注:只能输入屏幕中列出的功能序号,输入其他数字将出错。
(5)运行结果示意图:五.调试报告:(1)在编写Locate()函数的for循环时,其中的if (key == M.L[i].ID)中的“==”写成了“=”,这样运行了很多次都不行,最后仔细再检查了一遍,才把它找出来改正了(2)最后边写Display()函数时,为了在运行屏幕上显示规整的功能菜单栏,调试了很多遍才得到这样的效果。
六.附录:程序代码#include<iostream>#include<string>using namespace std;const int MAX_N = 1000;struct Data{int ID;char Name[20];float Score;};struct List{Data L[MAX_N];int n;int max_n;};void Initiate(List &M);void Length(List &M);void Get(List &M);void Copy(Data &a, Data &b);void Locate(List &M);void Insert(List &M);void Delete(List &M);void Dispaly();void main(){int o=0,p;List M;while (o==0){Dispaly();cin >> p;switch (p){case 1:Initiate(M); break;case 2:Length(M); break;case 3:Get(M); break;case 4:Locate(M); break;case 5:Insert(M); break;case 6:Delete(M); break;case 7:o = 1; break;default:cout << "参数输入错误" << endl;}}}void Initiate(List &M){M.n = 0;M.max_n = MAX_N;cout << "顺序表初始化完成,表中有零个元素。
顺序表上机实验
![顺序表上机实验](https://img.taocdn.com/s3/m/a42a00ec856a561252d36f16.png)
顺序表上机实验一、实验目的与要求编写程序,实现顺序表各种基本运算,并在此基础上设计一个主程序完成如下功能:1)初始化顺序表L;2)一次采用尾插法插入a,b,c,d,e元素;3)输出顺序表L;4)输出顺序表L的长度;5)判断顺序表L的是否为空;6)输出顺序表L的第4个元素;7)输出元素a的位置;8)在第4个元素位置上插入f元素;9)输出顺序表L;10)删除顺序表L的第3个元素;11)输出顺序表L;12)释放顺序表。
二、实验仪器与设备安装有VC++6.0环境的计算机一台。
三、实验原理与内容线性表的顺序存储是指在内存中用地址连续的一块存储空间顺序存放线性表的各元素。
因为内存中的地址空间是线性的,因此,物理空间上的相邻实现数据元素之间的逻辑相邻关系既简单又自然。
顺序表中插入元素要大量的移动元素,删除也要大量的移动数据元素。
四、实验方法与步骤//文件名:algo2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];i nt length;} SqList;void InitList(SqList *&L){L=(SqList *)malloc(sizeof(SqList));L->length=0;}void DestroyList(SqList *L){free(L);}int ListEmpty(SqList *L){return(L->length==0);}int ListLength(SqList *L){return(L->length);}void DispList(SqList *L){int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c",L->data[i]);printf("\n");}int GetElem(SqList *L,int i,ElemType &e) {if (i<1 || i>L->length)return 0;e=L->data[i-1];return 1;}int LocateElem(SqList *L, ElemType e){int i=0;while (i<L->length && L->data[i]!=e) i++;if (i>=L->length)return 0;elsereturn i+1;}int ListInsert(SqList *&L,int i,ElemType e){int j;if (i<1 || i>L->length+1)return 0;i--; //将顺序表位序转化为elem下标*/for (j=L->length;j>i;j--) //将data[i]及后面元素后移一个位置*/ L->data[j]=L->data[j-1];L->data[i]=e;L->length++; //顺序表长度增1*/return 1;}int ListDelete(SqList *&L,int i,ElemType &e){int j;if (i<1 || i>L->length)return 0;i--; //将顺序表位序转化为elem下标*/ e=L->data[i];for (j=i;j<L->length-1;j++)L->data[j]=L->data[j+1];L->length--;return 1;}/*文件名:exp2-1.cpp*/#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];i nt length;} SqList;extern void InitList(SqList *&L);extern void DestroyList(SqList *L);extern int ListEmpty(SqList *L);extern int ListLength(SqList *L);extern void DispList(SqList *L);extern int GetElem(SqList *L,int i,ElemType &e);extern int LocateElem(SqList *L, ElemType e);extern int ListInsert(SqList *&L,int i,ElemType e);extern int ListDelete(SqList *&L,int i,ElemType &e);void main(){SqList *L;ElemType e;printf("(1)初始化顺序表L\n");InitList(L);printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf("(3)输出顺序表L:");DispList(L);printf("(4)顺序表L长度=%d\n",ListLength(L));printf("(5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf("(6)顺序表L的第3个元素=%c\n",e);printf("(7)元素a的位置=%d\n",LocateElem(L,'a'));printf("(8)在第4个元素位置上插入f元素\n");ListInsert(L,4,'f');printf("(9)输出顺序表L:");DispList(L);printf("(10)删除L的第3个元素\n");ListDelete(L,3,e);printf("(11)输出顺序表L:");DispList(L);printf("(12)释放顺序表L\n");DestroyList(L);}五、实验学时4学时六、实验结果与评价七、实验注意事项注意观察每次对顺序表的输出结果;比较每次输出结果有何不同。
数据结构上机实验指导
![数据结构上机实验指导](https://img.taocdn.com/s3/m/839ddd4a59eef8c75ebfb350.png)
《数据结构》课程上机实验指导书实验一【实验名称】顺序表的基本算法【实验目的】创建一个顺序表,掌握线性表顺序存储的特点。
设计和验证顺序表的查找、插入、删除算法。
【实验要求】(1)从键盘读入一组整数,按输入顺序形成顺序表。
并将创建好的顺序表元素依次打印在屏幕上。
(2)设计一个带选择菜单的主函数,菜单中具备任意选择删除、插入、查找数据元素的功能。
(3)当选择删除功能时,从键盘读入欲删除的元素位置或元素值,按指定方式删除;当选择插入功能时,从键盘读入新元素值和被插入位置,在指定位置插入;当选择查找功能时,从键盘读入欲查找的元素值,返回其位置序号。
(4)每种操作结束后,都能在屏幕上打印出此时顺序表元素的遍历结果。
【实验步骤】1、实验前先写好算法。
2、上机编写程序。
3、编译。
4、调试。
例程:书上参考算法2-1,2-4,2-5,2-6,2-8!带菜单的主函数参考书上2.5综合实例!注意:顺序表的结构体!typedef struct{datatype items[listsize];int length;}SpList;实验二【实验名称】单链表的基本算法【实验目的】创建一个单链表,掌握线性表链式存储的特点。
设计和验证链表的查找、插入、删除、求表长的算法。
【实验要求】(1)从键盘读入一组整数,按输入顺序形成单链表。
并将创建好的单链表元素依次打印在屏幕上。
(注意:选择头插法或者尾插法!)(2)设计一个带选择功能菜单的主函数,菜单中至少具备任意选择删除、插入、查找数据元素,和求单链表表长等几项功能。
(3)当选择删除功能时,从键盘读入欲删除的元素位置,按指定位置删除;当选择插入功能时,从键盘读入新元素值和被插入位置,在指定位置插入;当选择查找功能时,从键盘读入欲查找的元素值,返回其位置序号;当选择求表长功能时,返回该单链表表长的数值。
(4)每种操作结束后,都能在屏幕上打印出此时单链表元素的遍历结果。
【实验步骤】1、实验前先写好算法。
顺序表的基本操作实验报告
![顺序表的基本操作实验报告](https://img.taocdn.com/s3/m/673fbd5db6360b4c2e3f5727a5e9856a5712265d.png)
顺序表的基本操作实验报告顺序表的基本操作实验报告引言:顺序表是一种常见的数据结构,它以连续的存储空间来存储数据元素,具有随机访问的特点。
在本次实验中,我们将通过实践来学习顺序表的基本操作,包括插入、删除、查找等,以加深对顺序表的理解和运用。
实验目的:1. 掌握顺序表的插入操作;2. 掌握顺序表的删除操作;3. 掌握顺序表的查找操作;4. 熟悉顺序表的基本操作的时间复杂度。
实验材料和方法:1. 实验材料:计算机、编程环境;2. 实验方法:使用编程语言实现顺序表的基本操作,并进行测试。
实验过程:1. 插入操作:在顺序表中插入一个元素,需要将插入位置之后的元素依次后移,并将新元素插入到指定位置。
实现代码如下:```pythondef insert_element(seq_list, index, value):seq_list.append(None) # 在顺序表末尾添加一个空位for i in range(len(seq_list)-1, index, -1):seq_list[i] = seq_list[i-1]seq_list[index] = value```通过测试,我们可以验证插入操作的正确性和时间复杂度。
2. 删除操作:顺序表的删除操作需要将删除位置之后的元素依次前移,并将最后一个元素删除。
实现代码如下:```pythondef delete_element(seq_list, index):for i in range(index, len(seq_list)-1):seq_list[i] = seq_list[i+1]seq_list.pop()```通过测试,我们可以验证删除操作的正确性和时间复杂度。
3. 查找操作:顺序表的查找操作可以通过遍历整个顺序表来实现,也可以利用有序性进行优化。
实现代码如下:```pythondef search_element(seq_list, value):for i in range(len(seq_list)):if seq_list[i] == value:return ireturn -1```通过测试,我们可以验证查找操作的正确性和时间复杂度。
顺序表的操作实验报告
![顺序表的操作实验报告](https://img.taocdn.com/s3/m/77638270effdc8d376eeaeaad1f34693daef10dd.png)
顺序表的操作实验报告一、实验目的。
本实验旨在通过对顺序表的操作进行实验,加深对顺序表的理解,掌握顺序表的基本操作方法,提高编程能力。
二、实验内容。
1. 初始化顺序表。
2. 插入元素。
3. 删除元素。
4. 查找元素。
5. 修改元素。
6. 输出顺序表。
三、实验步骤。
1. 初始化顺序表。
首先,我们需要定义一个顺序表的结构体,包括数据元素和表长两个成员变量。
然后,通过malloc函数为顺序表分配内存空间,并初始化表长为0,表示顺序表为空表。
2. 插入元素。
插入元素是指在顺序表的指定位置插入一个新的元素。
首先,需要判断插入位置是否合法,然后将插入位置后的元素依次向后移动一位,腾出位置给新元素,最后将新元素插入到指定位置。
3. 删除元素。
删除元素是指在顺序表中删除指定位置的元素。
同样需要判断删除位置是否合法,然后将删除位置后的元素依次向前移动一位,覆盖被删除的元素,最后将表长减一。
4. 查找元素。
查找元素是指在顺序表中查找指定数值的元素,并返回其位置。
可以通过顺序遍历顺序表,逐个比较元素的数值,找到匹配的元素后返回其位置。
5. 修改元素。
修改元素是指在顺序表中修改指定位置的元素的数值。
首先需要判断修改位置是否合法,然后直接修改指定位置的元素数值即可。
6. 输出顺序表。
输出顺序表是指将顺序表中的所有元素依次输出。
可以通过循环遍历顺序表,逐个输出元素的数值。
四、实验结果。
经过实验操作,我们成功实现了顺序表的初始化、插入、删除、查找、修改和输出操作。
通过实验,我们加深了对顺序表的理解,掌握了顺序表的基本操作方法。
五、实验总结。
顺序表是一种基本的数据结构,具有较高的操作效率。
通过本次实验,我们进一步理解了顺序表的内部实现原理,掌握了顺序表的基本操作方法,提高了编程能力。
在今后的学习和工作中,我们将进一步应用顺序表的相关知识,提高自己的编程水平。
六、参考资料。
1. 《数据结构与算法分析》。
2. 《C语言程序设计》。
以上为本次顺序表的操作实验报告内容,希望能对大家有所帮助。
11DS上机指导1实验报告 (2)
![11DS上机指导1实验报告 (2)](https://img.taocdn.com/s3/m/6402a115b7360b4c2f3f6404.png)
《数据结构》实验指导(一)顺序表初始化、创建和输出一、实验目的1、学会使用VC6.0的集成开发环境。
2、掌握线性表的顺序存储结构及其编程。
二、实验内容1、根据下列程序环境的设置,完成顺序表的初始化函数status InitList_Sq(SqList *L)的编写。
#include "stdio.h"#include "stdlib.h"#define OK 1#define ERROR 0#define TRUE 1#define FALSE 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;status InitList_Sq(SqList *L) //构造一个空的顺序表{L->elem=(elemtype*)malloc(LIST_INIT_SIZE*sizeof(elemtype)); if(!L->elem) exit(OVERFLOW);L->length=0;L->listsize=LIST_INIT_SIZE;return OK;}2、在第1题的基础上,输入下面的创建顺序表函数。
status create_Sq(SqList *L)//建立一个顺序表,含有n个数据元素。
{int m,n;printf("请输入元素的个数:");scanf("%d",&n);for(m=0;m<n;m++){printf("请输入第%d个元素:",m+1);scanf("%d",&L->elem[m]);L->length++;}return OK;}3、在第1和第2题的基础上,补充完整输出顺序表中元素和元素个数的输出函数。
软基上机实验报告-顺序表调试报告
![软基上机实验报告-顺序表调试报告](https://img.taocdn.com/s3/m/c181fd88daef5ef7ba0d3c88.png)
1-1:本案例包括两个错误:1)本案例先逐个输入顺序表的元素(以-1 结束),建立顺序表,建议输入:2,4,6,8,10,-1正确读入2)显示顺序表正确显示2,4,6,8,10,3)要求输入元素x=9,正确读入4)输入位置l=2 (该元素将应被插入到第二个元素之前)正确读入5)观察顺序表内容有什么问题输出2,9,4,4,4,4,6)调试分析问题Insert_list 函数在做插入操作时循环方向错误。
应该从表尾开始每个元素都放到原位置的下一个位置直到插入位置。
void insert_list(list_type *table, int new_node, int location){int i;location = location - 1;for (i = location; i < table->length; i++) //循环方向错误{table->data[i + 1] = table->data[i];}table->data[location] = new_node;table->length++;return;}正确代码:void insert_list(list_type *table, int new_node, int location){int i;location = location - 1;for (i = table->length - 1; i >= location; --i) {table->data[i + 1] = table->data[i];}table->data[location] = new_node;table->length++;return;}解决以上错误后1)本案例先逐个输入顺序表的元素(以-1 结束),建立顺序表,建议输入:2,4,6,8,10,-1正确读入2)显示顺序表正确显示2,4,6,8,10,3)要求输入元素x=9,正确读入4)输入位置l=2 (该元素将应被插入到第二个元素之前)正确读入5)显示顺序表内容(该元素将应被插入到第二个元素之前)正确显示2,9,4,6,8,106)输入要求删除的元素位置:2正确读入7)观察顺序表内容有什么问题删去了最后一个元素,而非第二个元素8)调试分析问题delete_list 函数循环方向不对。
数据结构实验报告 顺序表基本操作
![数据结构实验报告 顺序表基本操作](https://img.taocdn.com/s3/m/00a8f3573c1ec5da50e270a1.png)
四、实验步骤
一 1. 编 写 头 文 件 。 定 义 数 据 类 型 。 分 别 写 各 个 函 数 如 ListInsern_Sq , ListDelete_Sq,LocateElem 等函数。 2.编写主函数。 在主函数里构造空的线性表, 然后利用 ListInsert 函数使用户 初始化线性表。然后调用函数操作,操作结果用 PrintList_Sq 打印出线性表的内 容 3.运行程序,完整代码见下:
-4-
else { printf("输入位置有错! \n"); printf("-------------------------------------\n"); }/**/ printf("请输入你要删除的元素的位置:\n");//删除元素 scanf("%d",&i); if(ListDelete_Sq(La,i,e)) { printf("你删除的元素为: %d,删除元素后线性表为:\n",e); PrintList_Sq(La); printf("-------------------------------------\n"); } else { printf("输入位置有错! \n"); printf("-------------------------------------\n"); } printf("请输入你要查找的元素:\n");//查找元素 scanf("%d",&e); if(i=LocateElem_Sq(La,e,cmp)) { printf("你要查找的元素在第 %d 个位置。\n",i); printf("-------------------------------------\n"); } else { printf("找不到这个元素: \n"); printf("-------------------------------------\n"); } if(ClearList_Sq(La))//清空线性表 { printf("线性表已清空。 \n"); printf("--------------------------------------\n"); } else { printf("线性表清空出错。 \n"); printf("--------------------------------------\n"); } if(Destroy_Sq(La))//撤销线性表
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
printf("\nlength of the list is:%d", lp->length);
}
/*在已创建好的顺序表中删除一个元素*/
int deletelist(list_type *lp,int i)
{
int j;
if(i<0||(i>lp->length-1))
lp->data[i]=elem;
lp->length++;
}
}
/*将创建好的顺序表元素依次输出到屏幕上*/
void printlist(list_type *lp)
{
int i;
printf("\nThese %d records are:\n", lp->length);
if(lp->length<=0)
int main()
{
listtype list;
int data,k;
createlist(&list);
printlist(&list);
printf("\n请输入要插入的元素data\n");
scanf("%d",&data);
insertlist(&list,data);
printlist(&list);
{
if(lp->data[i]<0)
{
for(j=i;j<lp->length;j++)
lp->data[j]=lp->data[j+1];
lp->length--;
}
}
}
典型测试数据:
输入:①5 4 3 2 0 -2 -3 1 6 -1②5 4 3 2 1 0 9 8 7 4 2 1 4 6
插入位置:①4②0③12
#define false 0
typedef struct
{
int data[MAXNUM];
int length;
}list_type;
void createlist(list_type *lp);
void printlist(list_type *lp);
int insertlist(list_type *lp,int i,int x);
{
printf("No data!\n");
return;
}
for(i=0; i<lp->length; i++)
printf(" %d ", lp->data[i]);
printf("\nlength of the list is:%d", lp->length);
}
/*在已创建好的顺序表中插入一个元素*/
return(scanf("%d",&k));
②删除负数元素函数从头检查删除一直无法解决连续负数存在的问题,存在多删、漏删等问题
解决办法:请教同学,改变思路,从后往前删要简单一些。
实际运行结果:
输入:①②
元素插入:①②③
元素删除;:①②③
负数元素删除:
ex1_2:
p74第9题(用顺序表实现)
#include<stdio.h>
{
int i;
printf("\n这%d个数据是:\n", l->num);
if(l->num<=0)
{
printf("没有元素存在!\n");
return;
}
for(i=0; i<l->num; i++)
printf(" %d ", l->data[i]);
}
/*在已创建好的顺序表中插入一个元素*/
int insertlist(listtype *l,int x)
{
int i,j;
for(i=0; i<=l->num; i++)
{
if(l->data[i]>x)
{
for(j=l->num-1;j>=i;j--)
l->data[j+1]=l->data[j];
l->data[i]=x;
l->num++;
{
printf("i is invalid value");
return(false);
}
for(j=i+1;j<lp->length;j++)
lp->data[j-1]=lp->data[j];
lp->length--;
return(true);
for(i=0; i<lp->length; i++)
int insertlist(list_type *lp,int i,int x)
{
int j;
if(lp->length>=MAXNUM)
{
printf("the list is fall,can not insert.");
return(false);
}
if(i<0||(i>lp->length))
元素删除;:①5 4 3 2 0 -2 -3 1 6②4 3 2 0 -2 -3 1 6③itis invalid value
负数元素删除:5 4 3 2 0 1 6
上机时遇到的问题:
①该编译系统main函数必须返回int型返回值
解决办法:编写返回int型返回值语句
printf("\n若执行成功,输入1;若执行失败,输入0");
return(true);
}
}
}
典型测试数据
元素个数:8
输入:①1 3 5 6 9 10 11 17②1 3 5 6 9 10 11 17 20
插入元素:①0②7③18④6
应输出:
输入:①1 3 5 6 9 10 11 17②1 3 5 6 9 10 11 17
插入元素:①01 3 5 6 9 10 11 17②1 3 5 6 7 9 10 11 17
上机实验报告
学生姓名:畅京博学号:2011019040028
上机实验一
顺序表:
ex1_1
1)首先创建一个顺序表:从键盘读入一组整数(长度小于等于11),按输入顺序放入顺序表,输入以-1结束(注意-1不放到顺序表内);将创建好的顺序表元素依次输出到屏幕上。
2)在已创建好的顺序表中插入一个元素:从键盘读入需插入的元素值和插入位置,调用插入函数完成插入操作;然后将顺序表元素依次输出到屏幕上。
#define MAXMUM 88
typedef struct
{
int data[MAXMUM];
int num;
}listtype;
void createlist(listtype *l);
void printlist(listtype *l);
int insertlist(listtype *l,int x);
printf("\n若执行成功,输入1;若执行失败,输入0.\n");
return(scanf("%d入表的前elenum个分量*/
void createlist(listtype *l)
{
int i,elem,j;
l->num=0;
printf("请输入现有元素个数\n");
3)在已创建好的顺序表中删除一个元素:从键盘读入欲删除的元素位置(序号),调用删除函数完成删除操作;然后将顺序表元素依次输出到屏幕上。
4)删除顺序表中元素值为负数的所有元素,然后将顺序表元素依次输出到屏幕上。
#include<stdio.h>
#define MAXNUM 11
#define true 1
解决办法:刚开始输入原元素时要注意数目
实际运行结果:
输入:①②
插入元素:①0
②7
③18
④6
个人体会:编程应注意细节,注重算法,多试多体会。
int deletelist(list_type *lp,int i);
void delete_neg_num(list_type *lp);
int main()
{
list_type list;
int a,data,k;
createlist(&list);
printlist(&list);
printf("\n输入要插入的位置a\n");
printlist(&list);
delete_neg_num(&list);
printlist(&list);
printf("\n若执行成功,输入1;若执行失败,输入0");
return(scanf("%d",&k));
}
/*从键盘读入一组整数(长度小于等于11),按输入顺序放入顺序表,输入以-1结束*/
scanf("%d",&elem);
printf("\n请按顺序输入表前%d个数据:\n", elem);
for(i=0; i<elem; i++)