数据结构作业线性表的顺序实现
数据结构 线性表
第1讲线性表本章主要掌握如下内容：线性表的定义和基本操作，线性表的实现,线性表的顺序存储结构及链式存储结构，线性表的应用。
知识点分析（一）线性表的定义和基本操作1．线性表基本概念1）定义：是由相同类型的结点组成的有限序列。
如：由n个结点组成的线性表（a1, a2, …, a n）a1是最前结点，a n是最后结点。
结点也称为数据元素或者记录。
2）线性表的长度：线性表中结点的个数称为其长度。
长度为0的线性表称为空表。
3）结点之间的关系：设线性表记为（a1,a2,…a i-1 , a i, a i+1 ,…a n），称a i-1是a i的直接前驱结点．．．．（简称前驱），a i+1是a i的直接后继结点．．．．（简称后继）。
4）线性表的性质：①线性表结点间的相对位置是固定．．的，结点间的关系由结点在表中的位置确定。
②如果两个线性表有相同的数据结点，但它们的结点顺序不一致，该两个线性表也是不相等的。
注意：线性表中结点的类型可以是任何数据（包括简单类型和复杂类型），即结点可以有多个成分，其中能唯一标识表元的成分称为关键字（key），或简称键。
以后的讨论都只考虑键，而忽略其它成分，这样有利于把握主要问题，便于理解。
『经典例题解析』线性表的特点是每个元素都有一个前驱和一个后继。
( )【答案】错误。
【解析】线性表的第一个数据元素没有前驱，最后一个元素没有后继。
其余的所有元素都有一个前驱和后继。
2．线性表的抽象数据类型线性表是一个相当灵活的数据结构，其长度可以根据需要增加或减少。
从操作上讲，用户不仅可以对线性表的数据元素进行访问操作，还可以进行插入、删除、定位等操作。
1）线性表的基本操作假设线性表L有数据对象 D＝{ai | ai∈ElemSet，i=1,2,3,…,n，n>=0},数据元素之间的关系R＝{<ai-1,ai>|ai-1,ai∈D,i=1,2,…,n},则线性表L的基本操作如下所示：●InitList(&L)：其作用是构造一个长度为0的线性表（空线性表）；●DestoryList(&L)：其作用是销毁当前的线性表L；●ClearList(&L)：清空线性表L，使之成为空表；●ListLength(L)：返回线性表L的长度，即线性表中数据元素的个数；●ListEmpty(L) ：判断线性表L是否为空表，是则返回True，否则返回False；●GetElem(L,i,&e)：将线性表L中第i个数据元素的值返回到变量e中；●LocateELem(L,e,compare( )) ：判断线性表L中是否存在与e满足compare（）条件的数据元素，有则返回第一个数据元素；●PriorElem(L,cur_e,&pri_e)：返回线性表L中数据元素cur_e的前驱结点；●NextElem(L,cur_e,&next_e)：返回线性表L中数据元素cur_e的后继结点；●ListInsert(&L,i,e)：向线性表L的第i个位置之前插入一个数据元素，其值为e；●ListDelete(&L,i,&e)：删除线性表L的第i个数据元素，并将该数据元素的值返回到e中；●ListTraverse(L,visit())：遍历线性表中的每个数据元素。
数据结构实验报告-线性表(顺序表实现)
实验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.归并顺序表（销毁或清空操作前）七、思考讨论题或体会或对改进实验的建议通过本次实验，我掌握了定义线性表的顺序存储类型，加深了对顺序存储结构的理解，进一步巩固和理解了顺序表的基本操作，如建立、查找、插入和删除等。
数据结构实验报告-实验：1线性表的顺序存储和操作实现
}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空，即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度："+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);
数据结构与算法——顺序表的实现及原理
数据结构与算法——顺序表的实现及原理1. 顺序表的原理以及实现:1.1 什么是顺序表：顺序表是在计算机内存中以数组的形式保存的线性表，顺序表是简单的⼀种线性结构，逻辑上相邻的数据在计算机内的存储位置也是相邻的，可以快速定位第⼏个元素，中间不允许有空值，插⼊、删除时需要移动⼤量元素。
1.2 什么是线性表：线性表是从逻辑结构的⾓度来说的，除了头和尾之外，它的每⼀个元素都只有⼀个前驱元素和⼀个后驱元素。
各种队列（单向、双向、循环队列），栈等都是线性表的不同例⼦。
⽽本⽂题⽬的顺序表也是线性表的⼀种。
1.3 顺序表与链表的区别：⾸先，顺序表与链表均属于线性表，只是在逻辑结构和存储⽅式上有所不同。
顺序表：线性表采⽤顺序存储的⽅式存储就称之为顺序表，顺序表是将表中的结点依次存放在计算机内存中⼀组地址连续的存储单元中。
链表：线性表采⽤指针链接的⽅式存储就称之为链表。
1.4 线性表与数组的区别：线性表是从逻辑结构的⾓度来说的，⽽数组是从物理存贮的⾓度来说的，线性表可以⽤数组存贮也可以⽤链表来存贮。
同样的队列和栈也可以⽤数组和链表存贮，各有利弊。
根据具体情况灵活选择。
在C语⾔中，数组长度不可变，线性表长度是动态可变的。
1.5 顺序表的三个要素：⽤elems 记录存储位置的基地址分配⼀段连续的存储空间size⽤length 记录实际的元素个数，即顺序表的长度结构体定义#define MAX_SIZE 100struct _SqList{ElemType *elems; // 顺序表的基地址int length; // 顺序表的长度int size; // 顺序表总的空间⼤⼩}顺序表的初始化1#define MAX_SIZE 1002 typedef struct3 {4int* elems; // 顺序表的基地址5int length; // 顺序表的长度6int size; // 顺序表的空间7 }SqList;89bool initList(SqList& L) //构造⼀个空的顺序表L10 {11 L.elems = new int[MAX_SIZE]; //为顺序表分配Maxsize 个空间12if (!L.elems) return false; //存储分配失败13 L.length = 0; //空表长度为014 L.size = MAX_SIZE;15return true;16 }2. 顺序表添加元素:1bool listAppend(SqList &L, int e)2 {3 if(L.length==MAX_SIZE) return false; //存储空间已满4 L.elems[L.length] = e;5 L.length++; //表长增16 return true;7 }3. 顺序表插⼊元素1bool listInsert(SqList& L, int i, int e)2 {3if (i < 0 || i >= L.length)return false; //i 值不合法4if (L.length == MAX_SIZE) return false; //存储空间已满56for (int j = L.length - 1; j >= i; j--)7 {8 L.elems[j + 1] = L.elems[j]; //从最后⼀个元素开始后移，直到第i 个元素后移9 }1011 L.elems[i] = e; //将新元素e 放⼊第i 个位置12 L.length++; //表长增11314return true;15 }4. 顺序表删除元素1bool listDelete(SqList& L, int i)2 {3if (i < 0 || i >= L.length) return false; //不合法4if (i == L.length - 1) //删除最后⼀个元素，直接删除5 {6 L.length--;7return true;8 }9for (int j = i; j < L.length - 1; j++)10 {11 L.elems[j] = L.elems[j + 1]; //被删除元素之后的元素前移12 }13 L.length--;1415return true;16 }5. 顺序表销毁1void destroyList(SqList& L)2 {3if (L.elems) delete[]L.elems; //释放存储空间4 L.length = 0;5 L.size = 0;6 }6. 完整实现1 #include <iostream>23using namespace std;4#define MAX_SIZE 10056 typedef struct7 {8int* elems; // 顺序表的基地址9int length; // 顺序表的长度10int size; // 顺序表的空间11 }SqList;1213bool initList(SqList& L) //构造⼀个空的顺序表L14 {15 L.elems = new int[MAX_SIZE]; //为顺序表分配Maxsize 个空间 16if (!L.elems) return false; //存储分配失败17 L.length = 0; //空表长度为018 L.size = MAX_SIZE;19return true;20 }2122/*23bool getElem(SqList &L,int i,int &e)26if (i<1||i>L.length) return false;27e=L.elems[i-1]; //第i-1 的单元存储着第i 个数据28return true;29}30*/3132bool listAppend(SqList& L, int e)33 {34if (L.length == MAX_SIZE) return false; //存储空间已8满97943840111135 L.elems[L.length] = e;36 L.length++; //表长增137return true;38 }3940bool listInsert(SqList & L, int i, int e)41 {42if (i < 0 || i >= L.length)return false; //i 值不合法43if (L.length == MAX_SIZE) return false; //存储空间已满44for (int j = L.length - 1; j >= i; j--)45 {46 L.elems[j + 1] = L.elems[j]; //从最后⼀个元素开始后移，直到第i 个元素后移47 }48 L.elems[i] = e; //将新元素e 放⼊第i 个位置49 L.length++; //表长增150return true;51 }5253bool listDelete(SqList & L, int i)54 {55if (i < 0 || i >= L.length) return false; //不合法56if (i == L.length - 1) //删除最后⼀个元素，直接删除57 {58 L.length--;59return true;60 }61for (int j = i; j < L.length - 1; j++)62 {63 L.elems[j] = L.elems[j + 1]; //被删除元素之后的元素前移64 }65 L.length--;66return true;67 }6869void listPrint(SqList & L)70 {71 cout << "顺序表元素size: " << L.size << ", 已保存元素个数length: " << L.length << endl; 72for (int j = 0; j <= L.length - 1; j++)73 {74 cout << L.elems[j] << "";75 }76 cout << endl;77 }7879void destroyList(SqList & L)80 {81if (L.elems) delete[]L.elems;//释放存储空间82 L.length = 0;83 L.size = 0;84 }8586int main()87 {88 SqList list;89int i, e;9091 cout << "顺序表初始化..." << endl;92//1. 初始化93if (initList(list)) {94 cout << "顺序表初始化成功！" << endl;95 }9697//2. 添加元素98int count = 0;99 cout << "请输⼊要添加的元素个数：";100 cin >> count;101for (int i = 0; i < count; i++) {102 cout << "\n 请输⼊要添加元素e:";103 cin >> e;104if (listAppend(list, e)) {105 cout << "添加成功！" << endl;106 }107else {108 cout << "添加失败！" << endl;109 }110 }111112 listPrint(list);115 cout << "请输⼊要插⼊的位置和要插⼊的数据元素e:";116 cin >> i >> e;117if (listInsert(list, i, e)) {118 cout << "插⼊成功！" << endl;119 }120else {121 cout << "插⼊失败！" << endl;122 }123124 listPrint(list);125126//4. 删除元素127 cout << "请输⼊要删除的位置i:";128 cin >> i;129if (listDelete(list, i)) {130 cout << " 删除成功！" << endl;131 }132else {133 cout << "删除失败！" << endl;134 }135136 listPrint(list);137138//5. 销毁139 cout << "顺序表销毁..." << endl;140 destroyList(list);141 system("pause");142return0;143 }7. 企业级应⽤案例⾼并发WEB 服务器中顺序表的应⽤⾼性能的web 服务器Squid 每秒可处理上万并发的请求，从⽹络连接到服务器的客户端与服务器端在交互时会保持⼀种会话（和电话通话的场景类似）。
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一，它是一种有序的数据元素集合，其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式，其中顺序存储结构是最简单的一种，它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素，但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现，数组的长度应该大于等于线性表的长度，以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时，需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作：________在指定位置插入一个元素时，需要将插入位置之后的元素依次后移，给待插入的元素腾出位置。
●删除操作：________删除指定位置的元素时，需要将删除位置之后的元素依次前移，覆盖删除位置上的元素。
●修改操作：________修改指定位置的元素时，直接对该位置上的元素进行修改即可。
●查找操作：________根据指定的元素值，查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素，可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点：________可以快速地访问任意位置的元素，节省存储空间。
2.缺点：________插入和删除操作需要移动大量的元素，不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中，我们以顺序存储结构为基础，实现了线性表的增删改查操作，并进行了遍历操作。
通过实验，我们发现顺序存储结构在查询操作上有较好的性能，但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
数据结构(线性表)习题与答案
数据结构(线性表)习题与答案数据结构(线性表)习题与答案1. 线性表的定义线性表是一种常用的数据结构，它由一系列元素组成，并且每个元素具有前驱和后继关系。
线性表可以通过顺序存储或链式存储来实现。
2. 线性表的实现方式2.1 顺序存储顺序存储是利用数组来实现线性表的一种方式。
数组的每个元素可以存储一个数据项，通过下标可以快速访问和操作其中的元素。
2.2 链式存储链式存储是通过节点之间的指针关联来实现线性表的一种方式。
每个节点包含数据域和指针域，指针域指向下一个节点。
3. 线性表的基本操作3.1 初始化线性表初始化线性表需要给表头节点分配内存空间，并将头节点的指针域置为空。
3.2 插入元素在线性表的某个位置插入元素，需要先找到插入位置的前一个节点，然后将新节点插入到该位置。
调整节点之间的指针关联即可完成插入操作。
3.3 删除元素删除线性表中的某个元素，需要找到待删除元素的前一个节点，然后将该节点的指针指向待删除节点的下一个节点，释放待删除节点的内存空间即可。
3.4 查找元素查找线性表中某个元素的位置，可以从表头节点开始逐个比较节点的数据域，直到找到目标元素或者遍历结束。
4. 线性表的习题与答案4.1 习题1已知线性表L中的元素按非递减顺序排列，设计一个算法，将元素x插入到L中，保持L的有序性。
解答：1) 从表头节点开始，顺序遍历节点的数据域，找到第一个大于等于x的节点的前一个节点，记为p。
2) 创建新的节点node，将x赋值给node的数据域。
3) 将node的指针域指向p的下一个节点。
4) 将p的指针域指向node。
5) 插入完成。
4.2 习题2已知线性表L中的元素按递减顺序排列，设计一个算法，删除L中所有大于x的元素。
解答：1) 从表头节点开始，顺序遍历节点的数据域，找到第一个小于等于x的节点的前一个节点，记为p。
2) 将p的指针域指向p的下一个节点，删除p的后继节点。
3) 重复执行步骤2，直到遍历结束。
数据结构实验一线性表及其应用
实验一线性表及其应用一、实验目的1.熟悉C语言的上机环境，进一步掌握C语言的构造特点。
2.掌握线性表的顺序存储构造的定义及C语言实现。
3.掌握线性表的链式存储构造——单链表的定义及C语言实现。
4.掌握线性表在顺序存储构造即顺序表中的各种根本操作。
5.掌握线性表在链式存储构造——单链表中的各种根本操作。
二、实验容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插入元素68。
3.建立一个带头结点的单链表，结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、实现提示1.由于C语言的数组类型也有随机存取的特点，一维数组的机表示就是顺序构造。
因此，可用C语言的一维数组实现线性表的顺序存储。
在此，我们利用C语言的构造体类型定义顺序表：#define MAXSIZE 1024typedef int elemtype; /* 线性表中存放整型元素*/typedef struct{ elemtype vec[MAXSIZE];int len; /* 顺序表的长度*/}sequenlist;将此构造定义放在一个头文件sqlist.h里，可防止在后面的参考程序中代码重复书写，另外在该头文件里给出顺序表的建立及常量的定义。
2. 注意如何取到第i个元素，在插入过程中注意溢出情况以及数组的下标与位序〔顺序表中元素的次序〕的区别。
3.单链表的结点构造除数据域外，还含有一个指针域。
用C语言描述结点构造如下：typedef int elemtype;typedef struct node{ elemtype data; //数据域struct node *next; //指针域}linklist;注意结点的建立方法及构造新结点时指针的变化。
数据结构实验指导书-线性表的操作
数据结构实验指导书-线性表的操作实验1线性表的基本操作一、实验目的(1)掌握线性表的逻辑特征；(2)掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算；(3)熟练掌握线性表的链式存储结构定义及基本操作；(4)理解循环链表和双链表的特点和基本运算；(5)加深对顺序存储数据结构的理解和链式存储数据结构的理解，逐步培养解决实际问题的编程能力；二、实验内容1、创建有若干个元素（可以是整型数值）的顺序表，实现对顺序表的初始化，对已建立的顺序表插入操作、删除操作、遍历输出顺序表。
要求各个操作均以函数的形式实现，在主函数中调用各个函数实现以下操作：（1）从键盘上依次输入21、18、30、75、42、56，创建顺序表，并输出顺序表中的各元素值。
（2）分别在单链表的第3个位置插入67，给出插入成功或失败的信息，并输出此时顺序表中的各元素值。
（3）删除顺序表中的第6个数据元素，给出删除成功或失败的信息，并输出此时顺序表中的各元素值。
（4）查找顺序表中是否有75这个元素，如果有返回该元素在顺序表中的位序。
2、创建有若干个元素（可以是整型数值）的单链表，实现对单链表的初始化，对已建立的顺序表插入操作、删除操作、查找操作、遍历输出单链表表。
要求各个操作均以函数的形式实现，在主函数中调用各个函数实现以下操作：（1）从键盘上依次输入21、18、30、75、42、56，创建单链表，并输出单链表中的各元素值。
（2）分别在单链表的第4个位置，给出插入成功或失败的信息，并输出单链表中的各元素值。
（3）删除单链表中的第2个数据元素，给出删除成功或失败的信息，并输出单链表中的各元素值。
（4）查找顺序表中的第五个元素并输出该元素的值。
三、参考代码(1)顺序表的操作#include#include#defineTRUE1#defineFALSE0#defineOK1#defineERROR0#defineOVERFLOW-2typedefintStatu;#defineINIT_SIZE100/某初始分配空间的大小某/#defineLISTINCREMENT10/某分配增量某/typedefintElemType;typedeftruct{ElemType某elem;intlength;intlitize;}SqLit;/某ElemTypeelem[INIT_SIZE],注两者区别。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
线形表的顺序实现一、目的与要求实现线性表的基本操作，并且用数据测试。
二、方案// 顺序表的实现.cpp : Defines the entry point for the console application.#include"iostream"#include"stdlib.h"#include"stdio.h"using namespace std;typedef int ElemType;typedef int Status;#define List_Init_Size 100//线性表存储空间的初始分配量#define List_Increment 10//线性表存储空间的分配增量struct Sqlist{int *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量（以sizeof(ElemType)为单位）};void InitList(Sqlist &L)//构造一个空的顺序线性表L{L.elem=( ElemType*)malloc(List_Init_Size*sizeof( ElemType));if(!L.elem) //存储分配失败exit(0);elseL.length=0; //空表长度为0L.listsize=List_Init_Size; //初始存储容量}void DestroyList(Sqlist &L)//销毁顺序线性表L{free(L.elem);L.elem=NULL;L.length=0;L.listsize=0;}void Clearlist(Sqlist &L)//将顺序线性表置为空表{L.length=0;}bool ListEmpty(Sqlist L)//若L为空表，返回TURE，否则返回FALSE{if(L.length==0)return true;elsereturn false;}int ListLength(Sqlist L)//返回L中数据元素个数{return L.length;}Status GetElem(Sqlist L,int i,ElemType &e)//用e返回L中第i个数据元素的值{if(i<1||i>L.length)return false;elsee=*(L.elem+i-1);return 0;}int LocateElem( Sqlist L, ElemType e )//返回L中第1个与e相等的数据元素的位序，若该元素不存在，则返回值为0{int i = 0;while ( i < L.length && L.elem[i] != e )i++;if ( i < L.length ) return i+1;else return 0;}// LocateElem_SqStatus PriorElem(Sqlist L,ElemType cur_e,ElemType &pre_e)//若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e 无意义{int i=2;ElemType *p=L.elem+1;while(i<=L.length&&*p!=cur_e){p++;i++;}if(i>L.length) //操作失败return false;else{pre_e=*--p;return true;}}Status NextElem(Sqlist L,ElemType cur_e,ElemType &next_e)//若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，否则操作失败，next_e无意义{int i=1;ElemType *p=L.elem;while(i<=L.length&&*p!=cur_e){i++;p++;}if(i==L.length) //操作失败return false;else{next_e=*++p;return true;}}Status ListInsert(Sqlist &L,int i,ElemType e)//在L中的第i个位置之前插入新的数据元素e，L长度加1{ElemType *newbase,*q,*p;if(i<1||i>L.length+1) //i值不合法return false;if(i>=L.listsize) //当前的存储空间已满，增加分配{if(!(newbase=(ElemType*)realloc(L.elem,(L.listsize+List_Increment)*sizeof(ElemType)))) return false; //存储分配失败L.elem=newbase; //新基址L.length+=List_Increment; //增加存储容量}q=L.elem+i-1; //q为插入位置for(p=L.elem+L.length-1;p>=q;--p) //插入位置及之后的元素右移*(p+1)=*p;*q=e; //插入位置及之后的元素右移++L.length; //表长加1return true;}Status ListDelete(Sqlist &L,int i,ElemType e)//删除L中的第i个数据元素，用e返回其值，L长度减1{ElemType *q,*p;if(i<1||i>L.length) //i值不合法return false;p=L.elem+i-1; //p为被删除元素的位置e=*p;q=L.elem+L.length-1; //表尾元素的位置for(++p;p<=q;++p) //插入位置及之后的元素左移*(p-1)=*p;L.length--; //表长减1return true;}void ListTraverse(Sqlist L,void(*vi)(ElemType&))//依次对L的每个数据元素调用函数vi()，vi()的形参如'&'，表明可通过调用vi（）改变元素的值{ElemType *p;int i;p=L.elem;for(i=1;i<=L.length;i++)vi(*p++);printf("\n");}int main(){Sqlist L;ElemType e,e0;Status i;int j,k,n;InitList(L);printf("初始化后：L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);for(j=1;j<=5;j++){n=rand()%80;//随机数的值不超过80i=ListInsert(L,1,n);}// 在L的表头依次插入5个随机数printf("在L的表头依次插入5个随机数后：*L.elem=");for(j=1;j<=5;j++)printf("%d ",*(L.elem+j-1));printf("\n");printf("L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);i=ListEmpty(L);printf("L是否为空：i=%d(1:是；0：否)\n",i);Clearlist(L);printf("清空L后：L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);for(j=1;j<=10;j++){n=rand()%80;//随机数的值不超过80ListInsert(L,j,n);}// 在L的表尾依次插入10个随机数printf("在L的表尾依次插入10个随机数后,*L.elem=");for(j=1;j<=10;j++)printf("%d ",*(L.elem+j-1));printf("\n");printf("L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);ListInsert(L,1,20);printf("在L的表头插入20后：*L.elem=");for(j=1;j<=ListLength(L);j++) //ListLength(L)为元素个数printf("%d ",*(L.elem+j-1));printf("\n");GetElem(L,5,e);printf("第五个元素的值为：%d\n",e);for(j=10;j<=11;j++){k=LocateElem(L,j);if(k) //k不为0，表明有符合条件的元素，且其为序为k printf("第%d个元素的值为%d\n",k,j);elseprintf("没有值为%d的元素\n",j);}for(j=1;j<=2;j++) //测试头两个数据{GetElem(L,j,e0); //将第j个数据赋给e0i=PriorElem(L,e0,e); //求e0的前驱if(i==false)printf("元素%d没有前驱\n",e0);elseprintf("元素%d的前驱为%d\n",e0,e);}for(j=ListLength(L)-1;j<=ListLength(L);j++)//测试最后两个两个数据{GetElem(L,j,e0); //将第j个数据赋给e0i=NextElem(L,e0,e); //求e0后继if(i==false)printf("元素%d没有后继\n",e0);elseprintf("元素%d的后继为%d\n",e0,e);}k=ListLength(L);for(j=k+1;j>=k;j--){i=ListDelete(L,j,e);if(i==false)printf("删除第%d个元素失败\n",j);elseprintf("删除第%d个元素成功，其值为%d\n",j,e);}DestroyList(L);printf("销毁L后：L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);return 1;}三、结果和数据处理四、问题与讨论通过做这次实验，发现自己在数据结构这门课程中还有很多不足，有很多知识还没掌握，实验的时候出现了很多错误。