数据结构--顺序表的插入、删除、查找等操作,有详细解释,保证你喜欢!

合集下载

codeblock数据结构算法实现-顺序表基本操作

codeblock数据结构算法实现-顺序表基本操作

数据结构算法实现-顺序表基本操作序号一、引言二、顺序表的定义三、顺序表的基本操作1.初始化操作2.插入操作3.删除操作4.查找操作四、顺序表的实现五、总结一、引言数据结构是计算机科学中非常重要的一部分,它是计算机存储、组织数据的方式。

而顺序表是其中的一种基本数据结构,它采用一组位置区域连续的存储单元依次存放线性表中的元素。

本文将着重介绍顺序表的基本操作及其算法实现。

二、顺序表的定义顺序表是一种基本的线性表,顺序表中元素的逻辑顺序和物理顺序是一致的。

顺序表的特点是利用一组连续的存储单元依次存放线性表中的元素。

顺序表可以用数组实现,其元素在内存中是连续存储的,可以通过下标直接访问元素。

由于顺序表的存储方式,使得其在查找、插入和删除等操作上具有较好的性能。

三、顺序表的基本操作顺序表的基本操作包括初始化、插入、删除和查找等。

下面分别介绍这些操作的实现方法。

1.初始化操作初始化操作是指将一个空的顺序表初始化为一个具有初始容量的顺序表,并为其分配内存空间。

初始化操作的实现方法主要有两种,一种是静态分配内存空间,另一种是动态分配内存空间。

静态分配内存空间时,需要预先指定顺序表的容量大小,然后在程序中创建一个数组,并为其分配指定大小的内存空间。

动态分配内存空间时,可以根据需要动态创建一个数组,并为其分配内存空间。

下面是一个简单的初始化操作的实现示例:```C代码#define MAXSIZE 100 // 定义顺序表的最大容量typedef struct {ElementType data[MAXSIZE]; // 定义顺序表的元素数组int length; // 定义顺序表的当前长度} SeqList;2.插入操作插入操作是指将一个新元素插入到顺序表的指定位置。

插入操作的实现方法主要包括在指定位置插入元素,同时对其他元素进行后移操作。

下面是一个简单的插入操作的实现示例:```C代码Status Insert(SeqList *L, int i, ElementType e) {if (i < 1 || i > L->length + 1) { // 判断插入位置是否合法return ERROR;}if (L->length >= MAXSIZE) { // 判断顺序表是否已满return ERROR;}for (int j = L->length; j >= i; j--) { // 插入位置及之后的元素后移L->data[j] = L->data[j - 1];}L->data[i - 1] = e; // 插入新元素L->length++; // 顺序表长度加1return OK;}```3.删除操作删除操作是指将顺序表中指定位置的元素删除。

数据结构实验一顺序表

数据结构实验一顺序表

数据结构实验一1、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点,熟练掌握顺序表的基本运算2、实验内容:建立顺序表,完成顺序表的基本操作:初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空;1.问题描述:利用顺序表,设计一组输入数据(假定为一组整数),能够对顺序表进行如下操作:∙创建一个新的顺序表,实现动态空间分配的初始化;∙根据顺序表结点的位置插入一个新结点(位置插入),也可以根据给定的值进行插入(值插入),形成有序顺序表;∙根据顺序表结点的位置删除一个结点(位置删除),也可以根据给定的值删除对应的第一个结点,或者删除指定值的所有结点(值删除);∙利用最少的空间实现顺序表元素的逆转;∙实现顺序表的各个元素的输出;∙彻底销毁顺序线性表,回收所分配的空间;∙对顺序线性表的所有元素删除,置为空表;∙返回其数据元素个数;∙按序号查找,根据顺序表的特点,可以随机存取,直接可以定位于第i 个结点,查找该元素的值,对查找结果进行返回;∙按值查找,根据给定数据元素的值,只能顺序比较,查找该元素的位置,对查找结果进行返回;∙判断顺序表中是否有元素存在,对判断结果进行返回;.编写主程序,实现对各不同的算法调用。

2.实现要求:∙“初始化算法”的操作结果:构造一个空的顺序线性表。

对顺序表的空间进行动态管理,实现动态分配、回收和增加存储空间;∙“位置插入算法”的初始条件:顺序线性表L 已存在,给定的元素位置为i,且1≤i≤ListLength(L)+1 ;操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1;∙“位置删除算法”的初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) ;操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 ;∙“逆转算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行交换,为了使用最少的额外空间,对顺序表的元素进行交换;∙“输出算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行输出;∙“销毁算法”初始条件:顺序线性表L 已存在;操作结果:销毁顺序线性表L;∙“置空表算法”初始条件:顺序线性表L 已存在;操作结果:将L 重置为空表;∙“求表长算法”初始条件:顺序线性表L 已存在;操作结果:返回L 中数据元素个数;∙“按序号查找算法”初始条件:顺序线性表L 已存在,元素位置为i,且1≤i≤ListLength(L)操作结果:返回L 中第i 个数据元素的值∙“按值查找算法”初始条件:顺序线性表L 已存在,元素值为e;操作结果:返回L 中数据元素值为e 的元素位置;∙“判表空算法”初始条件:顺序线性表L 已存在;操作结果:若L 为空表,则返回TRUE,否则返回FALSE;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

顺序表的查找、插入与删除实验报告

顺序表的查找、插入与删除实验报告
{
int j;
if(i<1 || i>L->length +1)
{
printf("插入位置非法\n");
exit(0);
}
if(L->length >=ListSize)
{
printf("表空间溢出,退出运行\n");
exit(0);
}
for(j =L->length-1; j>=i-1;j--)
L->data[j+1]=L->data[j];
{
printf("删除位置非法\<=L->length -1;j++)
L->data[j-1]=L->data[j];
L->length --;
}
三、运行输出结果:
四、调试和运行程序过程中产生的问题及采取的措施:
InsertList(&L,x,i);/*顺序表插入*/
PrintList(L,n);/*打印顺序表*/
printf("输入要删除的位置:");
scanf("%d",&i);
DeleteList(&L,i);/*顺序表删除*/
PrintList(L,n);/*打印顺序表*/
}
/*顺序表的建立:*/
void CreateList(SeqList *L,int n)
{
int i;
for(i=0;i<n;i++)
scanf ("%d",&L->data[i]);
L->length=n;

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

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

实验报告课程数据结构及算法实验项目 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 顺序表的操作及其应用一、实验目的1)掌握线性表的顺序存储结构;2)熟练掌握顺序表基本算法的实现;3)掌握利用线性表数据结构解决实际问题的方法和基本技巧;4)按照实验题目要求独立正确地完成实验内容二、实验内容要求:数据元素类型ElemType 取整型int 或者char。

顺序存储实现如下算法:1)创建一顺序表;2)输出该顺序表;3)在顺序表中查找第i 个元素,并返回其值;4)在顺序表中第i 个元素之前插入一已知元素;5)在顺序表中删除第i 个元素;6)实现顺序表的合并。

(选做)源程序://A Sequential List顺序表#include <stdio.h>#include <malloc.h>#include <process.h>#include <stdlib.h>#include <conio.h>#include <windows.h>#define InitSize 100 //线性表存储空间的初始分配量#define ListIncrement 10 //线性表存储空间的分配增量typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;Status InitList(SqList &L) //初始化{L.elem=(ElemType *)malloc(InitSize*sizeof(ElemType));if(!L.elem)exit(OVERFLOW);L.length=0;L.listsize=InitSize;return OK;}//求表长int ListLength(SqList &L){return L.length;}//输入元素int DataInput(SqList &L){int i=1,j=1;printf("输入数据后,按“0”结束输入\n");while(j){scanf("%d",&j);if(j!=0){L.elem[i]=j;L.length++;i++;if(i>InitSize)break;}}return FALSE;}//输出顺序表Status ListTraverse(SqList L){ElemType *p;int i;p=L.elem;for(i=0;i<L.length;i++)printf("%d ",*p++);printf("\n");return OK;}Status GetElem(SqList L,int i,ElemType &e){if(i<1||i>L.length)exit(ERROR);e=L.elem[i-1];return OK;}//插入元素Status ListInsert(SqList &L,int i,ElemType e){ElemType *newbase,*q,*p;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){newbase=(ElemType *) realloc(L.elem,(L.listsize+ListIncrement)*sizeof(ElemType));if(!newbase)exit(OVERFLOW);L.elem=newbase;L.listsize=L.listsize+ListIncrement;}q=&(L.elem[i-1]);for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}//删除元素Status ListDeletSq(SqList &L,int i,ElemType &e){ElemType *p,*q;if(i<1||i>L.length)return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return OK;}int main(){SqList L;ElemType e;char ch;int t;while(1){system("cls");printf("\t------------MENU------------------\n");printf("\t|1.创建一顺序表|\n"); printf("\t|2.输入数据|\n"); printf("\t|3.输出顺序表|\n"); printf("\t|4.查找表中元素|\n"); printf("\t|5.于表中插入元素|\n"); printf("\t|6.删除表中元素|\n"); printf("\t|7.退出|\n"); printf("\t|---------------------------------\n");fflush(stdin);ch=getchar();if(ch=='7')break;switch(ch){case '1': InitList(L);printf("初始化顺序表成功!\n");printf("按任何键继续操作···\n");getch();break;case '2':DataInput(L);printf("数据输入成功!\n");printf("按任何键继续操作···\n");getch();break;case '3':ListTraverse(L);getch();break;case '4':printf("你查找是第几个元素:");fflush(stdin);scanf("%d",&t);GetElem(L,t,e);printf("你查找的元素是:%d\n",e);printf("按任何键继续操作···\n");getch();break;case '5':printf("输入你要插入的元素:");scanf("%d",&e);ListInsert(L,t,e);printf("成功插入!\n");printf("按任何键继续操作···\n");getch();break;case '6':printf("你想删除第几个数据:");scanf("%d",&t);ListDeletSq(L,t,e);printf("成功删除!\n");printf("按任何键继续操作···\n");getch();break;default:break;}}return FALSE;}运行截图:主菜单:1.创建顺序表;2.输入数据:3.插入数据:三、实验总结:问题:1.刚开始接触数据结构时,完全不知道这门课程是学什么的,一脸茫然,通过反复看书,最后逐渐明白了其中的含义。

数据结构实验指导书

数据结构实验指导书

数据结构实验指导书院别专业班级姓名计算机学院编实验一线性表的顺序存储实验一、实验目的及要求1、掌握在TC环境下调试顺序表的基本方法2、掌握顺序表的基本操作,插入、删除、查找、以及有序顺序表的合并等算法的实现。

二、实验学时2学时三、实验任务1、生成一个顺序表并动态地删除任意元素和在任意位置插入元素。

2、将两个有序表合并成一个有序表。

四、实验重点、难点1、在顺序表中移动元素。

2、在顺序表中找到正确的插入位置。

五、操作要点(一)顺序表基本操作的实现[问题描述] 当我们要在顺序表的第i个位置上插入一个元素时,必须先将顺序表中第i个元素之后的所有元素依次后移一个位置,以便腾空一个位置,再把新元素插入到该位置。

若是欲删除第i个元素时,也必须把第i个元素之后的所有元素前移一个位置。

[基本要求] 要求生成顺序表时,可以键盘上读取元素,用顺序存储结构实现存储。

[实现提示] 要实现基本操作,可用实现的基本操作,也可设计简单的算法实现。

[程序实现]#include <stdio.h>#include <conio.h>typedef int DataType ;# define maxnum 20typedef struct{int data[maxnum];int length;}SeqList;/*插入函数*/int insert(SeqList *L , int i , DataType x)/* 将新结点x插入到顺序表L第i个位置 */{ int j ;if( i<0 || i>(*L).length +1){ printf(" \n i 值不合法 ! ");return 0;}if((* L).length >=maxnum-1){ printf(" \n 表满不能插入!");return 0;}for(j=(*L).length;j>=i;j--) (*L).data[j+1]=(*L).data[j];(*L).data[i] = x;(*L).length++;return 1;}/*删除函数*/int delete( SeqList *L ,int i)/*从顺序L中删除第i个结点*/{ int j ;if( i<0|| i>(*L).length ){ printf(" \n 删除位置错误 ! ") ;return 0;}for(j=i+1;j<=(*L).length;j++)(*L).data[j-1] =(*L).data[j];(*L).length--;return 1;}/*生成顺序表*/void creatlist(SeqList * L){ int n , i , j ;printf("请输入顺序表 L 的数据个数:\n") ;scanf("%d" , &n) ;for(i=0 ; i<n ; i++){ printf("data[%d] =" , i) ;scanf("%d",&((*L).data[i]));}(*L).length=n-1;printf("\n") ;}/*creatlist *//*输出顺序表 L*/printout(SeqList * L){ int i ;for (i=0 ; i<=(* L).length ; i++){ printf(" data[%d]=", i) ;printf("%d", (*L).data[i]);}/*printout */printf("\n");}main(){ SeqList *L ;char cmd ;int i , t , x;clrscr() ;creatlist(L);do{printf("\ni , I ----- 插入\n") ;printf("d , D ----- 删除\n") ;printf("q , Q ----- 退出\n") ;do{cmd=getchar() ;}while((cmd!='i')&&(cmd!='I')&&(cmd!='d')&&(cmd!='D')&&(cmd!='q')&&(cmd!='Q')); switch(cmd){ case 'i':case 'I':printf("\nPlease input the DATA: ");scanf("%d",&x) ;printf("\nWhere? ");scanf("%d",&i) ;insert(L,i,x) ;printout(L);break ;case 'd':case 'D' :printf("\nWhere to Delete? ");scanf("%d",&i);delete(L,i);printout(L);break ;}}while((cmd!='q')&&(cmd!='Q'));}(二)有序顺序表的合并[问题描述] 已知顺序表la和lb中的数据元素按非递减有序排列,将la和lb表中的数据元素,合并成为一个新的顺序表lc[基本要求] lc中的数据元素仍按非递减有序排列,并且不破坏la和lb表[程序实现]# include <stdio.h># define maxnum 20typedef int DataType ;typedef struct{ DataType data[maxnum] ;int length ;}SeqList ;int MergeQL(SeqList la , SeqList lb , SeqList *lc){ int i , j , k ;if (la.length+1 + lb.length+1>maxnum){ printf("\narray overflow!") ;return 0;}i=j=k=0;while(i<=la.length && j<=lb.length){ if (la.data[i]<=lb.data[j])lc->data[k++]=la.data[i++] ;elselc->data[k++]=lb.data[j++];}/* 处理剩余部分 */while (i<=la.length) lc->data[k++]=la.data[i++];while (j<=lb.length) lc->data[k++]=lb.data[j++];lc->length=k-1;return 1;}main(){ SeqList la={{3,4,7,12,15},4} ;SeqList lb={{2,5,7,15,18,19},5} ;SeqList lc ;int i ;if (MergeQL(la,lb,&lc)){ printf("\n") ;for(i=0;i<=lc.length ; i++)printf("%4d",lc.data[i]);}}六、注意事项1、删除元素或插入元素表的长度要变化。

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
2.上机输入、调试实验程序;
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法,1为插入,2为删除,3为查询!4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);

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

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

《算法与数据结构》课程实验报告一、实验目的1、实现线性表的顺序存储结构。

2、熟悉C++程序的基本结构,掌握程序中的头文件、实现文件和主文件之间的相互关系及各自的作用。

3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现。

二、实验内容及要求对顺序存储的线性表进行一些基本操作。

主要包括:(1)插入:操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入。

(2)删除:操作方式可分为删除指定元素、删除指定位置的元素等,尝试实现逻辑删除操作。

(3)显示数据。

(4)查找:查询指定的元素(可根据某个数据成员完成查询操作)。

(5)定位操作:定位指定元素的序号。

(6)更新:修改指定元素的数据。

(7)数据文件的读写操作等。

其它操作可根据具体需要自行补充。

要求线性表采用类的定义,数据对象的类型自行定义。

三、系统分析(1)数据方面:能够实现多种数据类型顺序表的创建,并进行操作,不同的数据类型数据使用不同的文本文件保存。

(2)功能方面:能够实现线性表的一些基本操作,主要包括:1.计算表最大可以容纳表项个数以及当前表的当前长度。

2.能够进行添加操作,在已有的数据文件中进行数据的添加。

3.能够进行搜索操作,返回搜索项在表中表项序号4.能够进行定位操作,定位到表中合理位置。

5.能够进行取值操作,根据用户需求取出表中某项的值。

6.能够进行修改操作,在用户选择修改项后将重新输入内容修改到对应位置。

7.能够进行插入操作,在用户选择合理位置并输入插入内容后即可。

8.能够进行删除操作,用户根据选择表中项数删除对应数据。

9.能够进行判断表空或表满。

四、系统设计(1)设计的主要思路根据实验要求,首先将顺序表模板类完成,并将需要实现的功能代码完善,在写实现各个功能的菜单并将模板类实例化为简单数据类型最后进行调试,由于还需使得顺序表能够存储自定义的学生类类型数据,故根据要求写出Student类,并将之前所写得模板类用学生类数据类型实例化,再进行调试。

数据结构实验顺序表的基本操作

数据结构实验顺序表的基本操作

数据结构实验-顺序表的基本操作顺序表是一种线性数据结构,它的元素在内存中是连续存储的。

顺序表具有随机访问的特点,可以通过下标直接访问元素,因此在访问元素时具有较高的效率。

顺序表的基本操作包括插入、删除、查找等,下面将对这些基本操作进行详细介绍。

1. 初始化:初始化顺序表需要为其分配一定的内存空间,以存储元素。

可以使用静态分配或动态分配两种方式来初始化顺序表。

静态分配是在编译时为顺序表分配固定大小的内存空间,而动态分配是在运行时根据需要动态地为顺序表分配内存空间。

2. 插入操作:插入操作是将一个元素插入到顺序表的指定位置上。

在插入元素之前,需要判断顺序表是否已满,如果已满则需要进行扩容操作。

插入元素时,需要将插入位置以及其后的元素向后移动一位,为插入元素腾出位置。

插入操作的时间复杂度为O(n),其中n为顺序表的长度。

3. 删除操作:删除操作是将顺序表中的一个元素删除。

在删除元素之前,需要判断顺序表是否为空,如果为空则无法进行删除操作。

删除元素时,需要将删除位置后面的元素向前移动一位,覆盖删除位置上的元素。

删除操作的时间复杂度为O(n),其中n为顺序表的长度。

4. 查找操作:查找操作是根据给定的关键字,在顺序表中查找满足条件的元素。

可以使用顺序查找或二分查找两种方式进行查找。

顺序查找是从顺序表的第一个元素开始,逐个比较关键字,直到找到满足条件的元素或遍历完整个顺序表。

二分查找是在有序顺序表中进行查找,每次将待查找区间缩小一半,直到找到满足条件的元素或待查找区间为空。

查找操作的时间复杂度为O(n),其中n为顺序表的长度。

5. 修改操作:修改操作是将顺序表中的一个元素修改为新的值。

修改操作需要先进行查找操作,找到待修改的元素,然后将其值修改为新的值。

修改操作的时间复杂度为O(n),其中n为顺序表的长度。

6. 遍历操作:遍历操作是依次访问顺序表中的每个元素。

可以使用for循环或while循环进行遍历,从第一个元素开始,依次访问每个元素,直到遍历完整个顺序表。

数据结构上机实验指导

数据结构上机实验指导

《数据结构》课程上机实验指导书实验一【实验名称】顺序表的基本算法【实验目的】创建一个顺序表,掌握线性表顺序存储的特点。

设计和验证顺序表的查找、插入、删除算法。

【实验要求】(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、实验前先写好算法。

数据结构实验报告(实验)

数据结构实验报告(实验)

深 圳 大 学 实 验 报 告课程名称: 数据结构实验与课程设计 实验项目名称: 实验一:顺序表的应用 学院: 计算机与软件学院 专业: 指导教师: **报告人: 文成 学号: ********** 班级: 5 实验时间: 2012-9-17实验报告提交时间: 2012-9-24教务部制一、实验目的与要求:目的:1.掌握线性表的基本原理2.掌握线性表地基本结构3.掌握线性表地创建、插入、删除、查找的实现方法要求:1.熟悉C++语言编程2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法二、实验内容:Problem A: 数据结构——实验1——顺序表例程Description实现顺序表的创建、插入、删除、查找Input第一行输入顺序表的实际长度n第二行输入n个数据第三行输入要插入的新数据和插入位置第四行输入要删除的位置第五行输入要查找的位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行插入操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行删除操作后,顺序表内的所有数据,数据之间用空格隔开第四行输出指定位置的数据Sample Input611 22 33 44 55 66888 352Sample Output11 22 33 44 55 6611 22 888 33 44 55 6611 22 888 33 55 6622HINT第i个位置是指从首个元素开始数起的第i个位置,对应数组内下标为i-1的位置Problem B: 数据结构——实验1——顺序表的数据交换Description实现顺序表内的元素交换操作Input第一行输入n表示顺序表包含的·n个数据第二行输入n个数据,数据是小于100的正整数第三行输入两个参数,表示要交换的两个位置第四行输入两个参数,表示要交换的两个位置Output第一行输出创建后,顺序表内的所有数据,数据之间用空格隔开第二行输出执行第一次交换操作后,顺序表内的所有数据,数据之间用空格隔开第三行输出执行第二次交换操作后,顺序表内的所有数据,数据之间用空格隔开注意加入交换位置的合法性检查,如果发现位置不合法,输出error。

数据结构实验报告-线性表

数据结构实验报告-线性表

1 线性表1. 实验题目与环境1.1实验题目及要求(1)顺序表的操作利用顺序存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。

(2)单链表的操作利用链式存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。

(3)线性表的应用约瑟夫环问题。

有n个人围坐一圈,现从某个人开始报数,数到M的人出列,接着从出列的下一个人开始重新报数,数到M的人又出列,如此下去,直到所有人都出列为止。

要求依次输出出列人的编码。

2.问题分析(1)顺序表的操作利用一位数组来描述顺序表,即将所有元素一词储存在数组的连续单元中,要在表头或中间插入一个新元素时,需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。

同理,删除开头或中间的元素时,则将其后的所有元素向前移动一个位置以填补空位。

查找元素时,则需要利用循环语句,一一判断直到找出所要查找的元素(或元素的位置),输出相关内容即可(2)单链表的操作利用若干个结点建立一个链表,每个节点有两个域,即存放元素的数据域和存放指向下一个结点的指针域。

设定一个头指针。

在带头结点的单链表中的第i个元素之前插入一新元素,需要计数找到第i-1个结点并由一指针p指向它,再造一个由一指针s指向的结点,数据为x,并使x的指针域指向第i个结点,最后修改第i-1个结点的指针域,指向x结点。

删除第i个元素时,需要计数寻找到第i个结点,并使指针p指向其前驱结点,然后删除第i个结点并释放被删除结点的空间。

查找第i个元素,需从第一个结点开始计数找到第i个结点,然后输出该结点的数据元素。

(3)线性表的应用程序运行之后,首先要求用户指定初始报数的上限值,可以n<=30,此题中循环链表可不设头结点,而且必须注意空表和"非空表"的界限。

数据结构c++顺序表、单链表的基本操作,查找、排序代码

数据结构c++顺序表、单链表的基本操作,查找、排序代码

} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:

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

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

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。

(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。

(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。

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

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

数据结构实验报告之链表顺序表的操作1、编写程序实现顺序表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能:(1)初始化顺序表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出顺序表L;(9)删除L的第2个元素,之后输出顺序表L;(10)销毁顺序表L。

2、编写程序实现单链表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能:(1)初始化单链表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出单链表L;(4)输出单链表L的长度;(5)判断单链表L是否为空;(6)输出单链表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出单链表L;(9)删除L的第2个元素,之后输出单链表L;(10)销毁单链表L。

1顺序表2 #include<stdio.h>3 #include<malloc.h>4 #include<stdlib.h>56#define TRUE 17#define FALSE 08#define OK 19#define ERROR 010#define INFEASIBLE -111#define OVERFLOW -212 typedef int Status;13 typedef char ElemType;1415#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量16#define LISTINCREMENT 10 //线性表存储空间的分配增量17 typedef struct {18 ElemType *elem; //存储空间基地址19int length; //当前长度20int listsize; //当前分配的存储容量21 } SqList;2223 Status InitList_Sq(SqList &L) { //算法2.324 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));25if (!L.elem) exit(OVERFLOW); //存储分配失败26 L.length = 0; //空表长度为027 L.listsize = LIST_INIT_SIZE; //初始存储容量28return OK;29 }//InitList_Sq3031 Status ListInsert_Sq(SqList &L, int i, ElemType e) { //算法2.432 ElemType *newbase, *p, *q;33if (i<1 || i>L.length + 1) return ERROR; //i值不合法34if (L.length >= L.listsize)35 { //当前存储空间已满,增加分配36 newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));37if (!newbase) exit(OVERFLOW); //存储分配失败38 L.elem = newbase; //新基址39 L.listsize += LISTINCREMENT; //增加存储容量40 }41 q = &(L.elem[i - 1]); //q为插⼊位置42for (p = &(L.elem[L.length - 1]); p >= q; --p) *(p + 1) = *p; //元素右移43 *q = e; //插⼊e44 ++L.length; //表长增145return OK;46 }4748void DispSqList(SqList L)49 {50int i;51for (i = 0; i < L.length; i++)52 printf("%c ", L.elem[i]);53 }5455 Status ListDelete(SqList &L, int i, ElemType &e)56 {57 ElemType *p,*q;58if ((i < 1) || (i > L.length)) return ERROR;59 p = &(L.elem[i - 1]);60 e = *p;61 q = L.elem + L.length - 1;62for (++p; p <= q; ++p)63 *(p - 1) = *p;64 --L.length;65return OK;66 } //ListDelete_Sq6768 Status GetElem(SqList L, int i, ElemType &e)69 {70if (L.length == 0 || i<1 || i>L.length)71return ERROR;72 e = L.elem[i - 1];73return OK;74 }7576int ListLength(SqList L)77 {78return(L.length);79 }8081 Status DestroyList(SqList &L)82 {83 free(L.elem);84 L.length = 0;85return OK;86 }8788 Status ListEmpty(SqList L)89 {90return(L.length == 0);91 }9293int LocateElem(SqList L, ElemType e)94 {95int i = 0;96while (i < L.length && L.elem[i] != e) i++;97if (i >= L.length) return0;98else return i + 1;99 }100101void main()102 {103 SqList h;104 ElemType e;105 InitList_Sq(h);106 ListInsert_Sq(h, h.length + 1, 'a');107 ListInsert_Sq(h, h.length + 1, 'b');108 ListInsert_Sq(h, h.length + 1, 'c');109 ListInsert_Sq(h, h.length + 1, 'd');110 ListInsert_Sq(h, h.length + 1, 'e');111 DispSqList(h);112 printf("%d\n\n",ListLength(h));113 ListEmpty(h);114if (ListEmpty(h))116 printf("Empty\n\n");117 }118else119 {120 printf("Not empty\n\n");121 }122 GetElem(h, 4, e);123 printf("%c\n", e);124 printf("%d\n",LocateElem(h, 'c'));125 ListInsert_Sq(h,3,' f');126 DispSqList(h);127 ListDelete(h, 2, e);128 DispSqList(h);129 DestroyList(h);130 }131132133134135136单链表137138139140 #include<stdio.h>141 #include<malloc.h>142 #include<stdlib.h>143144#define TRUE 1145#define FALSE 0146#define OK 1147#define ERROR 0148#define INFEASIBLE -1149#define OVERFLOW -2150 typedef int Status;151152 typedef char ElemType;153154155 typedef struct LNode {156 ElemType data;157int length;158struct LNode *next;159 }LNode, *LinkList;160161162 Status InitList_L(LinkList &L) {163 L = (LinkList)malloc(sizeof(LNode));164 L->next = NULL;165return OK;166 }167168 Status ListInsert_L(LinkList L, int i, ElemType e) { 169 LinkList p = L,s;170int j = 0;171while (p && j < i - 1)172 {173 p = p->next;174 ++j;175 }176if (!p || j > i - 1)177 {178return ERROR;179 }180else181 {182 s = (LinkList)malloc(sizeof(LNode));183 s->data = e;184 s->next = p->next;185 p->next = s;186return OK;187 }188 }189190void DispList_L(LinkList L)191 {192 LinkList p = L->next;193while (p != NULL)194 {195 printf("%c\n", p->data);196 p = p->next;197 }198200201void DestoryList(LinkList &L)202 {203 LinkList p = L, q = p->next;204while (q != NULL)205 {206 free(p);207 p = q;208 q = p->next;209 }210 free(p);211 }212213 Status ListLength_L(LinkList L) {214 LinkList p = L; int n = 0;215while (p->next != NULL)216 {217 n++;218 p = p->next;219 }220return (n);221 }222223 Status ListDelete(LinkList L, int i, ElemType &e){ 224int j;225 LinkList p, q;226 p = L;227 j = 1;228while (p->next && j < i)229 {230 p = p->next;231 ++j;232 }233if (!(p->next) || j > i)234 {235return ERROR;236 }237 q = p->next;238 p->next = q->next;239 e = q->data;240 free(q);241return OK;242 }243244 Status ListEmpty_L(LinkList L)245 {246return(L->length == 0);247 }248249 Status GetElem(LinkList L, int i, ElemType &e) 250 {251int j;252 LinkList p;253 p = L->next;254 j = 1;255while (p&&j<i)256 {257 p = p->next;258 ++j;259 }260if (!p || j > i)261 {262return ERROR;263 }264 e = p->data;265return OK;266 }267268 Status LocateElem(LinkList L, int e)269 {270 LinkList p = L;271int n=0;272//p->length = 0;273while (p != NULL)274 {275if(p->data != e)276 {277 p = p->next;278 n++;279 }280else281 {282break;283 }284 }285if(p != NULL)286 {287return n;288 }289else290 {291return ERROR;292 }293 }294295void main()296 {297 LinkList h;298 ElemType e;299 InitList_L(h);300 ListInsert_L(h, 1, 'a');301 ListInsert_L(h, 2, 'b');302 ListInsert_L(h, 3, 'c');303 ListInsert_L(h, 4, 'd');304 ListInsert_L(h, 5, 'e');305 DispList_L(h);306 printf("%d\n", ListLength_L(h)); 307if (ListEmpty_L(h))308 {309 printf("Empty\n\n");310 }311else312 {313 printf("Not empty\n\n");314 }315 GetElem(h, 4, e);316 printf("%c\n", e);317 printf("%d\n", LocateElem(h, 'c')); 318 ListInsert_L(h, 3, 'f');319 DispList_L(h);320 ListDelete(h, 2, e);321 DispList_L(h);322 DestoryList(h);323 }。

顺序表的建立、输入、输出、查找、插入、删除(数据结构)

顺序表的建立、输入、输出、查找、插入、删除(数据结构)

顺序表的建⽴、输⼊、输出、查找、插⼊、删除(数据结构)1.顺序表的基本操作实践。

(1)建⽴4个元素的顺序表list[]={2,3,4,5},实现顺序表建⽴的基本操作。

(2)在list[]={2,3,4,5}的元素4和5之间插⼊⼀个元素9,实现顺序表插⼊的基本操作。

(3)在list[]={2,3,4,9,5}中删除指定位置(i=3)上的元素4,实现顺序表的删除的基本操作。

#include <stdio.h>#include <stdlib.h>#include <iostream>#define MAXSIZE 10using namespace std;typedef int ElemType;typedef struct {ElemType a[MAXSIZE];int length;} S;void CreatList(S &L) {scanf("%d", &L.length);for(int i = 1; i <= L.length; i ++) scanf("%d",&L.a[i]);} //创建列表void PutList(S L) {for(int i = 1; i <= L.length; i ++) {printf("%d ",L.a[i]);}printf("\n");} //输出列表void InserElem(S &L, int i, ElemType x) { j iif(i < 1 || i > L.length) return; 2 3 4 5 9for(int j = L.length+1; j > i; j --) { j-1jL.a[j] = L.a[j-1]; 2 3 4 9 5}L.a[i] = x;L.length++;} //插⼊void DeleElem(S &L, int i) {for(int j = i; j < L.length; j ++) {L.a[j] = L.a[j+1]; j j+1} 2 3 4 9 5L.length--;}//删除int main() {S L;CreatList(L);InserElem(L,4,9);PutList(L);DeleElem(L,3);PutList(L);return0;}结果E:\c++>b42345234952395。

顺序表的定义及基本操作

顺序表的定义及基本操作
}
printf("数据插入成功!\n");
}
else if(temp == 3)
DispList(h);
else if(temp == 4)
printf("该单链表的长度= %d\n",ListLength(h));
else if(temp == 5)
{
int N;
scanf("%d", &N);
if(N<1||N>ListLength(h))
}
printf("\n");
}
int GetElem(LinkList *L,int i,ElemType &e) //获取链表中的任意位置的元素。但是不能越界
{
int j=1;
LinkList *p=L->next;
while (j<i && p!=NULL)
{
j++;
p=p->next;
}
if (p==NULL)
}
if (p==NULL)//未找到第i-1个结点
{
printf("未找到第%d个节点!\n", (i-1));
return 0;
}
else//找到第i-1个结点*p
{
s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
s->data=e;
s->next=p->next;//将*s插入到*p之后
while(temp != 0)
{
printf("********************************************************************************");

数据结构顺序表课程设计

数据结构顺序表课程设计

数据结构顺序表课程设计一、课程目标知识目标:1. 学生能理解顺序表的基本概念,掌握其存储结构和操作方法。

2. 学生能描述顺序表的特点,并与链表等其他数据结构进行对比分析。

3. 学生能掌握顺序表的相关算法,如插入、删除、查找等,并了解其时间复杂度。

技能目标:1. 学生能够运用顺序表解决实际问题,如实现学生信息管理系统等。

2. 学生能够独立编写顺序表的插入、删除、查找等操作的程序代码。

3. 学生能够分析顺序表操作的算法性能,并对其进行优化。

情感态度价值观目标:1. 学生培养对数据结构学习的兴趣,认识到数据结构在实际问题中的重要作用。

2. 学生在学习过程中,培养解决问题的耐心和毅力,提高团队合作能力。

3. 学生能够树立正确的编程观念,注重代码规范和程序优化。

课程性质:本课程为高二年级信息技术课程,属于数据结构章节的内容,旨在让学生掌握顺序表这一基本数据结构。

学生特点:高二年级学生已经具备了一定的编程基础,对数据结构有一定的了解,但可能对顺序表这种线性表结构掌握不深。

教学要求:结合学生特点,注重理论与实践相结合,通过实例分析和实际操作,使学生能够熟练掌握顺序表的操作方法,并培养其编程思维和解决问题的能力。

在教学过程中,关注学生的情感态度,激发学习兴趣,提高学习积极性。

二、教学内容1. 顺序表的基本概念与存储结构- 引入顺序表的定义,比较顺序表与数组、链表的区别。

- 讲解顺序表的内存存储结构,分析其优缺点。

2. 顺序表的操作方法- 介绍顺序表的插入、删除、查找等基本操作。

- 讲解顺序表长度变化时的动态扩容和缩容方法。

3. 顺序表算法分析- 分析顺序表操作的时间复杂度,如插入、删除、查找等操作的时间复杂度。

- 探讨优化顺序表操作算法的方法,如二分查找等。

4. 实践应用与案例分析- 结合实际问题,如学生信息管理系统,讲解如何使用顺序表进行数据管理。

- 分析实际案例,巩固顺序表的操作方法和算法优化。

5. 教学内容安排与进度- 教学内容按照上述四个方面进行安排,共计8个课时。

数据结构实验报告顺序表

数据结构实验报告顺序表

数据结构实验报告顺序表数据结构实验报告:顺序表摘要:顺序表是一种基本的数据结构,它通过一组连续的存储单元来存储线性表中的数据元素。

在本次实验中,我们将通过实验来探索顺序表的基本操作和特性,包括插入、删除、查找等操作,以及顺序表的优缺点和应用场景。

一、实验目的1. 理解顺序表的概念和特点;2. 掌握顺序表的基本操作;3. 了解顺序表的优缺点及应用场景。

二、实验内容1. 实现顺序表的初始化操作;2. 实现顺序表的插入操作;3. 实现顺序表的删除操作;4. 实现顺序表的查找操作;5. 对比顺序表和链表的优缺点;6. 分析顺序表的应用场景。

三、实验步骤与结果1. 顺序表的初始化操作在实验中,我们首先定义了顺序表的结构体,并实现了初始化操作,即分配一定大小的存储空间,并将表的长度设为0,表示表中暂时没有元素。

2. 顺序表的插入操作接下来,我们实现了顺序表的插入操作。

通过将插入位置后的元素依次向后移动一位,然后将新元素插入到指定位置,来实现插入操作。

我们测试了在表中插入新元素的情况,并验证了插入操作的正确性。

3. 顺序表的删除操作然后,我们实现了顺序表的删除操作。

通过将删除位置后的元素依次向前移动一位,来实现删除操作。

我们测试了在表中删除元素的情况,并验证了删除操作的正确性。

4. 顺序表的查找操作最后,我们实现了顺序表的查找操作。

通过遍历表中的元素,来查找指定元素的位置。

我们测试了在表中查找元素的情况,并验证了查找操作的正确性。

四、实验总结通过本次实验,我们对顺序表的基本操作有了更深入的了解。

顺序表的插入、删除、查找等操作都是基于数组的操作,因此在插入和删除元素时,需要移动大量的元素,效率较低。

但是顺序表的优点是可以随机访问,查找效率较高。

在实际应用中,顺序表适合于元素数量不变或变化不大的情况,且需要频繁查找元素的场景。

综上所述,顺序表是一种基本的数据结构,我们通过本次实验对其有了更深入的了解,掌握了顺序表的基本操作,并了解了其优缺点及应用场景。

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

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

四、实验步骤
一 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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
cout&lt;&lt;&quot;删除操作完成后的顺序表是:&quot;&lt;&lt;endl;
put(list);
}
}
void delete2(sqlist &amp;list)//删除指定数字的函数
{
int b;
cout&lt;&lt;&quot;输入您想删除的数字:&quot;&lt;&lt;endl;
cout&lt;&lt;&quot;请输入要进行的操作序号:\n&quot;;
cout&lt;&lt;&quot;1.插入字符&quot;&lt;&lt;endl&lt;&lt;&quot;2.查找数字&quot;&lt;&lt;endl&lt;&lt;&quot;3.删除第i位数字&quot;&lt;&lt;endl&lt;&lt;&quot;4.删除指定数字&quot;&lt;&lt;endl&lt;&lt;&quot;0.退出&quot;&lt;&lt;endl&lt;&lt;endl;
cin&gt;&gt;b;
int i,j=0;
for(i=0;i&lt;list.length;i++)
{
if(list.data[i]==b)
{j=i+1;break;}
}
if(j!=0)
{
for(;i&lt;list.length-2 ;i++)
list.data[i]=list.data[i+1];
int j;
if(i&lt;0||i&gt;list.length)
{
cout&lt;&lt;&quot;位置错误&quot;&lt;&lt;endl;
put(list);
}
else
{ for(j=list.length;j&gt;=i;j--)
list.data[j]=list.data[j-1];
}
void insert(sqlist &amp;list)//插入函数
{
int i;
cout&lt;&lt;&quot;您想在第几位插入数字:\n&quot;;
cin&gt;&gt;i;
int x;
cout&lt;&lt;&quot;请输入要插入的数字:\n&quot;;
cin&gt;&gt;x;
--list.length;
cout&lt;&lt;&quot;该位置是第&quot;&lt;&lt;i&lt;&lt;&quot;位&quot;&lt;&lt;endl;
cout&lt;&lt;&quot;删除操作完成后的顺序表是:&quot;&lt;&lt;endl;
put(list);
cout&lt;&lt;endl;
}
void locateElem(sqlist &amp;list)
{
int i,j=0,b;
cout&lt;&lt;&quot;请输如要查找的字符:\n&quot;;
cin&gt;&gt;b;
for(i=0;i&lt;list.length;i++)
creatsqlist(l);
initsqlist(l);
cout&lt;&lt;endl&lt;&lt;&quot;**************************************************************************&quot;&lt;&lt;endl;
cout&lt;&lt;&quot;请输入要进行的操作序号:\n&quot;;
cout&lt;&lt;&quot;1.插入字符&quot;&lt;&lt;endl&lt;&lt;&quot;2.查找数字&quot;&lt;&lt;endl&lt;&lt;&quot;3.删除第i位数字&quot;&lt;&lt;endl&lt;&lt;&quot;4.删除指定数字&quot;&lt;&lt;endl&lt;&lt;&quot;0.退出&quot;&lt;&lt;endl&lt;&lt;endl;
}
else
cout&lt;&lt;&quot;很遗憾,表中没有找到此数字,删除不成功,请重试!&quot;&lt;&lt;endl;
}
int main()
{
in
t flag;
sqlist l;
cout&lt;&lt;&quot;请重新输入||代码错误&quot;&lt;&lt;endl;}
cout&lt;&lt;&quot;**************************************************************************&quot;&lt;&lt;endl;
{
int* data;//int*型元素
int length;//顺序表的实际长度
int listsize;//顺序表的最大长度
}sqlist;
void creatsqlist(sqlist &amp;list)
{
list.data=(int*)malloc(sizeof(int)*maxsize);//开辟一个名为l的顺序表
{b=list.data[i-1];
for(i=i-1;i&lt;list.length-1;i++)
list.data[i]=list.data[i+1];
--list.length;
cout&lt;&lt;&quot;需要删除的元素是:&quot;&lt;&lt;b&lt;&lt;endl;
if(list.data[i]==b)
{j=i+1;break;}
if(j)
cout&lt;&lt;&quot;该数字的位置是:&quot;&lt;&lt;j&lt;&lt;endl;
else
cout&lt;&lt;&quot;很抱歉,表中没有这个数字,请重试!&quot;&lt;&lt;endl;
cin&gt;&gt;n;
cout&lt;&lt;&quot;您申请的顺序表的长度是---&quot;&lt;&lt;n&lt;&lt;endl;
p=list.data;//p指向头指针
cout&lt;&lt;&quot;请依次输入无重复数字的有序顺序表(相邻数据用空格隔开,回车键完成输入):&quot;&lt;&lt;endl;
for(int i=0;i&lt;n;i++)//逐个赋值
{
cin&gt;&gt;*p;
p++;
list.length++;
}
cout&lt;&lt;&quot;您输入的递增顺序表为:&quot;&lt;&lt;endl;//打印出初始化的顺序表
for(i=0;i&lt;n;i++)
cin&gt;&gt;flag;
do
{
switch(flag)
{case 1:
insert(l);break;
case 2:
locateElem(l);break;
case 3:
delete1(l);break;
case 4:
delete2(l);break;
default:
cin&gt;&gt;flag;
}
while(flag!=0);
return 0;
}
list.data[j]=x;
list.length++;
}
cout&lt;&lt;&quot;插入操作完成后的顺序表:&quot;&lt;&lt;endl;
相关文档
最新文档