实验一 顺序表 实验报告
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。
在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。
我们先来介绍一下顺序表的基本概念。
顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。
顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。
在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。
我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。
在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。
总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。
数据结构实验一_顺序表的基本操作实验报告
实验一顺序表的基本操作一、实验目的掌握线性表的顺序表基本操作:建立、插入、删除、查找、合并、打印等运算。
二、实验要求包含有头文件和main函数;1.格式正确,语句采用缩进格式;2.设计子函数实现题目要求的功能;3.编译、连接通过,熟练使用命令键;4.运行结果正确,输入输出有提示,格式美观。
三、实验设备、材料和工具1.奔腾2计算机或以上机型2.turboc2,win-tc四、实验内容和步骤1. 建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2. 往该顺序表中第i位置插入一个值为x的数据元素。
3. 从该顺序表中第j位置删除一个数据元素,由y返回。
4. 从该顺序表中查找一个值为e的数据元素,若找到则返回该数据元素的位置,否则返回“没有找到”。
五、程序#include<stdio.h>#include<stdlib.h>#define list_init_size 10#define increment 2typedef struct {int *elem;int length,listsize;}sqlist; //类型定义void initlist_sq(sqlist &L) //初始化顺序表{ }void output(sqlist L) //输出顺序表{ }void insertlist(sqlist &L,int i, int x) //顺序表中插入x{ }void deletelist(sqlist &L,int j, int y) //顺序表中删除y{ }int locateelem(sqlist &L,int e) //顺序表中查找e{ }void main(){ }【运行结果】void initlist_sq(sqlist &L) //初始化顺序表{L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));if(!L.elem) exit (OVERFLOW);L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}void output(sqlist L) //输出顺序表{for(int i=0;i<=L.length-1;i++)printf("%d,",L.elem[i]);return OK;}void insertlist(sqlist &L,int i, int x) //顺序表中插入x{int p,q;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){newbase=(int*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));if(!newbasde)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;*p=x;++L.length;return ok;}void deletelist(sqlist &L,int j, int y) //顺序表中删除y{int p,q;if(i<1||I>L.length+1) return ERROR;p=&(L.elem[i-1]);y=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return ok;}int locateelem(sqlist &L,int e) //顺序表中查找e { int p;i=1;p=L.elem;while(i<=L.length&&!(*p++,e))++i;if(i<=L.length) return i;else return 0;}void main(){int d,p,a,b;int c;initlist_sq(&L);output( L);insertlist( &L, d, a);deletelist( &L, p, b);locateelem( &L, c);}。
顺序表实验报告
顺序表实验报告
摘要:
一、实验背景及目的
二、实验对象与方法
三、实验结果与分析
四、实验总结与建议
正文:
一、实验背景及目的
随着科技的不断发展,顺序表在各种领域的应用越来越广泛。
为了进一步了解顺序表的性能和特点,本实验对顺序表进行了相关测试。
实验旨在通过对比分析,评估顺序表在不同条件下的表现,为后续研究与应用提供参考依据。
二、实验对象与方法
1.实验对象:某品牌顺序表产品
2.实验方法:
(1)根据实验需求,制定实验方案,明确实验步骤与评价标准;
(2)将顺序表产品置于不同环境下,如高温、低温、湿度等,观察其性能变化;
(3)通过数据记录与分析,评估顺序表在不同环境下的稳定性、可靠性和适用性。
三、实验结果与分析
1.顺序表在不同环境下的性能表现:
(1)在高温环境下,顺序表表现稳定,数据传输速率较快;
(2)在低温环境下,顺序表仍能正常工作,性能略有下降;
(3)在湿度较大的环境下,顺序表出现一定程度的性能波动,但整体表现良好。
2.分析:
(1)顺序表在不同环境下性能表现差异较小,说明产品具有较强的适应性;
(2)在湿度较大环境下,性能略有波动,可能与产品内部结构有关,需进一步优化;
(3)实验结果符合预期,顺序表产品具备较好的稳定性和可靠性。
顺序表实验报告
实验报告实验项目名称实验一线性表的操作所属课程名称数据结构实验类型验证实验实验日期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已存在。
实验报告一 顺序表的操作
《数据结构》实验报告一系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:顺序表的查找、插入与删除。
设计算法,实现线性结构上的顺序表的产生以及元素的查找、插入与删除。
具体实现要求:从键盘输入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。
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语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。
数据结构-顺序表-实验报告
实验报告课程数据结构及算法实验项目 1.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机,Windows,DOS,Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算(1)问题描述顺序表时常进行的运算包括:创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。
试编程实现顺序表的这些基本运算。
(2)基本要求实现顺序表的每一个运算要求用一个函数实现。
(3)算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。
(4)算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果:构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。
顺序表的基本操作和实现实验报告(一)
顺序表的基本操作和实现实验报告(一)顺序表的基本操作和实现实验报告1. 引言顺序表是计算机科学中一种常用的数据结构,用于存储一组元素并支持快速的随机访问。
本实验旨在探究顺序表的基本操作和实现方法。
2. 实验目的•理解顺序表的概念和特性。
•学习顺序表的基本操作,包括插入、删除、查找和修改等。
•掌握顺序表的实现方法,包括静态分配和动态分配两种方式。
•培养对数据结构的抽象思维和编程能力。
3. 实验内容1.了解顺序表的定义,及其与数组的关系。
2.掌握插入操作的实现方法,包括在表头、表中和表尾插入元素。
3.掌握删除操作的实现方法,包括按索引删除和按值删除。
4.掌握查找操作的实现方法,包括按索引查找和按值查找。
5.掌握修改操作的实现方法,包括按索引修改和按值修改。
6.实现顺序表的静态分配和动态分配两种方式。
4. 实验步骤1.定义顺序表的结构体,包括数据存储区和长度属性。
2.实现插入操作,根据需要选择插入位置和移动元素。
3.实现删除操作,根据需要选择删除方式和更新长度。
4.实现查找操作,根据需要选择查找方式和返回结果。
5.实现修改操作,根据需要选择修改方式和更新元素。
6.实现顺序表的静态分配和动态分配方法。
5. 实验结果经过多次实验和测试,顺序表的基本操作都能够正确实现。
在插入操作中,能够将元素正确插入指定位置,并保持顺序表的有序性。
在删除操作中,能够按需删除指定位置或值的元素,并正确更新顺序表的长度。
在查找操作中,能够根据索引或值查找到对应的元素,并返回正确的结果。
在修改操作中,能够按需修改指定位置或值的元素,并更新顺序表的内容。
6. 实验总结本实验通过对顺序表的基本操作和实现方法的学习和实践,进一步巩固了对数据结构的理解和编程能力的培养。
顺序表作为一种常用的数据结构,对于解决实际问题具有重要的作用。
通过本次实验,我对顺序表的插入、删除、查找和修改等操作有了更深入的了解,并学会了如何实现这些操作。
通过本次实验,我还学会了顺序表的静态分配和动态分配方法,了解了它们的区别和适用场景。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作,深入理解线性表的逻辑结构和存储结构,掌握顺序表的插入、删除、查找等操作的实现方法,提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为 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
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)
1.C语言顺序表实验报告
实验报告要求一、实验目的二、实验内容三、程序流程图四、实验结果(要求检测所有情况的正确性,写出测试条件及相应的测试结果)五、完成思考题实验一顺序表的基本操作(2学时)一、实验目的了解顺序表的逻辑特征,掌握顺序表的描述方法、特点及有关的概念,掌握顺序表上的插入和删除等基本操作算法。
二、实验内容在顺序表List []中,实现顺序表的基本操作,包括:初始化顺序表,在表中插入元素、删除元素。
基本要求:(1)顺序表的元素个数可随意设定;(2)可连续测试任意多个元素的插入、删除,(插入、删除位置及要插入元素数值均从键盘输入);(3)任一操作结束后将顺序表中的内容输出;(4)可由用户选择退出程序。
三、实验要点及说明顺序表又称为线性表的顺序存储结构,它是用一组地址连续的存储单元依次存放线性表的各个元素。
可按如下格式定义顺序表:#define MAXLEN 50 /* 定义顺序表最大元素个数50 */typedef struct{datatype List[MAXLEN];/* 定义顺序表List */int Num; /* 定义顺序表表长*/}Seqlist;模块划分:(1)initiq( )函数:初始化顺序表(2)insertq( )函数:实现插入功能(3)deleteq( )函数:实现删除功能(4)print( )函数:实现输出功能四、参考源程序#include <stdio.h>#define MAXLEN 50typedef int datatype;typedef struct{datatype List[MAXLEN];int Num;}Seqlist;void initiq(Seqlist *la );int insertq(Seqlist *la,int n);int deleteq(Seqlist *la,int n);int print(Seqlist *la);void main(){ Seqlist la;int s,n; /* s 选择输入,n 插入或删除数据的个数*/printf("请输入你的选择: 1---initiate 2---insert 3---delete 4---print 5---exit\nyour choice =");scanf("%d",&s);while(s!=5){ if(s==1){ initiq( &la );printf("完成初始化!\n"); }else if(s==2){ printf("请输入待插入的数据个数:");scanf("%d",&n);insertq(&la,n);print(&la); }else if(s==3){ printf("请输入待删除的数据个数:");scanf("%d",&n);deleteq(&la,n);print(&la); }else if(s==4){ print(&la); }elseprintf("你的选择是错误的!\n ");printf("请输入你的选择: 1---initiate 2---insert 3---delete 4---print 5---exit\nyour choice =");scanf("%d",&s); } }/*初始化*/void initiq(Seqlist *la ){ la-> Num=0; }/*插入*/int insertq(Seqlist *la,int n){ int i,j; /* i 插入位置,j 顺序表下标*/datatype x; /* x 插入数据*/while(n){ if (la->Num>=MAXLEN-1){ printf ("\n 表满,不能插入!插入未完成,还有%d个数据未插入\n",n);return 0; }printf("请输入插入的位置和数据:");scanf("%d%d",&i,&x);if (i<0||i>la->Num){ printf ("\n 插入位置不合理!\n"); }else{ if (i== la->Num)la->List[i]=x;else{ for ( j=la->Num; j>i; j--)la->List[j]=la->List[j-1];la->List[i]=x; }la->Num++;n--; } }printf("插入完成\n");return 1; }/*删除*/int deleteq(Seqlist *la,int n){ int i,j; /* i 删除位置,j 顺序表下标*/while(n){ if (la->Num<=0){ printf ("\n 表空,不能删除!\n");return 0; }printf("请输入删除的位置:");scanf("%d",&i);if (i<0||i>=la->Num){ printf ("\n 删除位置错误!\n"); }else{ for ( j=i+1; j<la->Num; j++)la->List[j-1]=la->List[j];la->Num--;n--; } }printf("删除完成!\n");return 1; }/*显示输出*/int print (Seqlist *la){ int m;if (la->Num<=0){ printf("顺序表为空!\n");return 0; }else{ printf("当前的顺序表为:\n");for(m=0;m<la->Num;m++)printf("List[%d]=%d ",m,la->List[m]);printf("\n表长为%d\n",la->Num);return 1; } }五、思考题1.设顺序表L中的数据元素按递增排列,编写一个算法,将数据元素x插入到顺序表L的适当位置上,以保持顺序表的有序性。
顺序表实验报告
顺序表实验报告实验名称:顺序表的实现与操作实验目的:1.理解顺序表的概念、特点和实现方式。
2.掌握顺序表的基本操作,包括初始化、插入、删除、查找、修改、清空等操作。
3.提高编程能力,加深对数据结构的理解。
实验原理:顺序表是数据结构中的一种线性表,采用连续的存储方式来存储元素,其具有访问速度快的特点。
在顺序表中,元素在物理存储上是连续的,每个元素占据一定的存储空间。
顺序表的实现需要使用数组,可以通过数组下标查找具体元素,也可以通过数组长度限定表的大小。
实验步骤:1.定义顺序表结构体struct SeqList{int size;//表的大小int length;//表的长度int *data;//存储数据的指针};2.初始化操作void initSeqList(SeqList &list,int size){list.size = size;list.length = 0;list.data = new int[size];}3.插入操作void insertSeqList(SeqList &list,int pos,int elem){ if(pos<1 || pos>list.length+1){cout<<"位置不合法"<<endl;return;}if(list.length>=list.size){cout<<"顺序表已满"<<endl;return;}for(int i=list.length-1; i>=pos-1; i--){list.data[i+1] = list.data[i];}list.data[pos-1] = elem;list.length++;}4.删除操作void deleteSeqList(SeqList &list,int pos){ if(pos<1 || pos>list.length){cout<<"位置不合法"<<endl;return;}for(int i=pos-1; i<list.length-1; i++){ list.data[i] = list.data[i+1];}list.length--;}5.查找操作int searchSeqList(SeqList list,int elem){for(int i=0; i<list.length; i++){if(list.data[i] == elem){return i+1;}}return 0;}6.修改操作void modifySeqList(SeqList &list,int pos,int elem){ if(pos<1 || pos>list.length){cout<<"位置不合法"<<endl;return;}list.data[pos-1] = elem;}7.清空操作void clearSeqList(SeqList &list){list.length = 0;}实验结果:经过上述实验操作,成功实现了顺序表的初始化、插入、删除、查找、修改、清空等操作,并能够正确输出结果。
数据结构实验报告顺序表1
数据结构实验报告顺序表1一、实验目的本次实验的主要目的是深入理解和掌握顺序表这种数据结构的基本概念、存储方式和操作方法,并通过实际编程实现,提高对数据结构的实际应用能力和编程技能。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、顺序表的基本概念顺序表是用一组地址连续的存储单元依次存储线性表中的数据元素。
在顺序表中,逻辑上相邻的元素在物理位置上也相邻。
顺序表可以随机访问表中的任意元素,但插入和删除操作可能需要移动大量元素,效率较低。
四、顺序表的存储结构在 C++中,可以使用数组来实现顺序表。
以下是一个简单的顺序表存储结构的定义:```cppconst int MAX_SIZE = 100; //定义顺序表的最大容量class SeqList {private:int dataMAX_SIZE; //存储数据元素的数组int length; //顺序表的当前长度public:SeqList(){ length = 0; }//构造函数,初始化长度为 0//其他操作函数的声明int GetLength();bool IsEmpty();bool IsFull();int GetElement(int position);int LocateElement(int element);void InsertElement(int position, int element);void DeleteElement(int position);void PrintList();};```五、顺序表的基本操作实现1、获取顺序表长度```cppint SeqList::GetLength(){return length;}```2、判断顺序表是否为空```cppbool SeqList::IsEmpty(){return length == 0;}```3、判断顺序表是否已满```cppbool SeqList::IsFull(){return length == MAX_SIZE;}```4、获取指定位置的元素```cppint SeqList::GetElement(int position) {if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl; return -1;}return dataposition 1;}```5、查找指定元素在顺序表中的位置```cppint SeqList::LocateElement(int element) {for (int i = 0; i < length; i++){if (datai == element) {return i + 1;}}return -1; //未找到返回-1}```6、在指定位置插入元素```cppvoid SeqList::InsertElement(int position, int element) {if (IsFull()){std::cout <<"顺序表已满,无法插入!"<< std::endl; return;}if (position < 1 || position > length + 1) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = length; i >= position; i) {datai = datai 1;}dataposition 1 = element;length++;}```7、删除指定位置的元素```cppvoid SeqList::DeleteElement(int position) {if (IsEmpty()){std::cout <<"顺序表为空,无法删除!"<< std::endl; return;}if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = position; i < length; i++){datai 1 = datai;}length;}```8、打印顺序表中的所有元素```cppvoid SeqList::PrintList(){for (int i = 0; i < length; i++){std::cout << datai <<"";}std::cout << std::endl;}```六、实验结果与分析1、对顺序表进行初始化,创建一个空的顺序表。
实验一顺序表的基本操作实验报告
元素之后的所有数据都前移一个位置,最将线性表长减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语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。
顺序表的操作实验报告
顺序表的操作实验报告一、实验目的。
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语言程序设计》。
以上为本次顺序表的操作实验报告内容,希望能对大家有所帮助。
线性表逆置(顺序表)实验报告
线性表逆置(顺序表)实验报告实验一:线性表逆置(顺序表)实验报告(一)问题的描述:实现顺序表的逆置算法(二)数据结构的设计:顺序集是线性表的顺序存储形式,因此设计如下数据类型则表示线性表:typedefstruct{elemtype*elem;/*存储空间基址*/intlength;/*当前长度*/intlistsize;/*当前分配的存储容量(以sizeof(elemtype)为单位)*/}sqlist;(三)函数功能、参数说明及概要设计:1.函数statusinitlist(sqlist*l)功能说明:实现顺序表l的初始化算法设计:为顺序表中分配一块大小为list_init_size的储存空间2.函数intlistlength(sqlistl)功能表明:回到顺序表中l长度算法设计:回到顺序表的length 变量3.函数statuslistinsert(sqlist*l,inti,elemtypee)功能说明:将元素e插入到顺序表l中的第i个节点算法设计:推论顺序表中与否已八十,已八十则提空间,年满则稳步,将元素e填入至第i个元素之前,并将后面的元素依次往科玄珠4.函数statuslisttraverse(sqlistl,void(*vi)(elemtype*))功能说明:依次对l的每个数据元素调用函数vi()算法设计:依次对l的每个数据元素调用函数vi()5.函数voidexchange(sqlist*l)功能说明:实现顺序表l的逆置算法设计:用for循环将顺序表中l中的第i个元素依次与第(i+length)个元素互换6.函数voidprint(elemtype*c)功能表明:列印元素c算法设计:列印元素c2.(四)具体程序的实现/*程序名*/#include#include#include/*malloc()等*/#include/*int_max等*/#include/*eof(=^z或f6),null*/#include/*atoi()*/#include/*eof()*/#include/*floor(),ceil(),abs()*/#include/*exit()*//*函数结果状态代码*/#definetrue1#definefalse0#defineok1#defineerror0#defineinfeasible-1/*#defineoverflow-2因为在math.h中已定义overflow的值3,故换成此行*/typedefintstatus;/*status就是函数的类型,其值就是函数结果状态代码,如ok等*/typedefintboolean;/*boolean就是布尔类型,其值就是true或false*/typedefintelemtype;/*线性表的动态分配顺序存储结构*/#definelist_init_size10//线性表存储空间的起始分配量#definelistincrement2//线性表存储空间的分配增量typedefstruct{elemtype*elem;//存储空间基址intlength;//当前长度intlistsize;//当前分配的存储容量(以sizeof(elemtype)为单位)}sqlist;/*顺序则表示的线性表的基本操作*/statusinitlist(sqlist*l)/*算法2.3*/{/*操作结果:构造一个空的顺序线性表*/(*l).elem=(elemtype*)malloc(list_init_size*sizeof(elemtype));if(!(*l).elem)exit(overflow);/*存储分配失败*/(*l).length=0;/*空表长度为0*/(*l).listsize=list_init_size;/*起始存储容量*/returnok;}statusdestroylist(sqlist*l){/*初始条件:顺序线性表l已存在。
数据结构顺序表操作实验报告
实验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、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
顺序表实验报告一、实验内容和目的实验目的:掌握顺序表的建立、查找、插入和删除操作。
掌握有序表的建立、合并、插入操作。
实验内容: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函数的返回值判断用户输入的是数字还是非数字,作为判断输入结束的判断。
②如果读入的是数字,向顺序表结构中的数组添加该数字,并将顺序表结构的长度变量加一;如果读入的是非数字,停止要求用户输入,顺序表的创建结束。
4.2 顺序表遍历的实现获取顺序表的长度L,通过一个for循环,对顺序表的每一个元素进行相应的操作。
(演示程序中的是输出操作)4.3 顺序表查找的实现在遍历的基础上,对顺序表中每个元素与输入的元素进行对比,如果元素相等,则返回该元素的下标。
如果整个顺序表遍历,均未发现与其相等的元素,则说明该元素不存在于该顺序表中,返回错误信息。
4.4 顺序表插入的实现由用户输入要插入的元素和插入的位置。
执行插入操作之前先对用户输入的位置信息有效性进行检查。
如果用户输入的位置信息是有效的,则先把插入位置以后的数据自后向前的方向进行后移,再把元素插入到顺序表中。
如果用户输入的位置信息是无效的,则返回错误信息。
4.5 顺序表删除的实现由用户输入要删除的元素位置。
先对位置信息进行有效性检查。
如果用户输入的位置是有效的,则把删除位置后面的元素从前至后的方向向前移动(要删除元素会被下一个元素覆盖,从而起到跟删除等效的操作)。
如果用户输入的位置是无效的,则返回错误信息。
4.6 有序表的创建见“实验原理”4.7 有序表的遍历同“顺序表的遍历”4.8 有序表的元素插入同“实验原理”4.9 有序表创建和合并操作创建原理见“实验原理”合并操作:定义两个指针p1,p2,分别指向有序表L1和L2的元素。
先通过p1和p2比较两者的大小,把小的数字放到一个新的有序表中(新有序表的创建同样遵循实验原理中描述的算法),直到其中一个有序表的元素全部放到新的有序表里。
然后,再把剩下有序表的元素依次放到新的有序表里面。
五、实验结果5.1 程序主菜单5.2 顺序表创建(接受两种输入方式)5.3 顺序表遍历输出5.4 顺序表查找(找到和没找到的两种情况)5.5 顺序表元素插入5.6 顺序表元素删除5.7 有序表创建5.8 有序表遍历输出5.9 有序表元素插入5.10 创建有序表并合并第一步:创建第一个有序表第二步:创建第二个有序表第三步:合并两个有序表六、操作说明6.1 进入主菜单以后,要演示顺序表的操作(插入,查找,删除)需要先建立顺序表。
在创建顺序表以前选择这些操作会有错误信息。
(有序表也相同)6.2 创建有序表或者顺序表时,结束的标记是非数字字符。
即输入非数字字符即可结束数据的输入流程。
6.3 程序对大部分的输入均进行检查。
确保输入数据的有效性。
七、附录:代码#include<stdio.h>#include<stdlib.h>#include<windows.h>// 屏蔽VC++ 08 scanf 函数不安全的警告信息#pragma warning(disable:4996)#define MAXSIZE 100 // 顺序表的最大元素个数#define OK 0 // 表示成功操作#define LIST_FULL -2 // 表示顺序表已满#define INDEX_OUT_OF_RANGE -3 // 表示要操作的位置超出有效范围typedef int ElemType; // 顺序表的元素类型typedef struct list{ElemType elem[ MAXSIZE ];int length;} SqList;/** 顺序表基本操作的函数实现**/// 顺序表的初始化void InitList(SqList *L){L->length = 0;}// 在顺序表末尾添加新的元素int ListAppend(SqList *L, ElemType e){// 添加元素之前先检查顺序表能否继续添加元素if ( L->length >= MAXSIZE )return LIST_FULL;L->elem[ L->length ] = e;L->length++;return OK;}// 返回e 在顺序表L 中的位置(如果e 不存在于顺序表中,则返回0)int ListIndexOf(SqList L, ElemType e){int i, l;// 获得顺序表L 的长度l = L.length;// 如果顺序表为空表,返回错误信息if (l == 0)return 0;for (i = 0; i < l; i++){// 如果找到L 中与e 相等的元素,返回元素序号if ( L.elem[i] == e ){break;}}// 如果没有找到与e 相等的元素if (i >= l)return 0;elsereturn (i + 1);}// 向顺序表某个特定的位置添加元素int ListInsert(SqList *L, int i, ElemType e){int k;// 检查i 的有效性,如果i 为无效值,则返回错误信息if (!(i >= 1 && i <= L->length + 1))return INDEX_OUT_OF_RANGE;// 检查顺序表能否继续添加数据if (L->length >= 100)return LIST_FULL;// 将数据后移for ( k = L->length - 1; k >= (i - 1); k-- ){L->elem[k + 1] = L->elem[k];}L->elem[i - 1] = e;L->length++;return OK;}// 删除顺序表中某个特定位置的元素int ListDelete(SqList *L, int i, ElemType *e) {int k;// 删除前检查位置的有效性if (!(i >= 1 && i <= L->length))return INDEX_OUT_OF_RANGE;// 删除前将值赋给e*e = L->elem[i - 1];// 把删除以后的数据全部向前移动for (k = i - 1; k < L->length; k++){L->elem[k] = L->elem[k + 1];}L->length--;return OK;}/** 具体功能的函数实现**/// 将光标移动到行首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);}// 从键盘输入数据创建顺序表void CreateSqList(SqList *L){ElemType e;// 创建顺序表之前先进行初始化操作InitList(L);// 清屏system("cls");printf("请输入要放到顺序表中的数字(输入非数字字符结束输入过程)\n");printf("请输入第%d 个数字:", L->length + 1);// 当用户输入非数字时,scanf 函数无法读入,返回0,因此可以作为判断条件while ( scanf("%d", &e) != 0 ){// 如果ListAppend 返回顺序表已满的错误信息时,函数终止。