线性顺序表的插入与删除(实验报告)

合集下载

线性表实验报告

线性表实验报告

安徽师范大学数学计算机科学学院实验报告专业名称物联网工程实验室 6号楼2060404实验课程数据结构实验名称顺序表姓名庞现然学号 14111206029 同组人员无实验日期 2015.4.91、实验目的1. 熟练掌握顺序表的类型定义和基本操作算法(以建立、插入、删除、遍历、排序和归并等操作为重点)的实现。

2. 通过实验加深对C语言的使用(特别是函数、数组、结构体和指针)。

3. 掌握模块化程序设计方法。

2、实验原理运用各函数的调用,来实现线性表的基本操作。

3、需求分析输:(1)程序目的:实验线性表的基本操作。

(2)输入的形式:线性表(3)输入值的范围:处理范围内(4)输出的形式:线性表(5)程序能达到的功能:实现线性表的基本操作(6)测试数据:13,5,27,9,32,123,76,98,54,874、概要设计typedef int Status;typedef int ElemType;5、详细设计各函数及其定义:开始1.构造初始化线性表!InitList(&L)2.输入10个元素给线性表L(整数):1.输出顺序表DispList(&L); 6.输出元素的位置2.输出顺序表的长度 7.插入数据ListInsert(&L,4,56)3.输入所要查询的元素为序n 8.输出此时的线性表DispList(&L)4.输出第n个数据的值 9.输出顺序表的表长5.输入一个要查询的元素的值 10.删除数据元素ListDelete(&L,n,&e) 11.销毁线性表结束1.Status InitList(Sqlist *L)//初始化线性表!{L->elem = (ElemType *)malloc(LIST_Init_Size*sizeof(ElemType));if(! L->elem) exit (OVERFLOW) ; //储存分配失败L->length = 0; //空表长度为0L->listsize = LIST_Init_Size; //初始储存量return OK;}//InitLIst_Sq2.void DestroyList(Sqlist *L)//销毁线性表!{free(L);}//DestroyList_Sq3.Status ListEmpty(Sqlist L)//判定是否为空表!{if(L.length == 0)return ERROR;//如L为空表,则返回0,否则返回1.return OK;}//ListEmpty_Sq4.Status ListLength(Sqlist *L)//求线性表的长度!{return(L->length);}//ListLength_Sq5.void DispList(Sqlist *L)//输出线性表!{int i;/*if ( ListEmpty(L) == 0 ) return;//判断是否为空? */ for ( i = 0; i<L->length;i++){printf("%d ",L->elem[i]);} printf("\n");}//DIspList_Sq6.int GetElem(Sqlist *L,int i,ElemType *e)//求某个数据元素的值!{if (i<1 || i>L->length) return 0;e = &L->elem[i-1];//该运算返回L中第 i(1≤i≤ListLength(L))个元素的值,存放在e中return OK;}//GetElem_Sq7.int LocateElem(Sqlist *L,ElemType e)//按元素查找!{int i = 0;while (i < L->length && L->elem[i] != e)i++;if (i >= L->length)return 0; //若这样的元素不存在,则返回值为0。

数据结构C语言版 实验报告

数据结构C语言版 实验报告

数据结构C语言版实验报告一、实验目的本次实验旨在通过使用 C 语言实现常见的数据结构,加深对数据结构基本概念、原理和操作的理解,提高编程能力和解决实际问题的能力。

二、实验环境操作系统:Windows 10编程环境:Visual Studio 2019编程语言:C 语言三、实验内容1、线性表顺序表的实现与操作链表的实现与操作2、栈和队列栈的实现与应用(表达式求值)队列的实现与应用(模拟排队)3、树和二叉树二叉树的遍历(前序、中序、后序)二叉搜索树的实现与操作4、图图的存储结构(邻接矩阵、邻接表)图的遍历(深度优先搜索、广度优先搜索)四、实验步骤及结果1、线性表顺序表的实现与操作定义顺序表的数据结构,包括数组和表的长度。

实现顺序表的初始化、插入、删除、查找等操作。

测试顺序表的各种操作,输出操作结果。

```cinclude <stdioh>include <stdlibh>define MAX_SIZE 100typedef struct {int dataMAX_SIZE;int length;} SeqList;//初始化顺序表void initList(SeqList L) {L>length = 0;}//插入元素到顺序表int insertList(SeqList L, int pos, int element) {if (L>length >= MAX_SIZE || pos < 0 || pos > L>length) {return 0;}for (int i = L>length 1; i >= pos; i) {L>datai + 1 = L>datai;}L>datapos = element;L>length++;return 1;}//删除顺序表中的元素int deleteList(SeqList L, int pos) {if (pos < 0 || pos >= L>length) {return 0;}for (int i = pos; i < L>length 1; i++){L>datai = L>datai + 1;}L>length;return 1;}//查找顺序表中的元素int searchList(SeqList L, int element) {for (int i = 0; i < Llength; i++){if (Ldatai == element) {return i;}}return -1;}int main(){SeqList L;initList(&L);insertList(&L, 0, 10);insertList(&L, 1, 20);insertList(&L, 2, 30);printf("顺序表元素: ");for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");int pos = searchList(L, 20);if (pos!=-1) {printf("元素 20 在顺序表中的位置: %d\n", pos);} else {printf("顺序表中未找到元素 20\n");}deleteList(&L, 1);printf("删除元素后的顺序表元素: ");for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");return 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;}实验结果五、实验心得通过实验学习,我理解了线性顺序表的插入与删除的算法,了解到线性顺序表的插入与删除得效率低下,感到受益匪浅。

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

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

元素之后的所有数据都前移一个位置,最将线性表长减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、学会使用图的数据结构,并实现图的遍历和相关算法。

二、实验环境本次实验使用的编程环境为具体编程环境名称,编程语言为具体编程语言名称。

三、实验内容及步骤(一)线性表的实现与操作1、顺序表的实现定义顺序表的数据结构,包括数组和表的长度等。

实现顺序表的初始化、插入、删除和查找操作。

2、链表的实现定义链表的节点结构,包含数据域和指针域。

实现链表的创建、插入、删除和查找操作。

(二)栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。

实现栈的入栈、出栈和栈顶元素获取操作。

2、队列的实现采用循环队列的方式实现队列的数据结构。

完成队列的入队、出队和队头队尾元素获取操作。

(三)树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。

2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。

3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。

(四)图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。

2、图的遍历实现深度优先遍历和广度优先遍历算法。

四、实验结果与分析(一)线性表1、顺序表插入操作在表尾进行时效率较高,在表头或中间位置插入时需要移动大量元素,时间复杂度较高。

删除操作同理,在表尾删除效率高,在表头或中间删除需要移动元素。

2、链表插入和删除操作只需修改指针,时间复杂度较低,但查找操作需要遍历链表,效率相对较低。

(二)栈和队列1、栈栈的特点是先进后出,适用于函数调用、表达式求值等场景。

入栈和出栈操作的时间复杂度均为 O(1)。

2、队列队列的特点是先进先出,常用于排队、任务调度等场景。

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

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

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

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

二、实验内容。

1. 初始化顺序表,包括建立空的顺序表和建立有元素的顺序表。

2. 插入元素,在指定位置插入元素。

3. 删除元素,删除指定位置的元素。

4. 查找元素,根据元素值查找元素所在位置。

5. 输出顺序表,将顺序表中的元素依次输出。

三、实验步骤。

1. 初始化顺序表。

(1)建立空的顺序表,首先定义一个顺序表的结构体,包括数据存储区和表长两个成员变量。

然后通过动态内存分配为顺序表分配存储空间,并初始化表长为0,即建立了一个空的顺序表。

(2)建立有元素的顺序表,定义一个包含初始元素的数组,然后将数组中的元素依次复制到顺序表的数据存储区中,并更新表长。

2. 插入元素。

在指定位置插入元素时,需要先判断插入位置是否合法,然后将插入位置后的元素依次后移,为插入元素腾出位置,并更新表长。

3. 删除元素。

删除指定位置的元素时,同样需要先判断删除位置是否合法,然后将删除位置后的元素依次前移,覆盖被删除的元素,并更新表长。

4. 查找元素。

根据元素值查找元素所在位置时,需要遍历顺序表中的元素,逐个比较元素值,找到匹配的元素位置后返回位置信息。

5. 输出顺序表。

将顺序表中的元素依次输出时,可以通过循环遍历顺序表中的元素,并逐个输出。

四、实验结果与分析。

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

通过对顺序表的操作,加深了对顺序表结构和操作方法的理解,掌握了顺序表的基本操作技巧。

在实际编程中,顺序表的基本操作是非常常见的,对于处理线性表数据具有重要意义。

五、实验总结。

通过本次实验,深入理解了顺序表的基本操作方法,掌握了顺序表的初始化、插入、删除、查找和输出等操作技巧。

在今后的学习和工作中,将能更加熟练地运用顺序表的基本操作,提高编程实践能力,为实际问题的解决提供更加有效的数据结构支持。

线性表实验报告

线性表实验报告

线性表实验报告一、实验目的本次实验的主要目的是深入理解线性表的基本概念和操作,通过实际编程实现线性表的存储和基本运算,掌握线性表在数据结构中的应用,提高对数据结构的理解和编程能力。

二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

三、实验原理线性表是一种最基本、最简单的数据结构,它是由 n(n≥0)个数据元素组成的有限序列。

在这个序列中,每个数据元素的位置是按照其逻辑顺序排列的。

线性表有两种存储结构:顺序存储结构和链式存储结构。

顺序存储结构是用一组地址连续的存储单元依次存储线性表中的数据元素,使得逻辑上相邻的两个元素在物理位置上也相邻。

其优点是可以随机访问表中的任意元素,时间复杂度为 O(1);缺点是插入和删除操作需要移动大量元素,时间复杂度为 O(n)。

链式存储结构是通过指针将各个数据元素链接起来,每个数据元素由数据域和指针域组成。

其优点是插入和删除操作不需要移动大量元素,时间复杂度为 O(1);缺点是不能随机访问表中的元素,需要从头指针开始遍历,时间复杂度为 O(n)。

四、实验内容本次实验实现了顺序表和链表的基本操作,包括创建、插入、删除、查找、遍历等。

1、顺序表的实现定义顺序表的结构体,包括数据存储数组和表的长度。

实现顺序表的初始化函数,将表的长度初始化为 0。

实现顺序表的插入函数,在指定位置插入元素,如果插入位置非法或表已满,则返回错误。

实现顺序表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。

实现顺序表的查找函数,查找指定元素,如果找到则返回元素的位置,否则返回-1。

实现顺序表的遍历函数,输出表中的所有元素。

2、链表的实现定义链表的结构体,包括数据域和指向下一个节点的指针域。

实现链表的创建函数,创建一个空链表。

实现链表的插入函数,在指定位置插入元素,如果插入位置非法,则返回错误。

实现链表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。

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

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

顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院:班级:姓名:程序名学号:日期:一、上机实验的问题和要求:顺序表的搜寻、填入与删掉。

设计算法,同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。

具体内容同时实现建议:1.从键盘输入10个整数,产生顺序表,并输入结点值。

2.从键盘输入1个整数,在顺序表搜寻该结点的边线。

若找出,输入结点的边线;若打听不到,则显示“找不到”。

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

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

二、源程序及注解:#include#include/*顺序表的定义:*/#include#definelistsize100/*表空间大小可根据实际需要而定,这里假设为100*/typedefintdatatype;/*datatype可以是任何相应的数据类型如int,float或char*/typedefstruct{datatypedata[listsize];/*向量data用作放置表中结点*/intlength;/*当前的表中长度*/}seqlist;voidmain(){seqlistl;inti,x;intn=10;/*欲建立的顺序表长度*/l.length=0;voidcreatelist(seqlist*l,intn);voidprintlist(seqlistl,intn);intlo catelist(seqlistl,datatypex);voidinsertlist(seqlist*l,datatypex,inti);voiddele telist(seqlist*l,inti);1createlist(&l,n);/*建立顺序表*/printlist(l,n);/*打印顺序表*/printf(\输入要查找的值:\scanf(\i=locatelist(l,x);/*顺序表查找*/printf(\输入要插入的位置:\scanf(\printf(\输入要插入的元素:\scanf(\insertlist(&l,x,i);/*顺序表插入*/printlist(l,n);/*打印顺序表*/printf(\输入要删除的位置:\scanf(\deletelist(&l,i);/*顺序表删除*/printlist(l,n);/*打印顺序表*/}/*顺序表的创建:*/voidcreatelist(seqlist*l,intn){inti;for(i=0;ilength=n;}/*顺序表的列印:*/voidprintlist(seqlistl,intn){inti;for(i=0;i/*顺序表的查找:*/intlocatelist(seqlistl,datatypex){inti=0;while(iif(i2/*顺序表的插入:*/voidinsertlist(seqlist*l,datatypex,inti){intj;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];l->data[i-1]=x;l->length++;}/*顺序表的删除:*/voiddeletelist(seqlist*l,inti){intj;if(l->length==0){printf(\现行表为空,退出运行\\n\exit(0);}if(i<1||i>l->length){printf(\删除位置非法\\n\exit(0);}for(j=i;j<=l->length-1;j++)l->data[j-1]=l->data[j];l->length--;}3三、运行输出结果:四、调试和运行程序过程中产生的问题及采取的措施:4。

数据结构实验,线性表的插入和删除,单链表操作,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)掌握线性表的顺序存储结构的定义及C语言实现。

(2)掌握线性表在顺序存储结构即顺序表中的各种基本操作。

二、实验要求:(1)复习课本中有关线性表的知识;(2)用C语言完成算法和程序设计并上机调试通过;(3)撰写实验报告,给出算法思路或流程图和具体实现(源程序)、算法分析结果(包括时间复杂度、空间复杂度以及算法优化设想)、输入数据及程序运行结果(必要时给出多种可能的输入数据和运行结果)。

三、实验内容1、顺序表的建立2、顺序表的插入3、顺序表的删除4、顺序表的遍历实验二线性表的链式实现一、实验目的:(1)掌握线性表的链式存储结构——单链表的定义及C语言实现。

(2)掌握线性表在链式存储结构——单链表中的各种基本操作。

二、实验要求:(1)复习课本中有关线性表的知识;(2)用C语言完成算法和程序设计并上机调试通过;(3)撰写实验报告,给出算法思路或流程图和具体实现(源程序)、算法分析结果(包括时间复杂度、空间复杂度以及算法优化设想)、输入数据及程序运行结果(必要时给出多种可能的输入数据和运行结果)。

三、实验内容1、单链表的建立2、单链表的插入3、单链表的删除4、单链表的合并5、删除单链表中的重复值实验三栈(队列)的实现一、实验目的:(1)熟悉栈(队列)的特点及栈(队列)的基本操作,如入栈、出栈(入队、出队)等。

(2)掌握栈(队列)的基本操作在栈(队列)的顺序存储结构和链式存储结构上的实现;二、实验要求:(1)复习课本中有关栈(队列)的知识;(2)用C语言完成算法和程序设计并上机调试通过;(3)撰写实验报告,给出算法思路或流程图和具体实现(源程序)、算法分析结果(包括时间复杂度、空间复杂度以及算法优化设想)、输入数据及程序运行结果(必要时给出多种可能的输入数据和运行结果)。

三、实验内容:编写一个程序实现顺序栈(队列)的各种基本运算,并在此基础上设计一个主程序,完成如下功能:(1)初始化顺序栈(队列)(2)插入元素(3)删除栈顶(队头)元素(4)取栈顶(队头)元素(5)遍历顺序栈(队列)(6)置空顺序栈(队列)(7)完成数制转换实验四、二叉树的基本操作的实现一、实验目的:(1)掌握二叉树链表的结构和二叉树的建立过程;(2)掌握二叉树的基本操作,加深对二叉树的理解,逐步培养解决实际问题的编程能力。

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

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

顺序表的基本操作和实现实验报告顺序表的基本操作和实现实验报告引言顺序表是一种常用的数据结构,它能够在连续的存储空间中存储元素,并通过索引来访问和修改这些元素。

本实验旨在通过实现基本操作,包括插入、删除、获取等,来深入理解顺序表的原理和实现方式。

实验目的1.掌握顺序表的基本操作2.理解顺序表的实现原理3.学习使用编程语言实现顺序表实验过程1.创建顺序表–使用数组作为底层存储结构,设置一个指针指向数组的起始位置,并初始化顺序表的长度为0。

2.插入元素–通过移动元素的方式,在指定位置插入一个新元素。

–更新顺序表的长度。

3.删除元素–通过覆盖元素的方式,删除指定位置的元素。

–更新顺序表的长度。

4.获取元素–根据指定位置,返回对应的元素。

5.更新元素–根据指定位置,修改对应的元素的值。

–不改变顺序表的长度。

6.打印顺序表–遍历顺序表中的元素,并输出到控制台。

实验结果根据以上操作,我们成功实现了一个顺序表,并在各基本操作上进行了测试和验证。

实验结果表明,顺序表能够高效地支持元素的插入、删除、获取和更新等操作,并能够正确地保存和展示数据。

实验总结通过本次实验,我们深入学习了顺序表的基本操作和实现方式。

顺序表作为一种简单而有用的数据结构,在实际应用中有着广泛的应用。

同时,我们也体会到了数据结构与算法的设计和实现的重要性,它们对于程序性能和可读性都有着关键的影响。

参考文献1.《数据结构与算法分析》2.《算法导论》3.《C++ Primer》实验环境•编程语言: C++•开发环境: Visual Studio Code•操作系统: Windows 10实验步骤1.创建顺序表的类SeqList,并定义私有属性int* data和intlength。

2.定义构造函数SeqList(int size),用于初始化顺序表的大小。

3.实现插入元素的方法void insert(int pos, int value),根据指定位置和值,在顺序表中插入新元素。

数据结构线性表试验报告

数据结构线性表试验报告

线性表上机实习1、实验目的(1)熟悉将算法转换为程序代码的过程。

(2)了解顺序表的逻辑结构特性,熟练掌握顺序表存储结构的C语言描述方法。

(3)熟练掌握顺序表的基本运算:查找、插入、删除等,掌握顺序表的随机存取特性。

(4)了解线性表的链式存储结构,熟练掌握线性表的链式存储结构的C语言描述方法。

(5)熟练掌握线性链表(单链表)的基本运算:查找、插入、删除等,能在实际应用中灵活选择适当的链表结构。

2、实验要求(1)熟悉顺序表的插入、删除和查找。

(2)熟悉单链表的插入、删除和查找。

3、实验内容:①顺序表(1)抽象数据类型定义typedef struct {TypeData data[maxsize]; //容量为maxsize的静态顺手表int n; //顺序表中的实际元素个数}SeqList; //静态顺序表的定义在本次实验中,首先建立一个空的静态顺序表,然后键盘输入数据存入表中,然后进入菜单选择界面,通过不同的数字输入,实现对顺序表,删除,插入,查找,显示等操作。

(2)存储结构定义及算法思想在顺序表结构体的定义中,typedef int TypeData 为整型,存储结构如下:for(n=0;n<m;n++){cout<<"请输入线性表数据"<<endl;cin>>[n]; //顺序将数据存入顺序表} //其他存储与此类似,都是直接赋值与数组的某一位插入版块子函数:void insert(SeqList &L) //插入数据{int a,b,c,k;cout<<"请输入插入的数及其插入的位置"<<endl;cin>>a>>b;if(b<=0||b>+1)) {cout<<"不能在该位置插入"<<endl; return;} //判断插入位置是否合法k=[b-1];[b-1]=a; c=; =+1;while(c>b){[c]=[c-1];c--; //通过循环,实现插入位置后的数据挨个往后移动一位}[b]=k;}顺序表的插入与删除操作类似,在插入与删除后,都要循环调整后面数组的每一位元素,同时记录数据元素的长度的标示符也要跟着改变。

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

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

元素之后的所有数据都前移一个位置,最将线性表长减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语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。

线性表的顺序表示及实现实验报告

线性表的顺序表示及实现实验报告
scanf("%d",&c);
ListDelete(&fibo,c,&item);
PrintList(fibo);
}
实验步骤
1、WIN-TC开发环境安装与配置
1)首先在网上下载WIN-TC的版本;
2)下载完成后进行安装,安装路径默认就可以了,一路next就ok了;
3)打开WIN-TC会出现如下界st(SqList fibo)
{
int i;
for(i=0;i<fibo.length;i++) printf("%d\t",fibo.items[i]);
printf("\n");
return 1;
}
main()
{
int i;
int a,b,c;
int data[10];
DataType item;
{
printf("cha ru bu he fa");
return 0;
}
for(i=fibo->length-1;i>=pos-1;i--)
fibo->items[i+1]=fibo->items[i];
fibo->items[pos-1]=item;
fibo->length++;
return 1;
DataType items[LISTSIZE];
int length;
}SqList;
int ListDelete(SqList *fibo,int pos,DataType *item)
{
int i;
if(ListEmpty(*fibo))

顺序表的操作实验报告

顺序表的操作实验报告

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

1. 了解顺序表的基本概念和操作方法;2. 掌握顺序表的插入、删除、查找等操作;3. 熟悉顺序表的存储结构和实现方式。

二、实验内容。

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

三、实验原理。

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

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

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

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

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

四、实验步骤。

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

五、实验结果与分析。

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

六、实验总结。

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

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

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

使用数据结构基础第五版王中华课后实验

使用数据结构基础第五版王中华课后实验

使用数据结构基础第五版王中华课后实验
本次实验是基于《数据结构基础》第五版王中华教授所编写的课本,实验内容包含了
课后习题的部分,并且结合课本中的数据结构实现,加以实践与验证。

实验一:线性表的基本操作
1、目的:加深对线性表基本概念的理解与掌握。

掌握线性表的初始化,清空,判空,获取长度等基本操作。

2、实验步骤:
(1)根据课本提供的线性表结构体定义,编写相应的初始化函数。

(2)编写线性表的清空、判空、获取长度等基本操作函数。

(3)测试以上函数是否正确。

3、实验结果:
测试函数结果均正确。

加深了对线性表基本操作的理解。

实验二:顺序表的插入与删除
1、目的:了解顺序表的插入和删除的实现过程,掌握插入和删除的操作方式和效
果。

(2)实现顺序表的插入(在指定位置插入)和删除(删除指定位置元素)操作。

测试函数结果正确。

了解了单链表和双链表的实现过程,掌握了链表的插入和删除操
作方法。

1、目的:了解栈的基本概念和操作方法,掌握栈的初始化、入栈、出栈、获取栈顶
元素、栈空及栈长等基本操作方法。

(2)实现队列的初始化、入队、出队、获取队头元素、队空及队长等基本操作方法。

总结:通过对《数据结构基础》第五版王中华教授所编写的课本进行实验,加深了对
线性表、顺序表、链表、栈和队列的理解,掌握了这些数据结构的基本操作方法和实现原理。

本次实验让我更有信心在数据结构的学习与实践中取得更好的结果。

数据结构实验报告顺序表

数据结构实验报告顺序表

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

线性表的基本操作实验报告

线性表的基本操作实验报告

线性表的基本操作实验报告线性表的基本操作1、需求分析:构建一个顺序表并实现顺序表的一些基本操作,例如创建列表,插入、删除元素,求元素的前驱等功能。

(1) 顺序表中数据元素为整形数字,范围属于int型。

(2) 输出部分操作提示以及功能操作所得到的数据(int型)。

(3) 顺序表建立、删除、插入、查询、判空、判满、查询前后驱等功能。

(4) 测试数据:a)b)2、概要设计:用一个结构定义了一个数组,和数组内容的长度。

主程序使用switch语句对将要进行的操作进行选择,调用各个功能函数。

3、实验源代码如下:#include<iostream>using namespace std;typedef struct{int date[100];int length;}SeqList;SeqList L;SeqList SeqListInit()//初始化顺序表 {cout<<"你定义的顺序表的长度(长度小于)"<<endl;cin>>L.length;cout<<"顺序表里面储存数据为"<<endl;for(int i=0;i<L.length;i++){int a;cin>>a;L.date[i]=a;}return L;}void ListClear()/* 清空顺序表*/{L.length=0;}int ListLength()/* 求顺序表长度*/{cout<<L.length<<endl;return 0;}int ListEmpty()/* 检查顺序表是否为空*/ { if(L.length==0)cout<<"为空"<<endl;elsecout<<"不为空"<<endl;return 0;}int ListFull()/*检查顺序表是否为满*/ { if(L.length==100)cout<<"为满"<<endl;elsecout<<"未满"<<endl;return 0;}void ListTraverse()/* 遍历顺序表*/{for(int i=0;i<L.length;i++)cout<<L.date[i]<<" ";cout<<endl;}int ListGet(int i)/* 从顺序表中查找元素*/ { if(i>=0&&i<L.length)cout<<L.date[i-1]<<endl;return 0;}int ListLocate(int x){for(int i=0;i<L.length;i++)if(L.date[i]==x)cout<<L.date[i];return 0;}void ListInsert(int i, int x){if(i>=0&&i<L.length){for(int m=0;i<=L.length-i;m++)L.date[L.length]=L.date[L.length-1];L.date[i-1]=x;L.length++;}}void ListDelete(int i){if(i>=0&&i<L.length){for(i;i<L.length;i++)L.date[i-1]=L.date[i];L.length--;}}int ListPrior(int e){if(e-2>=0&&e-2<L.length)cout<<L.date[e-2]<<endl;return 0;}int ListNext(int e){if(e>=0&&e<L.length)cout<<L.date[e]<<endl; return 0; }int main(){while(1){int i;cout<<"1初始化顺序表"<<endl;cout<<"2清空顺序"<<endl;cout<<"3求顺序表长度"<<endl;cout<<"4检查顺序表是否为空"<<endl;cout<<"5检查顺序表是否为满"<<endl;cout<<"6遍历顺序表"<<endl;cout<<"7从顺序表中查找元素"<<endl;cout<<"8从顺序表中查找与给定元素值相同的元素的位置"<<endl; cout<<"9向顺序表插入元素"<<endl;cout<<"10从顺序表中删除元素"<<endl;cout<<"11求元素前驱"<<endl;cout<<"12求元素后继"<<endl;cin>>i;switch (i){case 1:SeqListInit();break;case 2:ListClear();break;case 3:ListLength();break;case 4:ListEmpty();break;case 5:ListFull();break;case 6:ListTraverse();break;case 7:{int m;cout<<"请输入查找元素的位置"<<endl; cin>>m;ListGet(m);break;}case 8:{int m;cout<<"请输入查找元素"<<endl; cin>>m;ListLocate(m);break;}case 9:{int x;cout<<"请输入插入的元素"<<endl; cin>>x;ListInsert(i,x);break;}case 10:{int m;cout<<"请输入删除的元素"<<endl; cin>>m;ListDelete(m);break;}case 11:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListPrior(m);break;}case 12:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListNext(m);break;}default:break;}}}4、a) 遇见形参与实参搞混问题,改形参里面的内容并不影响其原本数据。

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

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

提前了解实验相关的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;
}
实验结果
五、实验心得
通过实验学习,我理解了线性顺序表的插入与删除的算法,了解到线性顺序表的插入与删除得效率低下,感到受益匪浅。

相关文档
最新文档