实验一 线性表的顺序表示和实现
实验一 线性表的顺序表示和实现
实验内容
1.线性表的顺序存储结构
C 语言中的顺序表存储结构描述：
—————线性表的顺序存储结构————————
#define MAXSIZE 100 /*顺序表允许的最大空间量*/
typedef struct
{
ElemType elem[MAXSIZE]; /* ElemType 为抽象数据类型*/
int length; /*当前顺序表长度*/ } SqList;
2.顺序表的基本操作
（1）初始化操作：为顺序表分配一个预定义大小的数组空间，并将线性表的当前长度length 设为0。
（2）清空操作：将顺序表的长度设为0，是表为空表
（3）销毁操作：将顺序表所占用的空间释放
（4）定位操作：根据给定的数据元素e ，在顺序表中找出和e 相等的数据元素的位序，如果这样的数据元
素不存在，则返回0
（5）插入操作：在顺序表的第i 个数据元素前插入一个新的数据元素e ，注意，在插入前必须判断i 的值
域)1)(1(+≤≤L ListLength i ，而在插入操作后必须使顺序表的长度增1.
（6）删除操作：删除顺序表中第i 个数据元素，并且用e 返回其值。
注意，在删除操作前必须判断i 的值
域)1)(1(+≤≤L ListLength i ，而在删除操作后必须使顺序表的长度减1。
（7）输出操作：即将顺序表中各个元素按下标次序输出。
3.顺序表操作实现的操作步骤
（1）实现将顺序表的存储结构和基本操作程序代码。
（2）实现main 主函数。
4.程序代码完整清单
#include <stdio.h>
#include <malloc.h>
#define MaxSize 50 /*顺序表允许的最大空间量*/
typedef char ElemType; /*顺序表中元素类型为char*/
typedef struct
{
ElemType elem[MaxSize];
int length;
} SqList; /*顺序表结构定义 */
//基本操作函数声明
void InitList(SqList *&L); /*初始化线性表*/
void DestroyList(SqList *L); /*销毁线性表*/
int ListEmpty(SqList *L); /*清空线性表*/
int ListLength(SqList *L); /*求表长*/
void DispList(SqList *L); /*输出表*/
int GetElem(SqList *L,int i,ElemType &e); /*取表中元素*/
int LocateElem(SqList *L, ElemType e); /*定位表中元素*/
int ListInsert(SqList *&L,int i,ElemType e); /*插入元素*/
int ListDelete(SqList *&L,int i,ElemType &e); /*删除表中元素*/
void main()
{
SqList *L;
ElemType e;
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);
printf("(7)元素a的位置=%d\n",LocateElem(L,'a'));
printf("(8)在第4个元素位置上插入f元素\n");
ListInsert(L,4,'f');
printf("(9)输出顺序表L:");
DispList(L);
printf("(10)删除L的第3个元素\n");
ListDelete(L,3,e);
printf("(11)输出顺序表L:");
DispList(L);
printf("(12)释放顺序表L\n");
DestroyList(L);
}
void InitList(SqList *&L) /*初始化线性表操作结果：构造一个空的顺序线性表*/ {
L=(SqList *)malloc(sizeof(SqList));
L->length=0;
}
void DestroyList(SqList *L) /*释放线性表操作结果：释放空间*/
{
free(L);
}
int ListEmpty(SqList *L) /*清空线性表操作结果：将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->elem[i]);
printf("\n");
}
int GetElem(SqList *L,int i,ElemType &e) /*取表中元素操作结果：用e返回L中的第i*/ { /*个元素的值*/
if (i<1 || i>L->length)
return 0;
e=L->elem[i-1];
return 1;
}
int LocateElem(SqList *L, ElemType e) /*定位表中元素操作结果：返回L中第1个*/ { /* 与e相等的元素位序*/
int i=0;
while (i<L->length && L->elem[i]!=e) i++;
if (i>=L->length)
return 0;
else
return i+1;
}
int ListInsert(SqList *&L,int i,ElemType e) /*向表中插入元素操作结果：在L 中第i个*/ { /*位置前插入新的数据元素e，L的长度加1*/ int j;
if (i<1 || i>L->length+1)
return 0;
i--; /*将顺序表位序转化为elem下标*/
for (j=L->length;j>i;j--) /*将elem[i]及后面元素后移一个位置*/
L->elem[j]=L->elem[j-1];
L->elem[i]=e;
L->length++; /*顺序表长度增1*/
return 1;
}
int ListDelete(SqList *&L,int i,ElemType &e) /*将表中元素删除操作结果：将L 中第i { /*个位置的元素删除，L的长度减1
int j;
if (i<1 || i>L->length)
return 0;
i--; /*将顺序表位序转化为elem下标*/
e=L->elem[i];
for (j=i;j<L->length-1;j++)
L->elem[j]=L->elem[j+1];
L->length--;
return 1;
}
5. 运行结果清单
(1)初始化顺序表L
(2)依次采用尾插法插入a，b，c，d，e元素
(3)输出顺序表L：abcde
(4)顺序表L长度=5
(5)顺序表L为非空
(6)顺序表L 的第3个元素=c
(7)元素a的位置=1
(8)在第4个元素位置上插入f元素
(9)输出顺序表L：abcfde
(10)删除L的第3个元素
(11)输出顺序表L：abfde
(12)释放顺序表L。
数据结构实验报告-线性表(顺序表实现)
实验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.归并顺序表（销毁或清空操作前）七、思考讨论题或体会或对改进实验的建议通过本次实验，我掌握了定义线性表的顺序存储类型，加深了对顺序存储结构的理解，进一步巩固和理解了顺序表的基本操作，如建立、查找、插入和删除等。
线性表的顺序表示与实现
储存地址 内存状态 b b+L b+(i-1)L b+(n-1)L b+nL a1 a2 ai an
位序 1 2 i n
空 闲
b+(maxlen-1)L
以“存储位置相邻 存储位置相邻”表示有序对<ai-1，ai> 存储位置相邻
即：LOC(ai) = LOC(ai-1) + L
一个数据元素所占存储量↑
a1
a2
a3
a4
a5
a6
a6
一、线性表的顺序表示
• 顺序存储结构是指用一组地址连续的存贮单元依次存储线性表 的元素，通常用数组实现。数组的物理实现是一块连续的存储 空间，它是按首址（表中第1个元素的地址）+位移来访问每一 个元素。
a1 a2 . . . ai-1 ai . . . an-1 an
一维数组按照下标递增的顺序访问表中元素 a[1]→a[2]→……→a[n]
线性表的顺序表示和实现
内容提纲
前期回顾 顺序表的概念及意义 顺序表的算法实现 •表项插入 •表项删除 顺序表优缺点 本节总结
a6
前期回顾
线性表基本概念、 线性表基本概念、基本特征 最简单、 最简单、最常用的数据结构 头结点、尾结点、前驱、 头结点、尾结点、前驱、后继 线性表的基本操作指令 InitList（初始化） DestroyList（销毁） （初始化） （销毁） ListLength（长度） GetElem(取元素 取元素) （长度） 取元素 ListInsert(元素插入 ListDelete(元素删除 等 元素插入) 元素删除)等 元素插入 元素删除
总结
• 线性表的顺序表示、插入和删除的算法 • 教学重点：线性表的顺序表示和实现方法 • 教学难点：线性表的顺序存储算法实现
数据结构实验一线性表的顺序
数据结构实验一线性表的顺序存储结构实验一：线性表的顺序存储结构实验学时：2验证实验类型：、实验目的：1.熟练掌握线性表的基本操作在顺序存储和链式存储上的实现；2.以线性表的各种操作（建立、插入、删除等）的实现为重点；3.掌握线性表的动态分配顺序存储结构的定义和基本操作的实现；二、实验内容：1•输入一组整型数据，建立顺序表。
2•实现该线性表的删除。
3.实现该线性表的插入。
4.实现线性表中数据的显示。
5.实现线性表数据的查找和定位5、编写一个主函数,调试上述算法。
三、实验原理、方法和手段1•根据实验内容编程，上机调试、得出正确的运行程序。
2.编译运行程序，观察运行情况和输出结果3.写出实验报告（包括源程序和运行结果)。
四、实验条件运行Visual C++的微机一台五、实验步骤(程序清单)：(一)、程序代码：#include "stdafx.h"#include <iostream>using namespace std;typedef int elemtype;struct list{elemtype *p;int size;int maxsize;};void buildlist(list &a, int b) /* 建立顺序表*/{if (b<=0){cout« "数据有误"<<endl;}a.p= new elemtype[b];if (a.p==NULL){coutvv "动态可分配的空间用完，退出运行！" vvendl;}a.size=0;a.maxsize=b;}void clearlist(list &a) /* 清空线性表*/{if (a.p!=NULL){delete []a.p;a.p=NULL;}a.maxsize =0;a.size=0;}bool insertlist(list &a, int pos,elemtype b) /*向线性表中按给定的位置插入一个元素*/ int i;if (pos<=0||pos-1>a.size){cout« "位置无效"《endl;return false ;}if (a.maxsize<=a.size){a.p=(elemtype*)realloc(a.p,2*a.maxsize * sizeof (b));a.maxsize=2*a.maxsize;}for ( i=a.size;i>=pos;i--)a.p[i]=a.p[i-1];a.p[i]=b;a.size++;return true ;}bool deletelist(list &a, int pos) /*向线性表中按给定的位置删除一个元素*/{if (a.size==0){coutvv "线性表为空，删除无效！" vvendl;return false ;}if (pos<=0||pos>a.size){coutvv "位置无效"vvendl;return false ;}for (int i=pos-1;iva.size-1;i++)a.p[i]=a.p[i+1];a.size--;if (float (a.size)va.maxsize*0.4&&a.maxsize>10){a.p=(elemtype*)realloc(a.p,a.maxsize*0.5* sizeof (*(a.p)));a.maxsize=a.maxsize*0.5;}return true ;}bool getlist(list a, int pos,elemtype &item) /* 得到线性表中指定位置的元素*/{if (posv=0||pos>a.size){cout« "位置无效"《endl;return false ;} item=a.p[pos-1]; return true ;}int findlist(list a,elemtype b) /*从线性表中查找具有给定值的第个元素*/{for (int i=O;i<a.size;i++)if (a.p[i]==b)return i+1;return 0;}void display(list a) /*线性表中数据的显示*/{coutvv "顺序表元素个数为："vva.size <<endl<< "所占内存单元为："vva.maxsize* sizeof (*(a.p)) <<'字节"vvendlvv"数据为：";for (int i=0;iva.size;i++)coutvva.p[i]vv " ";coutvvendl;}void main(){list L;int i=10;int pos;elemtype a,b,c;buildlist(L,5);for (int j=0;jv10;j++){insertlist(L,j+1,i);i--;}display(L);coutvvendl;coutvv " 一、插入操作："vvendl;coutvv "位置：";cin»pos;coutvv "数据：";cin>>a;if (insertlist(L,pos,a))coutvv "插入成功"vvendl;elsecout« "插入失败"《endl;display(L);cout<<endl;coutvv "二、删除操作："vvendl;coutvv "位置：";cin»pos;if (deletelist(L,pos))coutvv "删除成功"vvendl;elsecoutvv "删除失败"vvendl;display(L);coutvvendl;coutvv "三、定位操作："vvendl;coutvv "位置："；cin»pos;if (getlist(L,pos,b))coutvv "该位置数据为"vvbvvendl;elsecoutvv "定位失败"vvendl;coutvv "四、查找操作："vvendl;coutvv "数据：";cin>>c;if (findlist(L,c))coutvv "线性表中第一个等于该数据的位置为"vvfindlist(L,c)vvendl;elsecoutvv "线性表中没有等于该数据的元素"vvendl;clearlist(L);}(二)、程序运行结果六、实验分析与总结：通过本次实验，我发现了自己身上很多的不足：1•不知道什么时候才需要将函数的返回类型弄成bool类型；2•在编写函数体的时候，对排除非法情况考虑不周；3•对申请、追加及删除动态空间的语法不熟悉；4.没有思路对算法进行优化，例如，不知道怎样将所申请的动态空间适当缩小或放大。
数据结构实验研究报告线性表的顺序表示和实现
纟眇理工数学与计算科学学院实验报告实验项目名称：线性表的顺序表示和实现所属课程名称：数据结构A _________________实验类型：验证性________________________实验日期： _______班级：_________学号：—201044070218 _________姓名：_______ 张松涛_______________成绩：_____________________________、实验概述:【实验目的】(1)、线性表的逻辑结构特征。
①、总存在第一个和最后一个元素。
②、除第一个元素以外，每一个元素总存在唯一一个直接前驱元素。
③、除最后一个元素以外，每一个元素总存在唯一一个直接后驱元素。
⑵、顺序表的特征。
①、逻辑关系上相邻的物理位置上也相邻。
②、是一种随机存储结构，可以用一个简单直观的公式来表示每一个元素的地址。
(3)学会定义线性表的顺序存储类型，实现C程序的基本结构，对线性表的一些基本操作和具体的函数定义。
掌握顺序表的基本操作，实现顺序表的插入、删除、查找以及求并集等运算。
【实验原理】//——线性表的动态分配顺序存储结构--------------#defi ne LIST_INIT_SIZE 5 // 线性表存储空间的初始分配量#defi ne LISTINCREMENT 2 // 线性表存储空间的分配增量Typedef struct{ElemType *elem; // 存储空间基址int len gth; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)}SqList;【实验环境】实验的环境：VC++、实验内容:【实验方案】编写主函数，调用初始化，建立顺序表的算法以及插入和删除算法。
调试运行输入数据得出结果并进行分析【实验过程】（实验步骤、记录、数据、分析）|叶《4* IHOt 1KOHl* fHl lf fl■tfer—«K li ■TT ST f RR«H nIKf KIBtf -1 i nr Sr ittif;apt K]t^pii ippr]utfiM u(r_inn_iiff，"删農存侶阿的杓站寸生量ITETHKfiTHFNT IQFwMpp*理)帼・：l*t l^njth■ill llwiliK；&u_)(•SUflllflCd-EST IHIT (FlfBlJIir) | ；iJ--4fl.rim) e<it(4MEflFLW|;LL .li«t5L7P=l.] £1 IINI I SIZE :[tltllst 耐tirntfiiD- vn«-tft K<I?, ip, "q ：14 IIT Li^t U i a F1 ml yipr r J(1 F J -j f 4 II I'M lflMfl-fc-ii-Vl wbihrn fERM ・SiltlMi L LSI Ht 亂丿诉I*)41K1<1 11 ) rrtuim tRHBR;a 1194KliKt)<*«5«-俺]材加昶*)r »] )aa(L .#1 f L . ].lS(Si?e*L 1ST IMWMFHT ZP»f 4 EleRTyp* })if( tnii^dtwjiektt ・>:|| rll5tSiEe*-Ll$ I J HCfltKHI $k. elwuLL ..lrkg< ■"Wnr卜巩u ;+ "-L. Lr nr|C.h ；(MIE tt|:StitU% L"II#亍林•—聲(骑Ll钊U^ltt L.11 PHI v|itIFKKI) II 舁乳7"*4"和『HU阳EKIDI：pW 叭呵i- 1J>^q・L ■•丄w-L ilff*g|l.k-li―.Ipruft h;milrti}/vi 丸valid VU I H C)IE" uItiK1;I «r((surtff 'Ur .U ,eke«(f )p; L .>PFiintrr'td w»i|T imwr f;网■，刮.b); LisHlrH-rr t_En(L 4l H.rj;f<jp| 1»*;1 (f.叶枇.31«■> printF<"1bri MB, *(1 ;■dm刊rm；, 1 ,»)；.priRtF4>!%4 ;将源程序输入VC6.0Lk卄LrL-Unll||UF**l(*； 1 -灯#2 弁----------------- -- --- —----- “tMipELlni .・< Mri xelUnyi^difebiiijfti^lti'M .uptf l^fYlrrv 版IM煮■UiriEAft丄*科ItfHtiHfr^-：\dKurmts- ±nd ictLinqs'iiKtaLnlstj'jtiM'XI上z mrnr CSBK: "EEt*R" ; ukfccl-H-rd adMllfirr lErrir rkrcti^l>g Ci^nr^iLnhj ・1 err writ),. ■发现有OVERFLOW : undeclared identifier ，错误，是没有定义导致加入宏替换定义OVERFLOW1^™-™-=-=-"=-=^^——-C»nfi|UFitii*3 1 - ■i«32i Ir眄l h•打i»1 .£ibj -・Mr甘忖F ■ji编译之后没有发现语法错误-»"-■■■■■-- ----- l^urKluiiia ii - trtn3£■ -■ ■»»w«Liifting __1 - tie - ■ rnrurts) B• wriaikf(和连接没问题，直接运行【实验结论】（结果）【实验小结】（收获体会）1. 实验要细心，认真。
顺序表的顺序表示和实现
顺序表的顺序表⽰和实现⼀.线性表的顺序表⽰的概念：⽤⼀组地址连续的存储单元依次存储线性表的数据元素。
1.线性表中的第i+1个元素的存储位置LOC(a[i+1]) 与第i个元素的存储位置LOC(a[i])之间的关系为：LOC(a[i+1]) = LOC(a[i])+n;n表⽰每个元素元素占⽤n个存储单元。
⼆.线性表的基本操作1.线性表的动态分配顺序存储结构#include<stdio.h>#include<stdlib.h>#define LIST_SIZE 20 //初始容量20#define INCREAMENT 10//每次扩容10#define ERROR 0#define OK 1typedef int elemType;typedef int Status;typedef struct{elemType *elems; //存储空间基址int length; //当前元素个数int listsize; //总容量}SqList;2.初始化线性表//构造⼀个空的顺序表Status initList(SqList &L){L.elems = (elemType *)malloc(LIST_SIZE*sizeof(elemType));if(!L.elems)return ERROR;//存储分配失败L.length=0; //长度为0L.listsize=LIST_SIZE;//容量为初始容量return OK;}3.插⼊元素需将插⼊位置之后的元素依次后移⼀个位置。
//在index位置插⼊元素eStatus insert(SqList &L,int index,int e){if(index<1||index>L.length+1)return ERROR;//插⼊位置不合法if(L.length==L.listsize){elemType *newbase = (elemType*)realloc(L.elems,(L.listsize+INCREAMENT)*sizeof(elemType));if(!newbase)return ERROR;L.elems=newbase;L.listsize = L.listsize+INCREAMENT;}elemType* loc = &(L.elems[index-1]); //要插⼊的位置for(int i=L.length-1;i>=index-1;i--){L.elems[i+1]=L.elems[i];}/*与上⾯效果相同for(int *p=&(L.elems[L.length-1]);p>=loc;p--){*(p+1)=*p;}*/*loc = e;L.length++;return OK;}//在末尾插⼊元素eStatus add(SqList &L,elemType e){return insert(L,L.length+1,e);}4.删除元素需将删除位置之后的元素依次向前移动⼀个位置。
数据结构实验一-线性表
数据结构实验⼀-线性表实验⼀线性表⼀、实验⽬的1、深刻理解线性结构的特点，以及在计算机内的两种存储结构。
2、熟练掌握线性表的顺序存储结构和链式存储结构，及其它们的基本操作，重点掌握查找、插⼊和删除等操作。
⼆、实验要求1、认真阅读程序，将未完成的代码补全（红⾊部分）。
2、上机调试，并运⾏程序。
3、保存和截图程序的运⾏结果，并结合程序进⾏分析。
三、实验内容和基本原理1、实验1.1 顺序表的操作利⽤顺序表存储⽅式实现下列功能（见参考程序1）：1）通过键盘输⼊数据建⽴⼀个线性表，并输出该线性表。
如，依次输⼊元素25,21,46,90,12,98。
2）根据屏幕菜单的选择，进⾏数据的插⼊、删除和查找，并在插⼊或删除数据后，再输出线性表。
如，在第2个位置上插⼊元素43，然后输出顺序表。
删除顺序表第4个元素，输出改变的顺序表。
3）在屏幕菜单中选择0，结束程序的运⾏。
基本原理：在顺序表的第i个位置上插⼊⼀个元素时，必须先将线性表的第i个元素之后的所有元素依次后移⼀个位置，以便腾空⼀个位置，在把新元素插⼊到该位置。
当要删除第i个元素时，只需将第i个元素之后的所有元素前移⼀个位置。
程序代码（蓝⾊为补充的语句）：//* * * * * * * * * * * * * * * * * * * * * * * *//*PROGRAM :顺序结构的线性表 *//*CONTENT :建⽴,插⼊,删除,查找 *//*编程语⾔： Visual c++ 6.0 *//* * * * * * * * * * * * * * * * * * * * * *#include#include#define MAXSIZE 20typedef int ElemType; //数据元素的类型typedef struct{ElemType a[MAXSIZE];int length;}SqList; //顺序存储的结构体类型SqList a,b,c;//函数声明void creat_list(SqList *L);void out_list(SqList L);void insert_sq(SqList *L,int i,ElemType e); ElemType delete_sq(SqList *L,int i);int locat_sq(SqList L,ElemType e);//主函数void main(){int i,k,loc;ElemType e,x;char ch;do {printf("\n\n\n");printf("\n 吴肖遥20151681310131");printf("\n 1.建⽴线性表");printf("\n 2.插⼊元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运⾏");printf("\n =====================");printf("\n 请输⼊要执⾏的操作: ");scanf("%d",&k);switch(k){case 1:{creat_list(&a);out_list(a);}break;case 2:{printf("\n请输⼊插⼊位置： ",a.length+1); scanf("%d",&i);printf("请输⼊要插⼊的元素值： ");scanf("%d",&e);insert_sq(&a,i,e);out_list(a);}break;case 3:{printf("\n请输⼊要删除元素的位置： ",a.length); scanf("%d",&i);x=delete_sq(&a,i);out_list(a);if(x!=-1)printf("\n删除的元素为：%d\n",x);else printf("要删除的元素不存在！");}break;case 4:{printf("\n请输⼊要查找的元素值：");scanf("%d",&e);loc=locat_sq(a,e);if(loc==-1)printf("\n未找到指定元素！");elseprintf("\n已找到，元素的位置是: %d ",loc);}break;}/*switch*/}while(k!=0);printf("\n 按回车键，返回...\n");ch=getchar();}/*main*///建⽴线性表void creat_list(SqList *L){int i;printf("请输⼊线性表的长度: ");scanf("%d",&L->length);for(i=0;ilength;i++){printf("数据 %d =",i);scanf("%d",&(L->a[i]));}}//输出线性表void out_list(SqList L){int i;for(i=0;i<=L.length-1;i++)printf("%10d",L.a[i]);}//在线性表的第i个位置插⼊元素evoid insert_sq(SqList *L,int i,ElemType e){int j;if(L->length==MAXSIZE)printf("线性表已满!\n");else {if(i<1||i>L->length+1)printf("输⼊位置错!\n");else {for(j=L->length-1;j>=i-1;j--)L->a[j+1]=L->a[j];L->a[j+1]=e;/*将未完成的代码补全,提⽰：此处添加⼀条语句，将被删除的元素值赋给e*/ L->length++;}}}//删除第i个元素，返回其值ElemType delete_sq(SqList *L,int i){ElemType x;int j;if(L->length==0)printf("空表!\n");else if(i<1||i>L->length){printf("输⼊位置错！\n");x=-1;}else{x=L->a[i-1];for(j=i;j<=L->length-1;j++)L->a[j-1]=L->a[j];/*将未完成的代码补全,提⽰：此处添加⼀条语句，将被删除元素之后的元素左移。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程，通过本次实验，旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。
具体目的包括：1、熟练掌握线性表（如顺序表、链表）的基本操作，如插入、删除、查找等。
2、理解栈和队列的特性，并能够实现其基本操作。
3、掌握树（二叉树、二叉搜索树）的遍历算法和基本操作。
4、学会使用图的数据结构，并实现图的遍历和相关算法。
二、实验环境本次实验使用的编程环境为具体编程环境名称，编程语言为具体编程语言名称。
三、实验内容及步骤（一）线性表的实现与操作1、顺序表的实现定义顺序表的数据结构，包括数组和表的长度等。
实现顺序表的初始化、插入、删除和查找操作。
2、链表的实现定义链表的节点结构，包含数据域和指针域。
实现链表的创建、插入、删除和查找操作。
（二）栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。
实现栈的入栈、出栈和栈顶元素获取操作。
2、队列的实现采用循环队列的方式实现队列的数据结构。
完成队列的入队、出队和队头队尾元素获取操作。
（三）树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。
2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。
3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。
（四）图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
四、实验结果与分析（一）线性表1、顺序表插入操作在表尾进行时效率较高，在表头或中间位置插入时需要移动大量元素，时间复杂度较高。
删除操作同理，在表尾删除效率高，在表头或中间删除需要移动元素。
2、链表插入和删除操作只需修改指针，时间复杂度较低，但查找操作需要遍历链表，效率相对较低。
（二）栈和队列1、栈栈的特点是先进后出，适用于函数调用、表达式求值等场景。
入栈和出栈操作的时间复杂度均为 O(1)。
2、队列队列的特点是先进先出，常用于排队、任务调度等场景。
实习01_线性表的顺序存储和操作(有序表的合并)
实验一线性表的顺序存储和操作(有序表的合并)1.目的用顺序表(SqList)类型实现书上算法2.1和2.2,了解线性表及在计算机中的两类不同的存储结构;熟练掌握线性表的查找、插入和删除等算法并灵活运用这些算法。
2.要求用C语言编写程序,其中Lb={2,4,6,8,10} La={1,2,3,4,5},①算法2.1执行后,得到的new La = 1,2,3,4,5,6,8,10②修改Lb=2,6,8,9,11,15,20,并利用新生成的La,得到合并后的Lc,Lc= 1,2,2,3,4,5,6,6,8,8,9,10,11,15,203、预习要求:1、复习书上第20页的例2-1和例2-2;2、复习算法2.3,理解如何构造线性表;3、复习算法2.7,理解算法的执行步骤和含义;4、项目介绍:前面的课程已经学习了如何用C语言描述顺序表、如何初始化顺序表、以及如何在顺序表中插入和删除数据元素。
现在通过两个顺序表的合并的实验,加深对顺序表的理解,熟悉如何将逻辑上的数学模型转化为计算机能够理解的指令代码。
该实验是数据结构课程的第一个实验,实验的目标除了加深理解课堂内容外,还对学生的动手能力提出了更高的要求,锻炼学生动手的能力。
5、算法设计#include <stdio.h>#include <stdlib.h>#include <malloc.h># define TRUE 1# define ERROR 0# define OK 1# define OVERFLOW -2# define FALSE 0# define LIST_INIT_SIZE 10# define LISTINCREMENT 5void main(){List La,Lb,Lc;int j,b[7]={2,6,8,9,11,15,20};InitList(La); // 创建空表La。
如不成功,则会退出程序的运行for(j=1;j<=5;j++) // 在表La中插入5个元素,依次为1、2、3、4、5 ListInsert(La,j,j);printf("La= ");ListTraverse(La,printer); // 输出表La的内容InitList(Lb); // 创建空表Lbfor(j=1;j<=5;j++) // 在表Lb中插入5个元素,依次为2、4、6、8、10 ListInsert(Lb,j,2*j);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容Union(La,Lb); // 调用算法2.1,将Lb中满足条件的元素插入La(不改变Lb) printf("new La= ");ListTraverse(La,printer); // 输出新表La的内容ClearList(Lb); // 清空表Lbfor(j=1;j<=7;j++) // 在表Lb中重新依次插入数组b[]的7个元素ListInsert(Lb,j,b[j-1]);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容MergeList(La,Lb,Lc); // 调用算法2.2,生成新表Lc(不改变表La和表Lb)printf("Lc= ");ListTraverse(Lc,printer); // 输出表Lc的内容}6.小结线性表是软件设计中最基础的数据结构。
实验1 线性表的顺序表示和实现
实验1 线性表的顺序表示和实现
1．实验目的
（1）熟练掌握线性表的基本操作在顺序存储结构上的实现。
（2）用线性表的操作实现表的合并。
2.实验内容
（1）要求用顺序存储结构实现线性表。
然后实现如下操作：
✧初始化线性表
✧建立一个含n个数据的线性表
✧查找：输入一个数，查找线性表，若有，则输出“查找成功”，否则输出
“无此数”。
✧插入：输入一个数和插入位置，实现插入操作，并显示插入成功。
✧删除：输入一个位置数，删除该位置上的数，并显示删除成功。
（2）线性表的合并，已知两个升序线性表，要求合并成一个新的升序线性表。
3．实验要求
（1）上机前编写实验源程序（要求手写,不允许打印），上机前老师检查，没有预先编写实验程序的同学不允许上实验课，按旷课一次处理。
旷课次数超过2次的同学实验成绩不及格，且没有补考资格。
（2）用一切你能想到的办法解决遇到的问题，培养解决问题的能力。
（3）实验报告（于下次实验时交）
报告内容包括：实验目的、实验内容、实验代码、实验输入输出结果以及实验体会供五部分。
线性表的动态分配顺序存储结构如下：
#define LIST_INIT_SIZE 100;//存储空间初始分配量
#define LISTINCREMENT 10;//存储空间分配增量
typedef struct{
ElemType *elem;//存储空间基址
int length; //当前长度
int listsize;//当前已经分配的存储空间，以sizeof(ElemType)为单位
}SqList;。
实验报告.线性表的顺序表示和实现
return OK;
}
void main()
{Sqlist L; int i; InitList_Sq(L); //构造一个空的线性表L
for (i=0;i<L.listsize;i++)
{scanf("%d",&L.elem[i]);
++L.length;}//输入数据
if(!L.elem) exit(OVERFLOW); //存储分配失败
L.length=0; //空表长度为0
L.listsize=LIST_INIT_SIZE; //初始存储容量
return OK;
}
Status ListInsert_Sq(Sqlist &L,int i, ElemType e){
for(i=0;i<L.listsize;i++)printf("%d ",*(L.elem+i));
//输出表中的数据
printf("\n");
ElemType e;scanf("%d""%d",&i,&e);
ListInsert_Sq(L,i,e);
//在线性表L中第i个元素之前插入元素e
for(i=0;i<L.length;i++)
要不然就会出现很多错误，得不到自己想要的结果。
第二点：要熟练的掌握有关C语言的知识，要充分明白算法与程序的区别，在
编写程序的过程中要保持清醒的头脑，时刻注意那些容易出错的地
方。
第三点：每次进行删除算法之后表长都要减一。否则会造成数据冗余，浪费