实验报告一顺序表的操作

合集下载

顺序表的基本操作实验报告

顺序表的基本操作实验报告

竭诚为您提供优质文档/双击可除顺序表的基本操作实验报告篇一:顺序表的基本操作--实验报告实验报告附:源程序:#include#definemaxsize100#defineerror0#defineok1typedefstruct{intelem[maxsize];intlast;}seqList;intInsList(seqList*L,inta,inti);intLocate(seqListL,inte);intDel(seqList*L,inti);voidmain(){inti,e,a;intlist1,list2;if(L.elem[st]==-1)seqListL;st=0;for(i=0;i list1=InsList(if(list1){}elseprintf("插入失败!");printf("要查找的元素为\n");scanf("%d",printf("插入后的顺序表为:\n");for(i=0;i list2=Locate(L,e);if(!list2)printf("该元素不存在\n");}printf("该元素所在位置的序号为:%d\n",list2);/*删除元素*/printf("是否要删除该元素?\n");intm;scanf("%d",if(m){Del(printf("删除后的顺序表为:\n");for(i=0;iintInsList(seqList*L,inta,inti)//i位置,下标i-1{for(p=L->last;p>=i-1;p--)L->elem[p+1]=L->elem[p];in tp;if(L->last>=maxsize-1){}printf("表已满,无法插入");return(error);L->elem[i-1]=a;L->last++;return(ok );intLocate(seqListL,inte){}intDel(seqList*L,inti){}for(k=i;klast;k++)L->elem[k-1]=L->elem[k];intk ;inti=0;while((ilast--;returnok;篇二:线性表的基本操作实验报告实验一:线性表的基本操作【实验目的】学习掌握线性表的顺序存储结构、链式存储结构的设计与操作。

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。

在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。

我们先来介绍一下顺序表的基本概念。

顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。

顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。

在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。

我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。

在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。

总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。

实验报告一 顺序表的操作

实验报告一 顺序表的操作

《数据结构》实验报告一系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:顺序表的查找、插入与删除。

设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。

具体实现要求:从键盘输入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");}四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:六、对算法的程序的讨论、分析,改进设想,其它经验教训:七、对实验方式、组织、设备、题目的意见和建议:。

实验1 顺序表基本操作

实验1 顺序表基本操作

实验1 顺序表基本操作【实验目的】<1>熟悉C语言的上机环境,掌握C语言的基本结构<2>会定义线性表的顺序存储结构<3>熟悉对顺序表的一些基本操作<4>熟悉与线性表相关的函数的定义和使用【实验内容】[实验任务一]顺序表的基本操作1.顺序表的插入操作【操作步骤】<1>启动辅助教学软件<2>选择“C语言”<3>选择“顺序表”<4>选择“顺序表插入”<5>输入建立表的数据<6>输入插入数据元素<7>输入插入位置<8>选择单步执行2.顺序表的删除操作【操作步骤】<1>启动辅助教学软件<2>选择“C语言”<3>选择“顺序表”<4>选择“顺序表插入”<5>输入建立表的数据<6>输入删除位置<7>选择单步执行[实验任务二]编写C语言程序1. 编程实现顺序表的插入操作。

2.编程实现顺序表的删除操作。

实验2 链表的基本操作【实验目的】<1>学会定义单链表的结点类型<2>熟悉单链表的一些基本操作,依据这些操作函数定义<3>掌握线性表的链式存储结构的特点<4>掌握循环链表和双向链表的定义、构造方法等。

【实验内容】[实验任务一]验证单链表的基本操作<1>单链表的插入操作<2>单链表的删除操作[实验任务二]编写C语言程序<1>用C语言实现构造单链表<2>用C语言实现输出单链表实验3 二叉树的基本操作【实验目的】<1>熟悉二叉树的结点结构<2>熟悉二叉树的基本操作<3>学会利用递归方法编写二叉树的遍历算法【实验内容】[实验任务一]二叉树的遍历<1>先序遍历<2>中序遍历<3>后续遍历[实验任务二]编写算法<1>根据二叉树的任一遍历算法,编写求二叉树中结点个数的算法。

实验报告1-顺序表操作

实验报告1-顺序表操作

《数据结构》实验报告实验名称:顺序表的操作专业:计算机科学与技术班级:本1103学号:201108111122 姓名:秦文杰提交日期:2012.10.8一、实验目的熟练掌握线性表的类型定义方法、顺序存储方法及其基本运算(元素的插入、删除等)的实现方法,培养综合运用所学知识,根据具体问题进行数据结构设计和算法设计的能力。

二、实验要求1.在问题分析的基础上选择顺序存储结构,进行算法设计,编制程序并上机调试成功。

2.按要求完成实验报告3.保存和打印出程序的运行结果,并结合程序进行分析。

三、实验内容设计实现一个顺序表操作的综合应用程序。

要求:实现顺序表的构造、插入、删除、显示以及查找功能。

(基本要求)四、实验设计及测试结果1.数据结构typedef struct {int *elem;int length;int listsize;}SqList;2.函数调用层次结构图1 函数调用层次结构3.函数功能说明Createlist函数:创建一个顺序表;Printlist函数:输出顺序表;listinsert函数:在顺序表的第i个元素之前插入一个元素;listdelete函数:在顺序表中删除第i个元素;locatelem函数:在顺序表中查找与e等值的元素;4. 测试结果与分析上述程序在Visual C++ 6.0环境下加以实现。

经过多次测试,程序运行正确。

运行结果如图2所示。

图2 运行结果五、收获与体会通过这次课程设计:a)我进一步巩固了C语言的基础,尤其是编写C语言的结构及算法转化程序的方法。

b)做实验达到了理论与实践结合的目的,提高了自己的编程能力,c)程序由算法和数据结构组成,一个好的程序不仅算法重要,数据结构的设计也很重要。

d)程序不够简洁,还有待改进,功能还有待更完善,下一步需要改进程序为菜单形式!六、源程序#include <iostream.h>#include <malloc.h>//如需要用到其它头文件请加入。

实验一 顺序表 实验报告

实验一 顺序表 实验报告

顺序表实验报告一、实验内容和目的实验目的:掌握顺序表的建立、查找、插入和删除操作。

掌握有序表的建立、合并、插入操作。

实验内容:1. 顺序表的建立2. 顺序表的遍历3. 顺序表的元素查找4. 顺序表的元素插入5. 顺序表的元素删除6. 有序表的建立7. 有序表的遍历8. 有序表的元素插入9. 有序表的合并二、实验原理基本原理:通过连续的地址空间实现逻辑上和物理上连续的储存的一系列元素。

并在此基础上进行元素的添加,查找,删除操作。

有序表的插入算法:元素插入之前的,先跟有序表中的逐个元素进行对比,以找到合适的插入位置。

例如,已有有序表L,要向L 中插入元素18L={13,15,17,19,20,35,40}第一步:将18与L1进行比较,18 > L1,不是合适的插入位置。

第二步:将18与L2进行比较,18>L2,仍然不是不是的插入位置。

重复上述步骤,知道找到18≤Ln,然后在(n-1) 和n之间插入元素。

(如果元素比有序表中的所有元素都要大,则把该元素放到有序表的最后)此例子中,L n-1 = 17,L n = 19插入元素之后的有序表L为:L′={13,15,17,18,19,20,35,40}仍然保持有序。

重置光标的位置:程序接受两种方式的输入。

一种是输入数字后按回车,一种是利用空格间隔的连续几个数字。

然而,在使用后者输入数字的时候,会出现提示输出不正确的问题。

(如图)这个问题的原因简单如下:当程序输出“请输入第2个数字:”的时候,应该等待用户输入;然而,在程序等待输入第一个数字的时候,用户输入了五个数字。

因此,程序输出“输入第2个提示以后”,程序发现仍然有数据没有进行处理,因此把上次输入但未处理的字符当成是用户的输入。

所以没让用户输入数据就自动继续执行。

解决这个问题的思路:每次输出提示时,将光标移动到行首,因此,输出提示的时候会自动覆盖已经输出的提示信息。

效果如下:具体的解决方法:#include<windows.h>// 将光标移动到行首void ResetCursor(){HANDLE hOut;COORD cTarget;CONSOLE_SCREEN_BUFFER_INFO info;int y = 0;hOut = GetStdHandle(STD_OUTPUT_HANDLE);GetConsoleScreenBufferInfo(hOut, &info);y = info.dwCursorPosition.Y;cTarget.X = 0;cTarget.Y = y;SetConsoleCursorPosition(hOut, cTarget);}三、程序流程图四、实现步骤4.1 创建顺序表的实现①通过scanf 函数从键盘中读入数据,并通过scanf函数的返回值判断用户输入的是数字还是非数字,作为判断输入结束的判断。

顺序表的基本操作和实现实验报告(一)

顺序表的基本操作和实现实验报告(一)

顺序表的基本操作和实现实验报告(一)顺序表的基本操作和实现实验报告1. 引言顺序表是计算机科学中一种常用的数据结构,用于存储一组元素并支持快速的随机访问。

本实验旨在探究顺序表的基本操作和实现方法。

2. 实验目的•理解顺序表的概念和特性。

•学习顺序表的基本操作,包括插入、删除、查找和修改等。

•掌握顺序表的实现方法,包括静态分配和动态分配两种方式。

•培养对数据结构的抽象思维和编程能力。

3. 实验内容1.了解顺序表的定义,及其与数组的关系。

2.掌握插入操作的实现方法,包括在表头、表中和表尾插入元素。

3.掌握删除操作的实现方法,包括按索引删除和按值删除。

4.掌握查找操作的实现方法,包括按索引查找和按值查找。

5.掌握修改操作的实现方法,包括按索引修改和按值修改。

6.实现顺序表的静态分配和动态分配两种方式。

4. 实验步骤1.定义顺序表的结构体,包括数据存储区和长度属性。

2.实现插入操作,根据需要选择插入位置和移动元素。

3.实现删除操作,根据需要选择删除方式和更新长度。

4.实现查找操作,根据需要选择查找方式和返回结果。

5.实现修改操作,根据需要选择修改方式和更新元素。

6.实现顺序表的静态分配和动态分配方法。

5. 实验结果经过多次实验和测试,顺序表的基本操作都能够正确实现。

在插入操作中,能够将元素正确插入指定位置,并保持顺序表的有序性。

在删除操作中,能够按需删除指定位置或值的元素,并正确更新顺序表的长度。

在查找操作中,能够根据索引或值查找到对应的元素,并返回正确的结果。

在修改操作中,能够按需修改指定位置或值的元素,并更新顺序表的内容。

6. 实验总结本实验通过对顺序表的基本操作和实现方法的学习和实践,进一步巩固了对数据结构的理解和编程能力的培养。

顺序表作为一种常用的数据结构,对于解决实际问题具有重要的作用。

通过本次实验,我对顺序表的插入、删除、查找和修改等操作有了更深入的了解,并学会了如何实现这些操作。

通过本次实验,我还学会了顺序表的静态分配和动态分配方法,了解了它们的区别和适用场景。

实验一-顺序表的基本操作

实验一-顺序表的基本操作

实验一顺序表的基本操作一、实验目的1.掌握顺序表及其基本操作的实现。

2.掌握利用VC/TC实现数据结构的编程方法。

3.通过上机实践进一步加深对线性表的顺序存储方式理解。

4.通过上机实践加强利用数据结构解决实际应用问题的能力。

二、实验要求1.实验前做好充分准备,包括复习第一章、第二章所学内容,事先预习好本次实验内容。

2.实验时记录实验结果,按要求完成各题。

3.实验结束后,给出实验总结与分析并及时给出本次实验的实验报告。

三、实验内容与要求实验题目:顺序表的定义及其相关操作算法的实现要求:编程实现顺序表的类型定义及顺序表的初始化操作、插入操作、删除操作、取元素操作、输出操作等,并对其进行验证。

四、实验程序示例1、顺序表实验程序示例#include "stdio.h"#include "alloc.h"/*-------------(1)预定义常量及类型-----------------*/#define OK 1#define ERROR 0#define OVERFLOW -2#define TRUE 1#define FALSE 0typedef int Status;/*-------(2)顺序表类型及其基本操作函数的定义---------*/#define InitSize 100#define INCR 20typedef int ElemType; /*定义元素类型为int类型*/typedef struct{ ElemType *Elem;int Length;int ListSize;}SqList; /*SqList类型为顺序表类型*/Status InitList_sq(SqList *L) /*初始化操作函数定义*/{ L->Elem=(ElemType*)malloc(InitSize*sizeof(ElemType));if (!(L->Elem))return(OVERFLOW);L->Length=0; L->ListSize=InitSize;return OK;}Status ListInsert_sq(SqList *L, int i, ElemType e) /*插入操作函数定义*/{/* 写出你的代码 */}Status ListDelete_sq(SqList *L, int i) /*删除第i 个位置的元素 */{/* 写出你的代码 */}Status LocateElem(SqList *L, ElemType e) /*查找值为e的元素的位置 */{/* 写出你的代码 */}/* 以下为选作的 *//*void exchange ( SqList *L,int m ,int n) // 本算法实现顺序表中前 m 个元素和后 n 个元素的互换void purge(SqList *L ) // 删除顺序表 L 中冗余元素v oid ReverseSeqList(SqList &L) //倒置v oid MergeList(SqList la,SqList lb,Sqlist &lc)//有数据类型为整型顺序表La和Lb,其元素均按从小到大升序排列,编写一个算法将它们合并成一个表Lc,且Lc的元素也是按升序排列。

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作,深入理解线性表的逻辑结构和存储结构,掌握顺序表的插入、删除、查找等操作的实现方法,提高编程能力和问题解决能力。

二、实验环境本次实验使用的编程语言为 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 语言项目。

实验一 顺序表的基本操作1

实验一 顺序表的基本操作1

实验一:顺序表的基本操作一、实验目的1.掌握线性表的顺序存储结构的表示和实现方法。

2.掌握顺序表基本操作的算法实现。

3.了解顺序表的应用。

二、实验环境硬件环境要求:PC 机(单机)使用的软件名称、版本号以及模块:Visual C++ 6.0 或 Turbo C 或 Win-TC 等。

三、实验内容编写一个程序,实现顺序表的各种基本运算(假设顺序表的元素类型为 char),并在此基础上设计一个主程序完成如下功能:(1)初始化顺序表L;(2)依次采用尾插法插入a、b、c、d、e元素;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第3个元素;(7)输出元素a的位置;(8)在第4个元素位置上插入f元素;(9)输出顺序表L;(10)删除L的第3个元素;(11)输出顺序表L;(12)释放顺序表L;四、实验要求1、用 Visual C++ 6.0 或 Turbo C 或 Win-TC 工具创建文件或程序,输入代码后,进行编译运行或在控制台执行。

2、观看程序运行结果,并根据结果进行思考,对程序进行修改和总结。

3、请在实验报告上写上实验要求、规范的程序代码、运行结果和你的总结体会。

【核心算法提示】1.顺序表插入操作的基本步骤:要在顺序表中的第 i 个数据元素之前插入一个数据元素 x,首先要判断插入位置 i 是否合法,假设线性表的表长为 n,则 i 的合法值范围:1≤i≤n+1,若是合法位置,就再判断顺序表是否满,如果满,则增加空间或结束操作,如果不满,则将第 i 个数据元素及其之后的所有数据元素都后移一个位置,此时第 i 个位置已经腾空,再将待插入的数据元素 x 插入到该位置上,最后将线性表的表长增加 1。

2.顺序表删除操作的基本步骤:要删除顺序表中的第 i 个数据元素,首先仍然要判断i 的合法性,i 的合法范围是1≤i≤n,若是合法位置,则将第i 个数据元素之后的所有数据元素都前移一个位置,最后将线性表的表长减 1。

实验一顺序表的基本操作

实验一顺序表的基本操作

实验一顺序表的基本操作一、实验目的1.掌握线性表的顺序存储结构的表示和实现方法。

2.掌握顺序表基本操作的算法实现。

3.了解顺序表的应用。

4.学会用Java语言编写算法并上机调试通过。

二、实验内容1.建立顺序表。

2.在顺序表上实现插入、删除和查找操作(验证性内容)。

3.删除有序顺序表中的重复元素(设计性内容)。

4.完成一个简单学生成绩管理系统的设计(应用性设计内容)。

三、实验要求1. 验证性实验要求编程实现如下功能:(1)根据输入顺序表的长度n和各个数据元素值建立一个顺序表,并输出顺序表中各元素值,观察输入的内容与输出的内容是否一致。

(2)在顺序表的第i个元素之前插入一个值为x的元素,并输出插入后的顺序表中各元素值。

(3)删除顺序表中第i个元素,并输出删除后的顺序表中各元素值。

(4)在顺序表中查找第i个元素,如果查找成功,则显示“查找成功”和该元素在顺序表中的位置,否则显示“查找失败”。

2. 设计性实验要求编程实现删除有序顺序表中的所有重复元素,即使有序顺序表中相同的元素只保留一个:(1) 根据输入的n个非递减的有序数据建立一个有序顺序表,并输出有序顺序表中各元素值。

(2) 删除有序顺序表中所有的重复元素,并显示删除后的有序顺序表中各元素值。

3. 应用性设计实验要求编程实现一个简单学生成绩表的操作,此系统的功能包括:(1) 查询:按特定的条件查找学生(2) 修改:按学号对某个学生的某门课程成绩进行修改(3) 插入:增加新学生的信息(4) 删除:按学号删除已退学的学生的信息。

要求采用顺序存储结构来实现对上述成绩表的相关操作。

四、源程序代码/**** 验证性实验的源程序代码**/import java.util.Scanner;public class SX1_SqList {private Object[] listElem; // 线性表存储空间private int curLen; // 当前长度// 顺序表的构造函数,构造一个存储空间容量为maxSize的线性表public SX1_SqList(int maxSize) {curLen = 0; // 置顺序表的当前长度为0listElem = new Object[maxSize];// 为顺序表分配maxSize个存储单元}// 在线性表的第i个数据元素之前插入一个值为x的数据元素。

实验一顺序表的基本操作实验报告

实验一顺序表的基本操作实验报告

元素之后的所有数据都前移一个位置,最将线性表长减1。

3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。

线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool 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");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");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);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。

实验一 顺序表的操作

实验一  顺序表的操作

实验一顺序表的操作班级:12083414 姓名:黄泽承学号:120814221、实验目的和要求:1)了解顺序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)。

2) 通过在visual C++实现以上操作的C语言代码。

3)提前了解实验相关的知识(尤其是C语言)。

2、实验内容:1) 顺序表的插入算法,删除算法,顺序表的合并算法2) 顺序表应用的实例(二选一)a) 利用顺序表的基本运行,实现如果在顺序表A中出现的元素,在顺序表B中也出现,则在顺序表A中将该元素删除。

及实现A-B。

b) 顺序表A和B的元素都是非递减排列,将他们合并成一个顺序表C,要求C也是非递减排列。

代码:#include <stdio.h>#define ListSize 100typedef int DataType;typedef struct{DataType list[ListSize];int length;}SeqList;void InitList(SeqList *L){ L->length=0;}int CreatList(SeqList *L){ int n;int i=0;printf("请输入需要的元素数\n");if(i<n){i++;scanf("%d",&i);}return 0;}int GetElem(SeqList *L,int i,DataType e){e=L->list[i-1];return e;}int GetLength(SeqList *L){DataType p;p=L->length;return p;}int InsertList(SeqList *L,int i,DataType e) {int j;if(i<1||i>L->length+1){printf("插入位置i不合法!\n");return -1;}else if(L->length>=ListSize){printf("顺序表已满,不能插入元素。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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. 了解顺序表的基本概念和操作方法;2. 掌握顺序表的插入、删除、查找等操作;3. 熟悉顺序表的存储结构和实现方式。

二、实验内容。

1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 对比顺序表和链表的优缺点;3. 分析顺序表的存储结构和实现方式。

三、实验原理。

顺序表是一种线性表的存储结构,它的特点是元素之间的逻辑顺序和物理顺序一致,即在内存中连续存储。

顺序表的基本操作包括插入、删除、查找等。

1. 插入操作,在顺序表的某个位置插入一个元素,需要将插入位置后的所有元素向后移动一个位置,然后将新元素插入到指定位置。

2. 删除操作,删除顺序表中的某个元素,需要将删除位置后的所有元素向前移动一个位置,然后将最后一个元素删除。

3. 查找操作,在顺序表中查找某个元素,需要遍历整个顺序表,逐个比较元素的值,直到找到目标元素或者遍历完整个表。

四、实验步骤。

1. 实现顺序表的基本操作,包括插入、删除、查找等;2. 编写测试用例,验证顺序表的功能和正确性;3. 对比顺序表和链表的优缺点,分析其适用场景;4. 分析顺序表的存储结构和实现方式,总结其特点和应用场景。

五、实验结果与分析。

1. 实现了顺序表的基本操作,包括插入、删除、查找等,功能正常;2. 经过测试用例验证,顺序表的功能和正确性得到了验证;3. 对比顺序表和链表的优缺点,发现顺序表的插入、删除操作效率较低,但查找操作效率较高,适合静态查找;4. 分析顺序表的存储结构和实现方式,发现其适用于元素数量较少且频繁查找的场景。

六、实验总结。

通过本次实验,我们深入了解了顺序表的基本概念和操作方法,掌握了顺序表的插入、删除、查找等操作。

同时,我们对比了顺序表和链表的优缺点,分析了顺序表的存储结构和实现方式,加深了对顺序表的理解和应用。

在今后的学习和工作中,我们将根据实验结果的分析,合理选择顺序表或链表作为数据结构,以满足不同场景下的需求。

顺序表的操作实验报告

顺序表的操作实验报告

顺序表的操作实验报告一、实验目的。

本实验旨在通过对顺序表的操作进行实验,加深对顺序表的理解,掌握顺序表的基本操作方法,提高编程能力。

二、实验内容。

1. 初始化顺序表。

2. 插入元素。

3. 删除元素。

4. 查找元素。

5. 修改元素。

6. 输出顺序表。

三、实验步骤。

1. 初始化顺序表。

首先,我们需要定义一个顺序表的结构体,包括数据元素和表长两个成员变量。

然后,通过malloc函数为顺序表分配内存空间,并初始化表长为0,表示顺序表为空表。

2. 插入元素。

插入元素是指在顺序表的指定位置插入一个新的元素。

首先,需要判断插入位置是否合法,然后将插入位置后的元素依次向后移动一位,腾出位置给新元素,最后将新元素插入到指定位置。

3. 删除元素。

删除元素是指在顺序表中删除指定位置的元素。

同样需要判断删除位置是否合法,然后将删除位置后的元素依次向前移动一位,覆盖被删除的元素,最后将表长减一。

4. 查找元素。

查找元素是指在顺序表中查找指定数值的元素,并返回其位置。

可以通过顺序遍历顺序表,逐个比较元素的数值,找到匹配的元素后返回其位置。

5. 修改元素。

修改元素是指在顺序表中修改指定位置的元素的数值。

首先需要判断修改位置是否合法,然后直接修改指定位置的元素数值即可。

6. 输出顺序表。

输出顺序表是指将顺序表中的所有元素依次输出。

可以通过循环遍历顺序表,逐个输出元素的数值。

四、实验结果。

经过实验操作,我们成功实现了顺序表的初始化、插入、删除、查找、修改和输出操作。

通过实验,我们加深了对顺序表的理解,掌握了顺序表的基本操作方法。

五、实验总结。

顺序表是一种基本的数据结构,具有较高的操作效率。

通过本次实验,我们进一步理解了顺序表的内部实现原理,掌握了顺序表的基本操作方法,提高了编程能力。

在今后的学习和工作中,我们将进一步应用顺序表的相关知识,提高自己的编程水平。

六、参考资料。

1. 《数据结构与算法分析》。

2. 《C语言程序设计》。

以上为本次顺序表的操作实验报告内容,希望能对大家有所帮助。

顺序表的基本操作(5篇)

顺序表的基本操作(5篇)

顺序表的基本操作(5篇)第一篇:顺序表的基本操作*********************************** 实验题目:顺序表的基本操作班级:姓名:学号:专业:实验完成的时间:*********************************一、实验目的(1)(2)(3)(4)掌握顺序表的基本运算,熟悉对顺序表的一些基本操作和具体函数的定义。

掌握顺序表的存储结构及其基本操作。

熟悉c语言程序的基本结构,掌握函数定义、调用等功能。

熟悉c语言环境的使用及程序的输入、编辑、调试和运行的全过程。

二、实验要求(1)熟练掌握线性表的存储结构及其基本操作。

(2)理解所给出的算法,掌握顺序表在实际中的应用。

(3)将上机程序调试通过,并能独立完成一至两个拓展题目。

三、实验内容实现顺序表上的插入、删除等操作。

调试程序并对相应的输出作出分析;修改输入数据,预期输出并验证输出的结果。

加深对有关算法的理解。

(1)主要内容:#define MAXSIZE 100 /*宏定义*/ //#define OVERFLOW-2 #include “stdio.h” /*包含输入输出文件*/typedef int data;typedef struct /*定义顺序表的结构*/ {data vec[MAXSIZE];/*顺序表数据成员所占据的存储空间*/ int last;/*顺序表中最后一个元素在数组中的下标(或向量中的位置)从0开始*/ }sequenlist;int insert(L,i,x)/*在顺序表的第i个元素之前插入一个新元素x*/ sequenlist *L;int i;data x;{ int j;if(((*L).last)>=MAXSIZE-1){printf(“the list is overflow!n”);return(0);/*溢出判断*/ } else if((i<1)||(i>(*L).last+1)){printf(“position is not correct!n”);return(0);/*插入位置不正确*/ } else {for(j=(*L).last;j>=i-1;j--)/*后移元素*/(*L).vec[j+1]=(*L).vec[j];(*L).vec[i-1]=x;/*插入新元素*/(*L).last=(*L).last+1;/*修改last的值*/ } return(1);} void DELETET(L,i)sequenlist *L;int i;{ int j;if(i<1||(i>L->last+2)) printf(“删除的位置错误n”);else {for(j=i;j<=(*L).last;j++)(*L).vec[j-1]=(*L).vec[j];(*L).last--;} } void listprint(sequenlist *L)/*输出线性表*/ { int i;for(i=0;i<=(*L).last;i++)printf(“i,e=%d,%dn”,i,L->vec[i]);} main(){ sequenlist sl={{1,2,3,4,5,6,7,8,9,10},9};//直接给顺序表赋初值sequenlist *L;/*定义一个指向顺序表类型的指针变量*/ int i,j,x;//elemtype e;L=&sl;/*给指针变量赋值*/ printf(“请输入你插入的位置和数n”);scanf(“%d,%d”,&i,&x);printf(“这个插入的位置: %d n插入的数:%dn”,i,x);insert(L,i,x);listprint(L);printf(“请输入删除的位置:”);scanf(“%d”,&j);DELETET(L,j);listprint(L);}(2)预习思考题(1)定义一个定位函数locate(L,x),具有元素检索的功能。

数据结构顺序表操作实验报告

数据结构顺序表操作实验报告

实验1 顺序表的操作一、实验要求1.输入一组整型元素序列,建立顺序表。

2.实现该顺序表的遍历。

3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0。

4.判断该顺序表中元素是否对称,对称返回1,否则返回0。

5.实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。

6.* 输入整型元素序列利用有序表插入算法建立一个有序表。

7.* 利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。

8.编写一个主函数,调试上述算法。

二、源代码#include"stdio.h"#include"stdlib.h"#define ElemType int//int类型宏定义#define MAXSIZE 100//顺序结构typedef struct{ElemType elem[MAXSIZE]; //元素数组int length; //当前表长}SqList;//建立顺序表void BuildList(SqList &L){int n;printf("请输入建立顺序表的大小。

n=");scanf("%d",&n);L.length=n;printf("\n开始建立顺序表...\n");for(int i=0;i<L.length;i++)//循环建立顺序表{printf("\n请输入第%d个元素:",i+1);scanf("%d",&L.elem[i]);}printf("\n建立顺序表完毕!...\n");}//遍历顺序表void ShowList(SqList &L){int i;printf("\n开始遍历顺序表...\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n遍历结束...\n");}//在顺序表中寻找X元素int FindList(SqList &L,int x){int a=0;for(int i=0;i<L.length;i++){if(L.elem[i]==x)a=1;}if(a==1)printf("1\n");elseprintf("0\n");return 0;}//判断是否对称int Duichen(SqList &L){int j,b=1,n;n=L.length;if(n%2==0){for(j=0;j<n/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}}elsefor(j=0;j<(n-1)/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}if(b==1)printf("1\n");elseprintf("0\n");return 0;}//前面为奇数,后面为偶数void PaixuList(SqList &L){int i,j,a;for(i=1;i<L.length;i++){if(L.elem[i]%2==1){a=L.elem[i];for(j=i;j>0;j--){L.elem[j]=L.elem[j-1];}L.elem[0]=a;i++;}}for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");}int main(){SqList List;int n;while(1){printf("\n 实验一:顺序表\n");printf("\n******************************************************************");printf("\n 1.创建顺序表");printf("\n 2.遍历顺序表");printf("\n 3.在该顺序表中进行顺序查找某一元素,查找成功返回1,否则返回0");printf("\n 4.判断该顺序表中元素是否对称,对称返回1,否则返回0");printf("\n 5.该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数");printf("\n 0.退出");printf("\n******************************************************************\n");printf("\n请输入选择序号:");scanf("%d",&n);switch(n){case 0:return 0;case 1:BuildList(List);break;case 2:ShowList(List);break;case 3:int X;printf("请输入要查找值:X=");scanf("%d",&X);FindList(List,X);break;case 4:Duichen(List);break;case 5:PaixuList(List);break;default:printf(" 请输入数字0-5 \n");}}return 0;}三、运行结果1)程序主界面2)选择1建立顺序表3)选择2遍历顺序表4)选择3查询元素X5)选择4判断是否对称6)选择5奇数在前,偶数在后7)选择0退出。

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告

数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。

二、实验内容1. 实现顺序表的创建和初始化操作。

2. 实现顺序表的插入操作。

3. 实现顺序表的删除操作。

4. 实现顺序表的查找操作。

5. 实现顺序表的输出操作。

三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。

2. 初始化顺序表,将当前元素个数置为0。

3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。

- 将插入位置之后的元素依次后移一位。

- 将要插入的元素放入插入位置。

- 当前元素个数加一。

4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。

- 判断要删除的位置是否合法,若不合法则输出错误信息。

- 将删除位置之后的元素依次前移一位。

- 当前元素个数减一。

5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。

- 若找到目标值,则返回该元素的位置。

- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。

6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。

四、实验结果经过实验,顺序表的各项操作均能正确实现。

在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。

在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。

在查找操作中,可以正确返回目标值的位置。

在输出操作中,可以正确输出顺序表中的所有元素。

五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。

在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。

通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《数据结构》实验报告一
系别:班级:
学号:姓名:
日期:指导教师:
一、上机实验的问题和要求:
顺序表的查找、插入与删除。

设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。

具体实现要求:
从键盘输入10个整数,产生顺序表,并输入结点值。

从键盘输入1个整数,在顺序表中查找该结点的位置。

若找到,输出结点的位置;若找不到,则显示“找不到”。

从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出顺序表所有结点值,观察输出结果。

从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。

二、程序设计的基本思想,原理和算法描述:
(包括程序的结构,数据结构,输入/输出设计,符号名说明等)
三、源程序及注释:
#include <>
/*顺序表的定义:*/
#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; /*欲建立的顺序表长度*/
=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);
else
printf("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<&&x!=[i])
++i;
if (i< 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 ",[i]);
printf("\n\n");
}
四、运行输出结果:
五、调试和运行程序过程中产生的问题及采取的措施:
六、对算法的程序的讨论、分析,改进设想,其它经验教训:
七、对实验方式、组织、设备、题目的意见和建议:。

相关文档
最新文档