顺序表插入元素

顺序表的基本操作实验报告一、实验目的本次实验旨在深入理解和掌握顺序表的基本操作，包括顺序表的创建、插入、删除、查找和遍历等功能，并通过实际编程实现，加深对数据结构中顺序存储结构的理解和应用能力。

二、实验环境本次实验使用的编程语言为 C 语言，编程环境为 Visual Studio 2019。

三、实验原理顺序表是一种线性表的顺序存储结构，它使用一组连续的存储单元依次存储线性表中的元素。

在顺序表中，元素的逻辑顺序与物理顺序是一致的。

顺序表的基本操作包括：1、创建顺序表：为顺序表分配存储空间，并初始化相关参数。

2、插入操作：在指定位置插入元素，需要移动后续元素以腾出空间。

3、删除操作：删除指定位置的元素，并将后续元素向前移动。

4、查找操作：在顺序表中查找指定元素，返回其位置或表示未找到。

5、遍历操作：依次访问顺序表中的每个元素。

四、实验步骤1、定义顺序表的数据结构｀｀｀cdefine MAXSIZE 100 ／／定义顺序表的最大长度typedef struct ｛int dataMAXSIZE; ／／存储顺序表元素的数组int length; ／／顺序表的当前长度｝ SeqList;｀｀｀2、顺序表的创建｀｀｀cvoid InitList(SeqList L) ｛L>length ＝ 0; ／／初始化顺序表长度为 0｝｀｀｀3、顺序表的插入操作｀｀｀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+＋；／／顺序表长度增加 1return 1;｝｀｀｀4、顺序表的删除操作｀｀｀cint DeleteList(SeqList L, int i) ｛if （i ＜ 1 ｜｜ i ＞ L>length) ｛／／删除位置不合法return 0;｝for （int j ＝ i; j ＜ L>length; j+＋）｛／／移动元素填补删除位置L>dataj 1 ＝ L>dataj;｝L>length; ／／顺序表长度减少 1return 1;｝｀｀｀5、顺序表的查找操作｀｀｀cint SearchList(SeqList L, int e) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ e) ｛／／找到元素return i ＋ 1;｝｝return 0; ／／未找到元素｝｀｀｀6、顺序表的遍历操作｀｀｀cvoid TraverseList(SeqList L) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；／／输出顺序表中的元素｝printf(＂＼n"）；｝｀｀｀五、实验结果与分析1、测试创建顺序表｀｀｀cSeqList L;InitList(＆L)；｀｀｀创建成功，顺序表初始长度为 0。

一、实验目的和要求通过对顺序表的编程练习，加强对顺序表的特点、顺序存储结构及其基本运算的理解和掌握。

提前了解实验相关的c语言的知识。

使用C语言根据相应算法编写一个程序，实现建立线性顺序表、插入和删除等基本操作。

要求仔细阅读下面的内容，编写一个C程序，上机调试通过，并观察其结果，写出实验报告书。

二、实验内容和原理内容：建立一个容量10的顺序表，在其中插入3个元素，然后作删除运算。

原理：在第i个元素前插入元素，从第i个元素开始到最后一个元素均向后移动一个位置，然后将新元素插入到第i个位置，将线性表的长度加1。

删除第i个元素，从第i+1个元素开始到最后一个元素均向前移动一个位置，然后将线性表的长度减1。

三、主要仪器设备计算机一台四、实验主程序#include<stdio.h>#include<stdlib.h>struct List{int size;int n;int *head;};void init(struct List *pl,int size){pl->size=size;pl->n=0;pl->head=malloc(size*sizeof(int)); }void in(int i,int val,struct List *pl){int k;if(pl->n==pl->size){printf("list is full.\n");return;}if(i>pl->n)i=pl->n+1;if(i<1)i=1;for(k=pl->n-1;k>=i-1;--k)pl->head[k+1]=pl->head[k];pl->head[i-1]=val;++pl->n;}void out(int i,struct List *pl){int k;if(pl->n==0){printf("list is empty.\n");return;}if(i<1||i>pl->n){printf("this element is not in the list.\n");return;}for(k=i;k<=pl->n;++k)pl->head[k-1]=pl->head[k];--pl->n;return;}void print(const struct List *pl) {int i;for(i=0;i!=pl->n;++i)printf("%d ",pl->head[i]);printf("\n");}int main(void){int i;struct List list;init(&list,10);for(i=0;i!=5;++i)in(i+1,i,&list);print(&list);in(1,5,&list);print(&list);in(10,4,&list);print(&list);in(5,50,&list);print(&list);out(1,&list);print(&list);out(list.n,&list);print(&list);out(3,&list);print(&list);getchar();return 0;}实验结果五、实验心得通过实验学习，我理解了线性顺序表的插入与删除的算法，了解到线性顺序表的插入与删除得效率低下，感到受益匪浅。

Java顺序表的基本操作代码一、什么是顺序表顺序表（Sequential List）是一种常见的线性数据结构，它由一组按照顺序存储的元素组成，其中每个元素都有唯一的索引值。

顺序表中的元素在物理存储上是连续的。

在Java中，顺序表可以通过数组进行实现，也可以通过ArrayList类来实现。

本文将分别介绍这两种实现方式。

二、数组实现顺序表1. 创建顺序表int[] array = new int[capacity];int size = 0;上述代码创建了一个容量为capacity的整型数组array，同时将顺序表的大小初始化为0。

2. 插入元素在顺序表的末尾插入元素：public void addLast(int element) {if (size == array.length) {// 扩容操作int[] newArray = new int[array.length * 2];System.arraycopy(array, 0, newArray, 0, array.length);array = newArray;}array[size] = element;size++;}在指定位置插入元素：public void add(int index, int element) {if (index < 0 || index > size) {throw new IndexOutOfBoundsException();}if (size == array.length) {// 扩容操作int[] newArray = new int[array.length * 2];System.arraycopy(array, 0, newArray, 0, index);System.arraycopy(array, index, newArray, index + 1, size - index); array = newArray;} else {System.arraycopy(array, index, array, index + 1, size - index);}array[index] = element;size++;}3. 删除元素删除末尾元素：public void removeLast() {if (size == 0) {throw new NoSuchElementException();}size--;}删除指定位置的元素：public void remove(int index) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}System.arraycopy(array, index + 1, array, index, size - index - 1);size--;}4. 获取元素获取指定位置的元素：public int get(int index) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}return array[index];}修改指定位置的元素：public void set(int index, int element) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}array[index] = element;}5. 查询元素查找指定元素的索引：public int indexOf(int element) {for (int i = 0; i < size; i++) {if (array[i] == element) {return i;}}return -1;}判断顺序表是否为空：public boolean isEmpty() {return size == 0;}三、ArrayList实现顺序表ArrayList是Java提供的一个动态数组类，它实现了List接口，可以方便地进行顺序表的操作。

顺序表实验报告顺序表是一种线性数据结构，它以连续的存储空间来存储数据元素，通过元素在数组中的相对位置来表示数据元素之间的逻辑关系。

在这个实验中，我们使用顺序表的实现来进行实验。

首先我们先了解一下顺序表的结构。

顺序表由两部分组成：表头和表体。

表头包含顺序表的一些基本信息，如顺序表的长度和当前表体的容量；表体是一个一维数组，用来存储数据元素。

在这个实验中，我们主要实现顺序表的插入操作和删除操作。

插入操作是指将一个新的数据元素插入到顺序表的某个位置；删除操作是指在顺序表中删除某个位置的数据元素。

实验步骤如下：1. 首先，我们需要定义一个顺序表的数据结构，包含表头和表体。

表头中需要有顺序表的长度和当前表体的容量，表体是一个一维数组。

2. 接下来，我们实现插入操作。

插入操作需要输入要插入的数据元素和插入的位置。

我们首先需要判断插入的位置是否合法，即位置在顺序表的范围内。

如果位置不合法，就返回插入失败。

如果位置合法，我们需要判断当前表体的容量是否已满。

如果已满，我们需要重新分配更大的内存空间来存储数据。

然后我们将插入位置后面的数据元素依次往后移动一位，给新的数据元素腾出位置。

最后，我们将要插入的数据元素放入指定位置处，并更新顺序表的长度。

3. 然后，我们实现删除操作。

删除操作需要输入要删除的位置。

首先我们需要判断删除的位置是否合法。

如果位置不合法，就返回删除失败。

如果位置合法，我们需要将删除位置后面的数据元素依次往前移动一位。

最后，我们更新顺序表的长度即可。

4. 最后，我们编写测试用例来检验我们实现的代码是否正确。

我们可以对插入和删除进行多次操作，然后查看顺序表的状态是否符合预期。

通过这个实验，我们可以更加深入地理解顺序表的原理和实现细节。

顺序表的插入和删除操作是非常常见的操作，掌握了这些操作，我们就能更加灵活地应用顺序表来解决实际问题。

同时，这个实验也锻炼了我们的编程能力和调试能力，提高了我们的代码质量和效率。

java顺序表的基本操作代码Java顺序表是一种基于数组实现的线性结构，具有随机访问、元素插入和删除等基本操作。

在Java中，我们可以通过定义一个数组来创建一个顺序表，并通过编写一些基本操作代码来实现对该顺序表的操作。

一、顺序表的定义和初始化在Java中，我们可以通过定义一个数组来创建一个顺序表。

下面是一个简单的代码示例：```public class SeqList<T> {private Object[] elementData; // 存储元素的数组private int size; // 当前元素个数// 构造函数public SeqList(int capacity) {elementData = new Object[capacity];size = 0;}}```在上述代码中，我们定义了一个SeqList类，其中包含了存储元素的数组elementData和当前元素个数size两个成员变量。

构造函数SeqList(int capacity)用于创建指定长度为capacity的数组，并将当前元素个数初始化为0。

二、顺序表的插入操作1. 在指定位置插入元素在Java中，我们可以通过下标来访问数组中的元素。

因此，在进行插入操作时，需要先将要插入位置之后的所有元素向后移动一位，然后再将新元素插入到指定位置上。

下面是一个简单的代码示例：```// 在指定位置插入元素public void insert(int index, T element) {if (index < 0 || index > size) {throw new IndexOutOfBoundsException("插入位置越界"); }// 判断数组是否已满，若已满则扩容if (size == elementData.length) {ensureCapacity(size * 2);}// 将要插入位置之后的所有元素向后移动一位for (int i = size - 1; i >= index; i--) {elementData[i + 1] = elementData[i];}// 插入新元素elementData[index] = element;size++;}// 扩容方法private void ensureCapacity(int minCapacity) {if (minCapacity > elementData.length) {Object[] newArray = new Object[minCapacity];System.arraycopy(elementData, 0, newArray, 0, size);elementData = newArray;}}```在上述代码中，我们首先判断要插入的位置是否越界。

元素之后的所有数据都前移一个位置，最将线性表长减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. 移动元素。

从插入位置开始，将插入位置之后的所有元素向后移动一位，为待插入元素腾出位置。

4. 插入元素。

将待插入的元素放入已腾出的位置中。

5. 更新顺序表的长度。

插入元素后，更新顺序表的长度。

6. 返回操作结果。

返回插入操作是否成功的结果。

注意：在步骤2和3中，可以根据具体情况选择从头部或尾部开始查找和移动元素。

同时，在步骤3中，需要注意插入位置是否超过了顺序表的容量，以防止数组越界错误。

实验报告一------顺序表的插入和删除1.实验目的1、输入一批整型数据，建立顺序表；2、实现顺序表的插入（输入插入位置i,插入元素）3、实现顺序表的删除（输入删除元素位置i）4、实现顺序表中数据的显示；5、实现顺序表中数据的查找和定位；6、编写主函数，调试上述算法。

2.实验源代码#include<stdio.h>#define max 100void sequenlist(int s[],int n) //建立一个顺序表{for(int i=0;i<n;i++){printf("顺序表第%d个元素是：\n",i+1);scanf("%d",&s[i]);}printf("所以该顺序表输出为：\n");for(int j=0;j<n;j++){printf("%d\t",s[j]);}putchar('\n');}void insert(int s[],int &n,int i,int x) //顺序表的插入{if(n==max||i<1||i>n+1)printf("插入失败!!!\n");elsefor(int k=n-1;k>=i-1;k--){s[k+1]=s[k];}s[i-1]=x;n++;}void dele(int s[],int &n,int i) //删除元素位置i {if(i<1||i>n+1)printf("无法删除!!!\n");elsefor(int j=i-1;j<n;j++){s[j]=s[j+1];}n--;}void disp(int s[],int n) //输出顺序表数据{printf("该顺序表输出为：\n");for(int j=0;j<n;j++){printf("%d\t",s[j]);}putchar('\n');}void locate(int s[],int &n,int x) //查找和定位{int k;for(int j=0;j<n;j++){if(s[j]==x)k=j+1;}printf("您要查找的数据位于第%d位!\n",k);}int main(){int s[max];int n;int i,x;int num;printf("请输入顺序表的数据元素个数：\n");scanf("%d",&n);sequenlist(s,n); //顺序表的建立printf("******************************************************\n" );printf("*************1.插入***********************************\n");printf("*************2.删除***********************************\n");printf("*************3.输出***********************************\n");printf("*************4.查找***********************************\n");printf("******************************************************\n" );while(1){printf("请选择：\n");scanf("%d",&num);switch(num){case 1:printf("请选择要插入的位置：\n");scanf("%d",&i);printf("请选择要插入的数据：\n");scanf("%d",&x);insert(s,n,i,x);break;case 2:printf("请选择您要删除的元素位置：\n");scanf("%d",&i);dele(s,n,i);break;case 3:disp(s,n);break;case 4:printf("请选择您要查询的元素：\n");scanf("%d",&x);locate(s,n,x);break;default:goto l;break;}}l:return 0;}3．实验结果见下图！。

c语言顺序表实验报告C语言顺序表实验报告引言：C语言是一种广泛应用于软件开发领域的编程语言，其灵活性和高效性备受开发者青睐。

在本次实验中，我们将探索C语言中的一种数据结构——顺序表。

顺序表是一种线性表的存储结构，通过数组实现，具有快速访问元素的特点。

本实验将通过实际操作，深入了解顺序表的创建、插入、删除和查找等基本操作，并对其性能进行评估。

实验目的：1. 掌握顺序表的创建和初始化方法；2. 熟悉顺序表的插入、删除和查找等基本操作；3. 评估顺序表在不同操作下的性能。

实验步骤：1. 创建顺序表在C语言中，可以通过定义一个结构体来表示顺序表，其中包含一个数组和一个记录当前元素个数的变量。

通过动态内存分配，可以根据需要调整顺序表的大小。

```ctypedef struct {int* data; // 数组指针int length; // 当前元素个数int capacity; // 顺序表的容量} SeqList;```在主函数中，可以通过调用malloc函数为顺序表分配内存空间，并对其进行初始化。

```cSeqList* createSeqList(int capacity) {SeqList* list = (SeqList*)malloc(sizeof(SeqList));list->data = (int*)malloc(capacity * sizeof(int));list->length = 0;list->capacity = capacity;return list;}```2. 插入元素顺序表的插入操作需要考虑插入位置的合法性以及顺序表是否已满的情况。

在插入元素时，需要将插入位置之后的元素后移一位，为新元素腾出空间。

```cvoid insert(SeqList* list, int position, int element) {if (position < 0 || position > list->length) {printf("插入位置非法！");return;}if (list->length >= list->capacity) {printf("顺序表已满，无法插入！");return;}for (int i = list->length - 1; i >= position; i--) {list->data[i + 1] = list->data[i];}list->data[position] = element;list->length++;}```3. 删除元素顺序表的删除操作需要考虑删除位置的合法性以及顺序表是否为空的情况。