实验一 顺序表的基本运算

合集下载

顺序表基本操作

顺序表基本操作

实验1:顺序表实验(4学时)一.实验目的1.学会定义线性表的顺序存储类型,实现C程序的基本结构对线性表的一些基本操作和具体的函数定义。

2.掌握顺序表的基本操作,实现顺序表的插入,删除,查找基本运算。

3.掌握对于多函数程序的输入,编辑,调试和运算过程。

二.实验要求1.预习C语言中结构体的定义和基本的操作方法。

2.对顺序表每个基本操作用一个单独函数实现。

3.编写完整程序完成下面实验内容并且上机运行。

三.实验内容编写完整程序完成下面基本操作并且上机运行1.初始化顺序表La;2.将顺序表La设置为空表;3.测试顺序表La是否上空表;4.在顺序表La插入一个新元素;5.删除顺序表La中某个元素;6. 在顺序表La中查找某个元素,查找成功,返回位序,否则返回0;7. 建立顺序表La;8. 打印顺序表La所有元素;9. 输入n个元素建立顺序表La;10. 归并非递减表La和Lb成为非递减表Lc要求编写一个主菜单调用上面各个基本操作。

;程序:#include <stdio.h>#include <conio.h>#include <stdlib.h>#define LIST_INIT_SIZE 10#define LISTINCREMENT 3#define TRUE 1#define FALSE 0#define OK 1#define ERROR -1#define OVERFLOW -2typedef int status;typedef int Elemtype;typedef struct {int *elem;int length;int listsize;}sqlist;status Printf_sq(sqlist *L){if(!L) return ERROR;else for(int i=0;i<L->length;i++)printf("%d",L->elem[i]);return OK;}status InitList_Sq(sqlist *L) {L->elem=(Elemtype *)malloc(LIST_INIT_SIZE*sizeof(Elemtype));if(!L->elem) return ERROR;//如果用exit的话一但退出就退出整个程序L->length=0;L->listsize=LIST_INIT_SIZE;L->elem[0]=0;L->elem[1]=1;L->elem[2]=2;L->length=3;Printf_sq(L);return OK; }status ClearList_sq(sqlist *L){L->length=0;Printf_sq(L);return OK;}status ListEmpty_sq(sqlist *L){if(L->length==0) return OK;else return ERROR;}status ListInsert_sq(sqlist *L,int i,int e){int *q,*p;if (i<1 || i>L->length+1)return ERROR;if (L->length >= L->listsize) {int *newbase;newbase = (Elemtype *) realloc(L->elem, (L->listsize + LISTINCREMENT) * sizeof (Elemtype));L->elem = newbase;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;Printf_sq(L);return OK;}status ListDelete_sq(sqlist *L,int i,int e){int *q,*p;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;Printf_sq(L);return OK;}status LocateElem_sq(sqlist *L, int e){for(int i=0;i<L->listsize;i++){if(L->elem[i]==e)return i;if(i==LIST_INIT_SIZE)return OVERFLOW;}return OK;}status Creat_sq(sqlist *L){L->elem=(Elemtype *)malloc(LIST_INIT_SIZE*sizeof(Elemtype)); if(!L->elem) return ERROR;L->length=0;L->listsize=LIST_INIT_SIZE;L->elem[0]=0;L->elem[1]=1;L->elem[2]=2;L->length=3;Printf_sq(L);return OK;}void MergeList_Sq(sqlist La, sqlist Lb, sqlist &Lc) {int *pa,*pb,*pc,*pa_last,*pb_last;pa = La.elem; pb = Lb.elem;Lc.listsize = Lc.length = La.length+Lb.length;pc = Lc.elem = (Elemtype *)malloc(Lc.listsize*sizeof(Elemtype)); if (!Lc.elem)exit(OVERFLOW);pa_last = La.elem+La.length-1;pb_last = Lb.elem+Lb.length-1;while (pa <= pa_last && pb <= pb_last) {if (*pa <= *pb) *pc++ = *pa++;else *pc++ = *pb++;}while (pa <= pa_last) *pc++ = *pa++;while (pb <= pb_last) *pc++ = *pb++;Printf_sq(&Lc);}void main(){int e=1;int i=1;sqlist La,Lb,Lc,Ld,Le,Lf,Lg,Lh;InitList_Sq( &La);InitList_Sq( &Lb);InitList_Sq( &Lc);InitList_Sq( &Ld);InitList_Sq( &Le);InitList_Sq( &Lf);InitList_Sq( &Lg);InitList_Sq( &Lh);ClearList_sq(&Lb);ListEmpty_sq(&Lc);ListInsert_sq(&Ld,i,e);ListDelete_sq(&Le,i,e);LocateElem_sq(&Lf, e);Creat_sq(&Lg);Printf_sq(&Lg);MergeList_Sq(La, Lb, Lh);}实验2:单链表实验(6学时)一实验目的1.学会定义线性表的链表存储类型,实现C程序的基本结构对线性表的一些基本操作和具体的函数定义。

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

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

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

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法顺序表是一种基本的数据结构,它可以存储线性结构,支持随机访问,具有较好的存储效率。

在实际应用中,我们需要实现顺序表的各种基本运算,包括插入、删除、查找、遍历、排序等操作。

下面介绍一些实现顺序表基本运算的算法。

1.插入算法顺序表插入算法的基本思路是:将插入位置之后的所有元素向后移动一位,然后将待插入元素放入插入位置。

具体实现如下:```void Insert(SqList &L, int pos, int data){if (pos < 1 || pos > L.length + 1) // 插入位置非法return;if (L.length == L.MAXSIZE) // 顺序表已满return;for (int i = L.length; i >= pos; i--) // 将pos以后的元素依次后移,腾出pos位置L.data[i] = L.data[i - 1];L.data[pos - 1] = data; // 将新元素插入pos位置L.length++; // 顺序表长度+1}```2.删除算法顺序表删除算法的基本思路是:将待删除元素之后的所有元素向前移动一位,然后将顺序表长度减1。

具体实现如下:```void Delete(SqList &L, int pos){if (pos < 1 || pos > L.length) // 删除位置非法return;for (int i = pos; i < L.length; i++) // 将pos以后的元素依次前移,覆盖pos位置L.data[i - 1] = L.data[i];L.length--; // 顺序表长度-1}```3.查找算法顺序表查找算法的基本思路是:从表头开始逐个比较元素,直到找到目标元素或者搜索到表尾。

具体实现如下:```int Search(SqList L, int data){for (int i = 0; i < L.length; i++){if (L.data[i] == data) // 找到目标元素,返回其下标return i;}return -1; // 未找到目标元素,返回-1}```4.遍历算法顺序表遍历算法的基本思路是:从表头开始依次输出元素。

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

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

实验一顺序表的基本操作一、实验目的掌握线性表的顺序表基本操作:建立、插入、删除、查找、合并、打印等运算。

二、实验要求包含有头文件和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顺序表和链表基本操作(学生)

实验1顺序表和链表基本操作(学生)

实验一线性表运算的实现班级学号姓名一、实验预备知识1.复习C中函数的相关内容。

2.复习如何用主函数将多个函数连在一起构成一个C完整程序。

3.复习多文件结构。

二、实验目的1.掌握线性表的顺序和链式存储结构2.熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3.熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1.编写初始化并创建线性表和输出线性表的算法。

2.编写对线性表插入和删除运算算法,要判断位置的合法性和溢出问题。

3.编写有序表的插入和删除运算算法。

4.编写一个主函数,将上面函数连在一起,构成一个完整的程序。

5.将实验源程序调试并运行,写出输入、输出结果,并对结果进行分析。

四、实验内容顺序表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。

2.初始化并建立顺序表。

(开辟的存储空间大小为8)3.编写顺序表输出算法。

4.依次插入3,21,15三个数,分别插入在第4,6和2位置,每插入一次都要输出一次顺序表。

5.删除第5,第3和第12个位置上的元素,每删除一个元素都要输出一次顺序表。

6.编写一个排序算法,对线性表中元素从小到大排列。

7.向有序表分别插入20和50,插入后表仍然有序。

(修改开辟的存储空间大小为15)单链表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。

2.建立一个带表头结点的单链表(前插入法和尾插入法都可以)。

3.编写单链表输出算法。

4.依次插入3,21,15三个数,分别插入在第4,6和12位置,每插入一次都要输出一次单链表。

5.删除第5,第3和第12个位置上的元素,每删除一个元素都要输出一次单链表。

6.编写一个排序算法,对线性表中元素从小到大排列。

7.分别删除值为25和42的元素,删除后表仍然有序。

五、实验结果给出程序清单及输入/输出结果六、总结1.实验过程中遇到的问题及解决方法2.收获北华航天工业学院《数据结构》课程实验报告实验题目:作者所在系部:作者所在专业:作者所在班级:作者学号:作者姓名:任课教师姓名:完成时间:北华航天工业学院教务处制一、实验目的1 掌握线性表的顺序和链式存储结构;2 熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算;3 熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算。

顺序表实验报告

顺序表实验报告

实验一顺序表的基本操作及其应用一、需求分析1.本演示程序实现顺序表的初始化,依次从键盘读入数据,建立顺序表、表中元素的连续追加、求顺序表的长度、检查顺序表是否为空、检查顺序表是否为满、显示顺序表、从顺序表中查找元素、给定元素值找位置、向顺序表中插入元素、从顺序表中删除元素、顺序表的逆序排列等基本操作。

2.演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后,由用户在键盘上输入演示程序中规定的运算命令。

3.程序执行命令包过1)顺序表的初始化;2)连续追加元素建表;3)求顺序表长度;4)检查顺序表是否为空;5)检查顺序表是否为满;6)显示顺序表;7)从顺序表中查找元素;8)给定元素值找位置;9)向顺序表中插入元素;10)从顺序表中删除元素;11)逆序二、概要设计抽象化数据类型线性表的定义如下:ADT List{数据对象:D={ai|ai属于ElemSet,i=1,2,....,n,n>=0}数据关系:R1={<ai-1,ai>|ai-1,ai属于D,i=2,.....n}基本操作:ListEmpty(L)初始条件:线性表L已存在。

操作结果:若L为空表,则返回TURE,否则返回FLASE。

ListLength(L)初始条件:线性表L已存在。

操作结果:返回L中数据元素个数。

ListInsert(&L,i,e)初始条件:线性表L已存在,1<=i<=ListLength(L)+1。

操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1。

ListDelete(&L,i,&e)初始条件:线性表L已存在且非空,1<=i<=ListLength(L)。

操作结果:删除L的第i个数据元素,并用e返回其值,L的长度减一。

ListTraverse(L,visit())初始条件:线性表L已存在。

操作结果:依次对L的每个数据元素调用函数visit()。

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法1. 初始化顺序表算法实现:初始化操作就是将顺序表中所有元素的值设置为默认值,对于数值类型,可以将其设置为0,对于字符类型,可以将其设置为空格字符。

初始化的时间复杂度为O(n),其中n为顺序表的长度。

2. 插入操作算法实现:顺序表的插入操作就是在指定位置上插入一个元素,需要将该位置后面的元素全部后移,在指定位置上插入新元素。

若顺序表已满,则需要进行扩容操作,将顺序表长度扩大一倍或者按一定的比例扩大。

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

3. 删除操作算法实现:顺序表的删除操作需要将指定位置上的元素删除,并将该位置后面的元素全部前移。

删除操作后,如果顺序表的实际长度小于等于其总长度的1/4,则需要进行缩容操作,将顺序表长度缩小一倍或者按一定的比例缩小。

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

4. 修改操作算法实现:顺序表的修改操作就是将指定位置上的元素赋予新的值。

修改操作的时间复杂度为O(1)。

5. 查找操作算法实现:顺序表的查找操作就是在顺序表中找到指定位置的元素,并返回其值。

查找操作的时间复杂度为O(1)。

6. 遍历操作算法实现:顺序表的遍历操作就是依次访问顺序表中的每个元素,遍历操作的时间复杂度为O(n),其中n为顺序表的长度。

7. 合并操作算法实现:顺序表的合并操作就是将两个顺序表合并成一个新的顺序表,新的顺序表的长度为两个顺序表的长度之和。

合并操作的时间复杂度为O(n),其中n为两个顺序表的长度之和。

总结:顺序表是一种简单而高效的数据结构,其基本运算包括初始化、插入、删除、修改、查找、遍历和合并等操作。

其中,插入、删除、遍历和合并操作的时间复杂度比较高,需要进行相应的优化处理。

同时,在实际应用中,还需要注意顺序表的扩容和缩容操作,避免造成资源浪费或者性能下降。

数据结构实验一顺序表

数据结构实验一顺序表

数据结构实验一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;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

顺序表的基本运算

顺序表的基本运算

顺序表的基本运算
顺序表是一种常见的数据结构,它可以存储一组具有相同数据类型的元素,并支持一系列的基本操作。

顺序表的基本运算包括插入、删除、查找和遍历等操作。

1. 插入操作:顺序表的插入操作通常有两种方式,一种是在表尾插入元素,另一种是在表中的任意位置插入元素。

对于表尾插入元素,需要先判断表是否已满,如果未满,则将元素插入表尾。

对于在表中任意位置插入元素,需要先将插入位置及其之后的元素后移,然后再将要插入的元素放入合适的位置。

2. 删除操作:顺序表的删除操作也有两种方式,一种是删除表尾元素,另一种是删除表中的任意元素。

对于删除表尾元素,直接将表尾元素删除即可。

对于删除表中任意元素,需要先找到要删除的元素的位置,然后将该位置之后的元素前移,最后将表中的元素个数减1。

3. 查找操作:顺序表的查找操作可以根据元素的值或者位置进行。

如果是根据元素的值进行查找,则需要遍历整个表,逐一比较元素的值。

如果是根据位置进行查找,则直接返回该位置的元素值即可。

4. 遍历操作:顺序表的遍历操作可以遍历整个表,也可以只遍历部分元素。

遍历整个表可以使用循环结构,依次输出每个元素的值。

遍历部分元素则可以通过设置起始位置和结束位置来实现。

- 1 -。

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

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

实验报告课程数据结构及算法实验项目 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. 删除元素,删除指定位置的元素。

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

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

三、实验步骤。

1. 初始化顺序表。

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

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

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

2. 插入元素。

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

3. 删除元素。

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

4. 查找元素。

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

5. 输出顺序表。

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

四、实验结果与分析。

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

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

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

五、实验总结。

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

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

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

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

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

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

实验目的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),根据指定位置和值,在顺序表中插入新元素。

数据结构 顺序表基本运算实现

数据结构 顺序表基本运算实现
printf("这些元素分别是:\n");
; //依次打印输出顺序表中的元素
printf("\n");
}
//查找
locate(SeqList *list, int e)
{
int i;
printf("插入元素,请输入需要插入的位置:\n");
scanf("%d",&i);
insert(list,i,e);
printList(list);
break;
3.编写一个完整的程序实现顺序表的下列基本操作:
(1) 新建一个顺序表。。
(2) 打印输出顺序表中的元素。
(3) 在顺序表中查找某个元素。
(4) 在顺序表中指定位置插入元素。
(5) 在顺序表中删除指定位置的元素。
(6) 删除顺序表La中的某一元素。
编写一个主菜单,调用以上基本操作。
参考程序代码如下,请将其补充完整,并上机调试运行。
//顺序表的建立、查找、插入与删除,表元素为数字
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define MAX 100 //表最大长度
//选择顺序表操作动作
printf("请输入操作对应的数字进行顺序表的操作:\n");
printf("————查询(1)\n);
printf("————插入(2)\n);
printf("————删除(3)\n);
printf("————退出(0)\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 线性顺序表的基本操作

实验一一、实验目的1、掌握使用VC6.0上机调试线性表的基本方法;2、掌握线性表的基本操作:插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。

二、实验要求1、认真阅读和掌握本实验的程序。

2、上机运行本程序。

3、保存和打印出程序的运行结果,并结合程序进行分析。

4、按照你对线性表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果三、注意事项:在磁盘上创建一个目录,专门用于存储数据结构实验的程序。

四、实验内容程序1:线性表基本操作的实现这个程序中演示了顺序表的创建、插入、删除和查找,请修改并完成。

程序如下:#include <stdio.h>#include <stdlib.h>/*顺序表的定义:*/#define ListSize 100typedef struct{ int data[ListSize]; /*向量data用于存放表结点*/int length; /*当前的表长度*/}SeqList;void CreateList(SeqList *L,int n);void PrintList(SeqList *L,int n);int LocateList(SeqList *L,int x);void InsertList(SeqList *L,int x,int i);void DeleteList(SeqList *L,int i);void main(){SeqList L;int i,x;int n=10; /*THE LENGTH OF LIST*/L.length=0;clrscr();CreateList(&L,n); /*CREAT THE LIST*/PrintList(&L,n); /*PRINT THE LIST*/printf("INPUT THE RESEARCH ELEMENT");scanf("%d",&x);i=LocateList(&L,x);printf("the research position is %d\n",i); /*顺序表查找*/printf("input the position of insert:\n");scanf("%d",&i);printf("input the value of insert\n");scanf("%d",&x);InsertList(&L,x,i); /*顺序表插入*/PrintList(&L,n); /*打印顺序表*/printf("input the position of delete\n");scanf("%d",&i);DeleteList(&L,i); /*顺序表删除*/PrintList(&L,n);getch();/*打印顺序表*/}/*顺序表的建立:*/void CreateList(SeqList *L,int n){int i;printf("please input n numbers\n");for(i=1;i<=n;i++){scanf("%d",&L->data[i]);}L->length=n;}/*顺序表的打印:*/void PrintList(SeqList *L,int n){int i;printf("the sqlist is\n");for(i=1;i<=n;i++)printf("%d ",L->data[i]);}/*顺序表的查找:*/int LocateList(SeqList *L,int x){int i;for(i=1;i<=10;i++)if((L->data[i])==x) return(i);else return(0);}/*顺序表的插入:*/void InsertList(SeqList *L,int x,int i){int j;for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=x;L->length++;}/*顺序表的删除:*/void DeleteList(SeqList *L,int i) { int j;for(j=i;j<=(L->length)-1;j++)L->data[j]=L->data[j+1];}。

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法顺序表是一种线性表,可以用数组来实现。

在顺序表中,数据元素在数组中的存储位置是按照逻辑顺序依次排列的。

顺序表中的基本运算包括插入、删除、查找、遍历等。

1. 插入操作顺序表的插入操作是指在顺序表中的指定位置插入一个元素。

插入操作分为两种情况:(1) 在顺序表的末尾插入元素;(2) 在顺序表的中间插入元素。

插入操作算法如下:(1) 在顺序表的末尾插入元素:a. 判断顺序表是否已满,如果已满则输出错误信息;b. 否则将元素插入到顺序表的末尾。

(2) 在顺序表的中间插入元素:a. 判断顺序表是否已满,如果已满则输出错误信息;b. 否则将指定位置之后的元素向后移动一个位置;c. 将新元素插入到指定位置。

2. 删除操作顺序表的删除操作是指删除顺序表中指定位置的元素。

删除操作分为两种情况:(1) 删除顺序表的末尾元素;(2) 删除顺序表的中间元素。

删除操作算法如下:(1) 删除顺序表的末尾元素:a. 判断顺序表是否为空,如果为空则输出错误信息;b. 否则删除顺序表的最后一个元素。

(2) 删除顺序表的中间元素:a. 判断顺序表是否为空,如果为空则输出错误信息;b. 否则将指定位置之后的元素向前移动一个位置;c. 删除指定位置的元素。

3. 查找操作顺序表的查找操作是指在顺序表中查找指定元素的位置。

查找操作分为两种情况:(1) 查找顺序表中第一个符合条件的元素;(2) 查找顺序表中所有符合条件的元素。

查找操作算法如下:(1) 查找顺序表中第一个符合条件的元素:a. 从表头开始遍历顺序表;b. 如果找到符合条件的元素,则返回该元素的位置;c. 如果遍历完整个顺序表都没有找到符合条件的元素,则返回错误信息。

(2) 查找顺序表中所有符合条件的元素:a. 从表头开始遍历顺序表;b. 如果找到符合条件的元素,则输出该元素的位置;c. 如果遍历完整个顺序表都没有找到符合条件的元素,则输出错误信息。

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

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

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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)掌握链表的概念,学会对链表进⾏操作。

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

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

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

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

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

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

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

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

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

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

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

加深对有关算法的理解。

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

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

实验一顺序表的基本运算
1、实验目的
掌握顺序表的基本操作,初始化、插入、删除以及显示等运算在顺序存储结构上的实现。

2、实验内容
(1)顺序表的初始化;
(2)顺序表插入算法的实现;
(3)顺序表删除算法的实现;
(4)显示顺序表中各个元素;
(5)顺序表清空算法的实现;
(6)顺序表判空算法的实现;
(7)求顺序表长度算法的实现;
(8)求顺序表中一个元素前驱算法的实现;
(9)求顺序表中一个元素后继算法的实现;
(10)求顺序表第i个元素算法的实现。

3、实验要求
(1)能够熟练在Visual C++6.0环境中进行程序的编辑、编译和调试;
(2)会书写类C语言的算法,并将算法转变为程序实现。

4、运行程序
#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
#define LISTINCREMENT 10
typedef char ElemType;
typedef struct{
ElemType *elem;
int length;
int listsize;
}SqList;
int InitList_Sq(SqList &L){
L.elem = (ElemType *)malloc(MaxSize*sizeof(ElemType));
if(!L.elem) return 0;
L.length = 0;
L.listsize=MaxSize;
return 1;}
int ListInsert_Sq(SqList &L,int i,ElemType e){
if(i<1||i>L.length+1) return 0;
ElemType *p;
if(L.length>=L.listsize) {
ElemType *newbase = (ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(! newbase) return 0;
L.elem = newbase;
L.listsize += LISTINCREMENT; }
ElemType *q=&L.elem[i-1];
for(p=&L.elem[L.length-1];p>=q;--p)
*(p+1)=*p;
*q=e;
++L.length;
return 1;}
int ListDelete_Sq(SqList &L,int i,ElemType &e){
if(i<1||i>L.length) return 0;
ElemType *p=&(L.elem[i-1]);
e=*p;
ElemType *q=L.elem+L.length-1;
for(++p;p<=q;++p)
*(p-1)=*p;
--L.length;
return 1;}
void Disp_Sq(SqList L){
if(L.length==0) printf("此顺序表为空表!\n");
for(int i=0;i<L.length;i++)
printf("%c",L.elem[i]);
printf("\n");}
void main(){
ElemType e;
SqList L;
InitList_Sq(L);
Disp_Sq(L);
ListInsert_Sq(L,1,'A');
ListInsert_Sq(L,2,'B');
ListInsert_Sq(L,1,'C');
Disp_Sq(L);
ListDelete_Sq(L,1,e);
Disp_Sq(L);
printf("删除的元素是:%c\n",e);}
5、测试数据:
(1)运行程序并给出运行结果。

(2)改变主函数,使插入的元素序列为CBA,并删除第2个位置的元素。

void main( ){
}
(3)执行下列函数
#include <stdio.h>
#include <malloc.h>
void main(){
char a[3]={'C','A','B'}; int i;
for(i=0;i<3;i++) printf("%c",a[i]);
printf("\n");
char e=a[0];
for(i=0;i<2;i++) a[i]=a[i+1];
a[2]=' ';
for(i=0;i<3;i++) printf("%c",a[i]);
printf("\n");
printf("删除的元素是:%c\n",e); }
观察运行结果,分析在数组中直接插入和删除元素与在顺序表中插入删除元素的区别。

(4)将实验内容中(5)-(10)的算法写成函数,使得主程序可以调用它们。

相关文档
最新文档