数据结构顺序表
数据结构算法经典 -顺序表

insertsort(struct sqlist *p,int n)
{
int i,j;
for(i=2;i<=n;i++)
{
p->sqlist[0]=p->sqlist[i];
j=i-1;
while(j>0 && p->sqlist[0]<p->sqlist[j])
printf("\n");
for(i=1;i<=n;i++)
printf("%d",p->sqlist[i]);
printf("\n");
}
}
display(struct sqlist *p)
{
int j;
if (p->size==0)
printf("此表为空无法显示!");
else
{
for (j=i;j<p->size;j++)
p->sqlist[j]=p->sqlist[j+1];
p->size--;
}
printf("此线性表为:");
for (i=1;i<=p->size;i++)
printf("%d->",p->sqlist[i]);
printf("%d",p->sqlist[j]);
}
}
main()
{
int i,select,a,j;int w;
数据结构实验报告-线性表(顺序表实现)

实验1:线性表(顺序表的实现)一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。
三、实验基本原理顺序表是由地址连续的的向量实现的,便于实现随机访问。
顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素:6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。
实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败!";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败!";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量:" << endl;cin >> len;cout << "依次输入要插入的元素:" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功!" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是:" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功!" << endl << "被删除的元素是:" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是:" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置:" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;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;cout << "--------------13:归并线性表-------------" << endl;cout << "--------------14:奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束!" << endl;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素(返回的是数组下标,下标从0开始)4.删除元素(位置从1开始)5.销毁顺序表6.清空顺序表7.顺序表长度(销毁或清空操作前)8.判空(销毁或清空操作前)9.定位满足大小关系的元素(销毁或清空操作前)说明:这里默认找第一个小于目标元素的位置且下标从0开始,当前顺序表的数据为:1 4 2 510.前驱(销毁或清空操作前)11.后继(销毁或清空操作前)12.输出顺序表(销毁或清空操作前)13.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。
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、顺序表存储
原理:将表中元素⼀个个存⼊⼀组连续的存储单元中,这种存储结构是顺序结构。
采⽤顺序存储结构的线性表简称为“ 顺序表”。
优点:简单易⽤使⽤的是联系的内存空间可以借助CPU的缓存机制预读取数组中的数据所以访问效率⽐较⾼
缺点:1.插⼊和删除⽐较慢
2.不可以增长长度
3:如果申请的过⼤系统可能没有⾜够的内存空间给分配,会导致内存不⾜,如果声明过⼩就会导致不够⽤如果不够⽤只能申请⼀个更⼤的空间还要把原数组的数据copy 过去影响效率
⽐如:插⼊或者删除⼀个元素时,整个表需要遍历移动元素来重新排⼀次顺序 C# 中如 ArrayList List 等
2、链式表存储
原理:链表存储是在程序运⾏过程中动态的分配空间,只要存储器还有空间,就不会发⽣存储溢出问题
优点:插⼊和删除速度快,保留原有的物理顺序
缺点:查找速度慢,因为查找时,需要循环链表访问并且链式存储在内存中不连续这样对CPU的缓存不友好没办法做到预先读取链表除了要存储本⾝数据外还要额外维护前后节点的指针,对内存要求的严格的程序是不友好的~⽽且链表频繁的删除和新增会导致内存也频繁的申请释放容易产⽣内存碎⽚导致GC 频繁的去回收
⽐如:插⼊或者删除⼀个元素时,只需要改变指针指向即可 C# 中 LinkedList<T>
总结在实际开发中我们还是要权衡⾃⼰的使⽤场景来决定使⽤什么样的数据结构。
chap2数据结构,顺序表,树,图,链表,排序

2.4 一元多项式的表示
ADT List { 数据对象: D={ ai | ai ∈ElemSet, i=1,2,...,n, n≥0 } { 称 n 为线性表的表长; 称 n=0 时的线性表为空表。} 数据关系:
R1={ <ai-1 ,ai >|ai-1 ,ai∈D, i=2,...,n }
{ 设线性表为 (a1,a2, . . . ,ai,. . . ,an), 称 i 为 ai 在线性表中的位序。}
i = 1; found = TRUE; while ( i<= La_len && found ) {
GetElem(LA, i, e); // 取得LA中一个元素
if (LocateElem(LB, e, equal( ))
i++;
// 依次处理下一个
else found = FALSE;
// LB中没有和该元素相同的元素
{加工型操作} ClearList( &L ) ( 线性表置空 ) PutElem( &L, i, &e ) ( 改变数据元素的值 ) ListInsert( &L, i, e ) ( 插入数据元素 ) ListDelete( &L, i, &e ) ( 删除数据元素 )
ClearList( &L ) 初始条件:线性表 L 已存在。 操作结果:将 L 重置为空表。 PutElem( &L, i, e ) 初始条件: 线性表 L 已存在, 且 1≤i≤LengthList(L)。 操作结果:L 中第 i 个元素赋值和 e 相同。
线性结构的基本特征: 线性结构 是 一个数据元素的有序(次序)集 1.集合中必存在唯一的一个“第一元素” 2.集合中必存在唯一的一个 “最后元素”
数据结构实验一顺序表

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

顺序表类型定义
顺序表类型定义是一种数据结构,由相同类型的元素连续存储在内存中形成一个逻辑上有序的序列。
顺序表又称为线性表,它是一种可以容纳任意类型的数据的数据结构,也是计算机中最常用的数据结构之一。
顺序表的特点是:存储方式简单,因为它只需要连续的内存单元就可以存储元素;查找快,因为它具有索引,可以快速查找到需要的元素;插入和删除方便,因为顺序表本身就是一个有序的结构,只需要移动一小部分元素就可以实现插入和删除;可以随机访问,因为它具有索引,可以根据索引快速访问到指定位置的元素。
顺序表的缺点是:容量有限,因为它需要连续的内存空间,如果存储的元素太多,就会导致内存空间不够用;插入和删除效率较低,因为顺序表本身是一个有序的结构,插入和删除时需要移动大量的元素,所以效率较低。
顺序表在程序设计中有着广泛的应用,它可以用来存储数据、实现算法、实现抽象数据类型(ADT)等。
在算法设计中,顺序表可以用来实现查找、排序、插入、删除等常见的算法;在数据结构设计中,顺序表可以用来实现栈、队列、双端队列等复杂的数据结构;在ADT设计中,顺序表可以用来实现字符串、集合、图等常见的ADT。
总之,顺序表类型定义是一种简单易用的数据结构,它可以用来实现各种常见的算法和数据结构,而且可以满足大多数应用场景的需求。
顺序表的建立与基本算法

顺序表的建立与基本算法
顺序表是数据结构中最基本、最常见的存储结构。
它是一组在一起的有组织地存储在内存中的相关数据项,以便快速访问和修改。
顺序表的建立与基本算法主要包括以下几点:
一、建立顺序表
1.定义存储空间大小:首先要确定存储空间大小,根据实际情况来确定。
2.申请内存空间:将需要的内存空间分配给顺序表,用于存放后面的数据元素。
3.初始化顺序表:将顺序表的长度初始化为0,表示此时顺序表是空表,然后给顺序表的数据元素赋初值,例如-1、0、NULL等。
4.插入数据元素:在指定位置插入数据元素到顺序表上。
5.释放内存空间:当顺序表使用完毕,需要释放顺序表所申请的内存空间,回收内存。
二、顺序表的基本算法
1.查找算法:在顺序表中查找特定的数据元素,通过遍历顺序表的方式来查找,可以通过比较元素的特征值来区分,查找的时间复杂度为O(n)。
2.插入算法:在顺序表中插入数据元素,需要先判断顺序表是否已满,如果未满则在指定位置插入数据元素,需要将插入位置后面的元素都后移一个位置,插入的时间复杂度为O(n)。
3.删除算法:在顺序表中删除数据元素,需要先判断顺序表是否为空,如果非空则在指定位置删除数据元素,需要将删除位置后面的元素都前移一个位置,删除的时间复杂度为O(n)。
4.更新算法:更新顺序表中的数据元素,需要先查找到特定的元素,然后根据需要更新数据元素,更新的时间复杂度也是O(n)。
总的来说,顺序表的建立与基本算法包括建立顺序表,查找算法,插入算法,删除算法,更新算法等几个方面,都要结合实际情况具体
操作,时间复杂度都是O(n)。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
return(TRUE);
}
void main()//主函数
{SeqList l,*la;
int p,q,r,k,j ,m,num;
printf("请输入线性表的长度:");
scanf("%d",&r);
st = r-1;
la=&l;
Input(la,la->last+1);
(4)创建顺序表的插入函数:int InsList(SeqList *L,int i,ElemType e);
(5)创建顺序表的删除函数:int DelList(SeqList *L,int i,ElemType *e);
(6)主函数:void main()
4.详细设计
#include <stdio.h>
{ElemTypeelem[MAXSIZE];
Intlast;
}SeqList;
3.模块划分
(1)创建顺序表输入函数:void Input(SeqList *L,int n);
(2)创建顺序表输出函数:void Output(SeqList *L);
(3)创建顺序表的内容查找函数:int Locate(SeqList L,ElemType e);
{printf("插入位置不合法\n");
return(ERROR);
}
if(L->last>= MAXSIZE-1)
{printf("表已满无法插入");
return(ERROR);
}
for(k=L->last;k>=i-1;k--) //为插入元素而移动位置
L->elem[k+1]=L->elem[k];
scanf("%d",&m);
DelList(la,m,&num);
printf("删除成功,删除的元素为%d",num);
printf("\n");
Output(la);
}
5.测试数据及结果
实验总结:
经过调试与测试,实验结果与测试预期一致。顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。
#include <stdlib.h>
#include <malloc.h>
#define OK 1
#define ERROR -1
#define TRUE 1
#define FALSE 0
#define ElemType int
#defineMAXSIZE 100 //最大长度
typedef struct
printf("请输入要插入的位置:\n");
scanf("%d",&k);
printf("请输入要插入的元素值:\n");
scanf("%d",&j);
InsList(la,k,j); //调用插入函数
Output(la);
//删除元素 删除第i个元素
printf("请输入需要删除的元素的位置:\n");
{int k;
if((i<1)||(i>L->last+1))
{printf("删除位置不合法!\n");
return(ERROR);
}
*e = L->elem[i-1]; /* 将删除的元素存放到e所指向的变量中*/
for(k=i; k<=L->last; k++)
L->elem[k-1] = L->elem[k]; /*将后面的元素依次前移*/
数据结构顺序表实验报告
洛阳理工学院实验报告
系别
计算机
班级
学号
姓名
课程名称
数据结构
实验日期
10/23
实验名称
顺序表的基本操作
成绩
实验目的:
熟悉掌握线性表顺序存储结构,掌握与应用顺序表的查找、插入、删除等基本操作算法,训练和提高结构化程序设计能力及程序调试能力。
实验条件:
计算机一台,Visual C++6.0
L->elem[i-1]=e; //第i个元素的下标为i-1
L->last++;
return(OK);
}
int DelList(SeqList *L,int i,ElemType *e) //删除函数
/*在顺序表L中删除第i个数据元素,并用指针参数e返回其值。i的合法取值为1≤i≤st+1 */
}
void Output(SeqList *L) //输出函数
{ int i;
for(i=0; i<=L->last; i++)
printf("%2d,",L->elem[i]);
printf("\n");
}
int Locate(SeqList L,ElemType e)//内容查找函数
{int i;
实验内容:
1.问题描述
以顺序表为存储结构实现以下基本操作:
(1)在第i个元素前插入一个新元素。
(2)查找值为x的某个元素。若成功,给出x在表中的位置;不成功给出提示信息。
(3)删除第i个元素,若成功,给出提示信息并显示被删元素的值;不成功给出失败的提示信息。
2.数据结构类型定义
typedef struct
Out请输入要查找的元素值:\n");
scanf("%d",&q);
p=Locate(l,q);
if(p == -1)
printf("在此线性表中没有该元素! \n");
else
printf("该元素在线性表中的位置为:%d \n",p);
//插入元素 (在i处插入元素e)
i=0;
while((i<=st)&&(L.elem[i])!=e)
i++;
if(i<=st)
return(i+1); //返回序号
else
return(-1);
}
int InsList(SeqList *L,int i,ElemType e)//插入数据
{int k;
if((i<1) || (i>L->last+2)) /*首先判断插入位置是否合法*/
{ElemType elem[MAXSIZE];
int last;
}SeqList;
void Input(SeqList *L,int n) //输入函数
{ int i;
printf("请输入线性表的各元素值:\n");
for(i=0; i<n; i++)
scanf("%d",&L->elem[i]);