数据结构实验线性表的顺序存储结构
数据结构实验报告-线性表(顺序表实现)
实验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.归并顺序表（销毁或清空操作前）七、思考讨论题或体会或对改进实验的建议通过本次实验，我掌握了定义线性表的顺序存储类型，加深了对顺序存储结构的理解，进一步巩固和理解了顺序表的基本操作，如建立、查找、插入和删除等。
《数据结构》线性结构实验报告
《数据结构》线性结构实验报告2、源程序：#include <stdio.h>#include<stdlib.h>#define MAXSIZE 1024typedef int elemtype;typedef struct SequenStack{elemtype data[MAXSIZE];int top;}SequenStack;SequenStack * Init_SequenStack(){SequenStack * S;S = (SequenStack *)malloc(sizeof(SequenStack));if (S == NULL)return S;S->top = -1;return S;}int SequenStack_Empty(SequenStack * S)//判栈空{if (S->top == -1){return 1;}{int a;printf("请以十进制输入一个数：\n");scanf_s("%d", &a);printf("转化为二进制为：");Conversion(a);printf("\n");}运行结果：3、源程序：#include<stdio.h>#include<stdlib.h>#include<string.h>typedef struct node{char data;struct node* next;}LinkStack;//初始化LinkStack* Init_LinkStack(){LinkStack* top;top = (LinkStack*)malloc(sizeof(LinkStack));top->next = NULL;return top;}//入栈void Push_LinkStack(LinkStack* top, char x){LinkStack* node;node = (LinkStack*)malloc(sizeof(LinkStack));node->data = x;node->next = top->next;top->next = node;}运行结果：4、源程序：#include <stdio.h>#include<stdlib.h>#include<string.h>#define MAXSIZE 20typedef int elemtype;typedef struct QueueNode{elemtype data;struct QueueNode* next;}LinkedQueueNode;typedef struct LQueue{LinkedQueueNode* front;LinkedQueueNode* rear;}LQueue, *LinkedQueue;typedef struct Person{char name[MAXSIZE];char sex;}Person;typedef char* ElemType;//链队初始化LinkedQueue Init_LinkedQueue(){LinkedQueue Q = (LinkedQueue)malloc(sizeof(LQueue));LinkedQueueNode * head = (LinkedQueueNode *)malloc(sizeof(LinkedQueueNode));if (head != NULL && Q != NULL){head->next = NULL;Q->front = head;Q->rear = head;printf("输入参与者的姓名，性别\n");for (i = 0; i < num; i++){printf("输入第%d个舞者的名字:\n", i + 1);scanf_s("%s", &dancer[i].name, 10);printf("输入第%d个人的性别(F/M):\n", i + 1);scanf_s("%s", &dancer[i].sex, 10);while (dancer[i].sex != 'F' && dancer[i].sex != 'M'){printf("输入错误，请重新输入第%d个人的性别(F/M):\n", i + 1);scanf_s("%s", &dancer[i].sex, 10);}}DancePartner(dancer, num);break;case 0:printf("感谢你的使用！\n");break;default:printf("无此选项！\n");break;}} while (n != 0);return 0;}运行结果：。
数据结构实验报告-实验：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.线性表的初始化初始化线性表时，需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作：________在指定位置插入一个元素时，需要将插入位置之后的元素依次后移，给待插入的元素腾出位置。
●删除操作：________删除指定位置的元素时，需要将删除位置之后的元素依次前移，覆盖删除位置上的元素。
●修改操作：________修改指定位置的元素时，直接对该位置上的元素进行修改即可。
●查找操作：________根据指定的元素值，查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素，可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点：________可以快速地访问任意位置的元素，节省存储空间。
2.缺点：________插入和删除操作需要移动大量的元素，不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中，我们以顺序存储结构为基础，实现了线性表的增删改查操作，并进行了遍历操作。
通过实验，我们发现顺序存储结构在查询操作上有较好的性能，但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
数据结构实训实验报告
一、实验背景数据结构是计算机科学中一个重要的基础学科，它研究如何有效地组织和存储数据，并实现对数据的检索、插入、删除等操作。
为了更好地理解数据结构的概念和原理，我们进行了一次数据结构实训实验，通过实际操作来加深对数据结构的认识。
二、实验目的1. 掌握常见数据结构（如线性表、栈、队列、树、图等）的定义、特点及操作方法。
2. 熟练运用数据结构解决实际问题，提高算法设计能力。
3. 培养团队合作精神，提高实验报告撰写能力。
三、实验内容本次实验主要包括以下内容：1. 线性表（1）实现线性表的顺序存储和链式存储。
（2）实现线性表的插入、删除、查找等操作。
2. 栈与队列（1）实现栈的顺序存储和链式存储。
（2）实现栈的入栈、出栈、判断栈空等操作。
（3）实现队列的顺序存储和链式存储。
（4）实现队列的入队、出队、判断队空等操作。
3. 树与图（1）实现二叉树的顺序存储和链式存储。
（2）实现二叉树的遍历、查找、插入、删除等操作。
（3）实现图的邻接矩阵和邻接表存储。
（4）实现图的深度优先遍历和广度优先遍历。
4. 算法设计与应用（1）实现冒泡排序、选择排序、插入排序等基本排序算法。
（2）实现二分查找算法。
（3）设计并实现一个简单的学生成绩管理系统。
四、实验步骤1. 熟悉实验要求，明确实验目的和内容。
2. 编写代码实现实验内容，对每个数据结构进行测试。
3. 对实验结果进行分析，总结实验过程中的问题和经验。
4. 撰写实验报告，包括实验目的、内容、步骤、结果分析等。
五、实验结果与分析1. 线性表（1）顺序存储的线性表实现简单，但插入和删除操作效率较低。
（2）链式存储的线性表插入和删除操作效率较高，但存储空间占用较大。
2. 栈与队列（1）栈和队列的顺序存储和链式存储实现简单，但顺序存储空间利用率较低。
（2）栈和队列的入栈、出队、判断空等操作实现简单，但需要考虑数据结构的边界条件。
3. 树与图（1）二叉树和图的存储结构实现复杂，但能够有效地表示和处理数据。
线性表实验
实验一线性表的顺序存储一、实验说明实验项目名称：线性表的顺序存储实验类型：基础实验课时：2实验所用主要仪器：微型计算机1台，安装中文版Windows 2000/XP 操作系统、VC++6.0集成编程环境。
二、实验目的：1. 掌握线性表的顺序存储结构。
2. 利用顺序存储结构实现线性表的基本操作。
3. 了解线性表的应用。
三、实验内容1. 运行顺序表的演示程序，掌握顺序表的存储结构的实现，进一步了解顺序表的初始化、查找、插入、删除、销毁等算法的编程实现。
（请运行源程序，写出创建线性表以及线性表的插入、删除、查找等一组测试结果）2. 按课本P43题2.6的要求，在演示程序中增加顺序表逆置功能。
本题要求：(1) 写出顺序表逆置算法加入到程序中并上机验证通过。
(2) 设计一组测试数据，并测试程序各个功能，记录输出结果。
（请查看源码中的reverse（L）函数）3. 约瑟夫圈问题：假设有n个人按1、2、3、…、n的顺序围成一圈。
现在，从第s个人开始按1、2、3、…、m的顺序报数，数到m的人出圈，接着从出圈的下一个人开始重复此过程，直到所有人出圈为止。
求出所有人的出圈顺序。
本题解法1：用顺序表为数据结构来解决这个问题。
算法如下：可以将n个人的编号存入一个一维数组中，表的长度就是人数n，因此，就可以用一维数组来代替顺序表。
算法的思想是：先求出出圈人的编号，用一个临时单元保存它，然后从出圈人的后一个开始，直到最后一个，都按顺序向前移动一个位置，再将临时单元的出圈人编号存入最后。
当这个重复步骤完成后，数组中存放的是出圈人的逆序列。
本题中，围圈的人数n、出圈的报数号m、开始报数的位置s，在程序中预先给定为10、3、2。
当然，用户也可以从键盘临时输入。
本题提供源程序。
（请查看源码中的joes(int n,int s,int m)、joes1(SqList &a,int n,int s,int m)、joes2(SqList a,int n,int s,int m)函数，对比两种方法解决约瑟夫问题的优劣性）本题要求：要求在main函数中修改joes、Joes1函数，设计出至少三组不同的测试数据(对应三个变量人数n、报数号m、开始位置s)，记录输出结果。
数据结构实验报告1-线性结构的顺序存储
教师签名： 2008 年 月 日
第2页共2页
2、参照课本，定义一个向量类模板，编写它的成员函数模板，对类模板加以实现；编写向量的并、 交运算功能函数；编写主程序，对两个向量进行分别进行合并、交运算。
3、通过阅读课本栈类板代码，理解栈类操作特点；编写一个借助于栈，将二进制数转换为十进制数 字串的程序；编写汉诺塔问题程序，理解函数的递归调用。
4、参照课本，定义一个顺序队列类模板，编写它的成员函数模板 ，对类模板加以实现；编写主程序， 对队列进行各种基本操作，理解队列的操作特性。
五、 实验总结（包括心得体会、问题回答及实验改进意见，可附页）
通过本次实验，基本上能够理解线性结构的顺序存储方式及各种不同线性结构的操作方式；顺序存 储方式主要用于线性的数据结构，它把逻辑上相邻的数据元素存储在物理上相邻的存储单元里结点之间 的关系由存储单元的邻接关系来体现。线性表、向量、栈、队列都属于线性结构的顺序存储，各结点的 物理地址是相邻的，每一次插入、删除运算会引起相应结点物理地址的重新排列；栈的操作特点是先进 后出，而队列的操作特点是先进先出。
2、 对两个向量进行合并、交运算，结果如下： 输入向量 La 的结点元素：1 2 3 4 5，输入 Lb 的结点元素：1 2 3 4 5 6，则两向量的交集为：1 2 3 4 5；并集为：1 2 3 4 5 6。
3、（1）将二进制数转换为十进制数字串的程序，结果如下： 输入要转换的带符号整数 x:+3;则 x 转换成十进制数字串输出为：+3
Байду номын сангаас
第1页共2页
四、 实验结果（包括程序或图表、结论陈述、数据记录及分析等，可附页）
1、 对线性表进行插入、删除、定位等操作，结果如下： 输入线性表元素：1 2 3 4 5，（1）选择插入，输入插入位置 2，插入值 9，则新的线性表为：1 2 9 3 4 5；（2）选择删除，输入删除元素序号 5，则新的线性表为：1 2 9 3 4；（3）选择取值，输入要求 值元素序号 2，则屏幕输出：第２个元素的值为 9；（4）选择查找，输入要查找的元素值 9，则屏幕输 出：要查找元素的序号为 2。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告实验目的：本次实验主要是为了学习和掌握线性表的基本操作和实现方式。
通过实验，我们可以加深对线性表的理解，并能够熟悉线性表的基本操作。
实验设备与环境：本次实验所需的设备包括计算机和编程环境。
我们选择使用C语言来实现线性表的操作，并在Visual Studio Code编程软件中进行编写和调试。
实验内容：1.线性表的定义和基本操作1.1 线性表的定义：线性表是一种有序的数据结构，其中的元素按照一定的顺序存储，可以插入、删除和访问元素。
1.2 线性表的基本操作：1.2.1 初始化线性表：创建一个空的线性表。
1.2.2 判断线性表是否为空：判断线性表是否不含有任何元素。
1.2.3 获取线性表的长度：返回线性表中元素的个数。
1.2.4 在线性表的指定位置插入元素：在线性表的第i个位置插入元素x，原第i个及其之后的元素依次后移。
1.2.5 删除线性表中指定位置的元素：删除线性表中第i个位置的元素，原第i+1个及其之后的元素依次前移。
1.2.6 获取线性表中指定位置的元素：返回线性表中第i个位置的元素的值。
1.2.7 清空线性表：将线性表中的元素全部删除，使其变为空表。
2.线性表的顺序存储结构实现2.1 线性表的顺序存储结构：使用数组来实现线性表的存储方式。
2.2 线性表的顺序存储结构的基本操作：2.2.1 初始化线性表：创建一个指定长度的数组，并将数组中的每个元素初始化为空值。
2.2.2 判断线性表是否为空：判断线性表的长度是否为0。
2.2.3 获取线性表的长度：返回线性表数组的长度。
2.2.4 在线性表的指定位置插入元素：将要插入的元素放入指定位置，并将原位置及其之后的元素依次后移。
2.2.5 删除线性表中指定位置的元素：将指定位置的元素删除，并将原位置之后的元素依次前移。
2.2.6 获取线性表中指定位置的元素：返回指定位置的元素的值。
2.2.7 清空线性表：将线性表数组中的每个元素赋空值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
南昌航空大学实验报告课程名称：数据结构实验名称：实验一线性表的链式存储结构班级：080611 学生姓名：冯武明学号：16 指导教师评定：XXX 签名: XXX题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。
一、需求分析⒈先构造两个多项式链表，实现两个多项式的和及删除值为零元素的操作，不同用户输入的多项式不同。
⒉在演示过程序中，用户需敲击键盘输入值，即可观看结果。
⒊程序执行的命令包括：（1）构造多项式链表A （2）构造多项式链表B （3）求两张链表的和（4）删除值为零元素，即不创建链表。
二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Stack {数据对象：D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系：R1={<a i-1,a i>|a i-1,a i∈D,i=2,…n≥0}基本操作:init(linklist *L)操作结果：destroylist(List *L)clearlist(List *L)初始条件：线性表L已经存在，1≤i≤ListLength(&L)操作结果：用e返回L中第i个数据元素的值。
insfirst(link h,link s)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
delfirst(link h,link *q)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
append(linklist *L,link s)初始条件：线性表La已经存在操作结果：判断La中是否有与e相同的元素。
remove(linklist *L,link *q)初始条件：非递减线性表La，Lb已经存在操作结果：合并La，Lb得到Lc，Lc仍按非递减有序排列。
UnionList(List *La ,List *Lb)初始条件：线性表La，Lb已经存在操作结果：将所有在Lb而不在La中的元素插入到La中表尾的位置。
PrintList(List L)初始条件：线性表L已经存在操作结果：打印出表L。
ListInsert(List *L, int i, struct STU e)初始条件：线性表L已经存在，1≤i≤ListLength(&L)+1操作结果：在表L中第i个位置前插入元素e，L的长度加1。
}ADT List2. 本程序有三个模块：⑴主程序模块void main(){初始化；{接受命令；显示结果；｝｝⑵链表单元模块：实现表抽象数据类型；三、详细设计⒈元素类型，结点类型typedef struct{int *elem;int length;int listsize;}sqlist;sqlist *La,*Lb,*Lc;2. 对抽象数据类型中的部分基本操作的伪码算法如下：void initlist(sqlist *L){L->elem=(int*)malloc(listinitsize*sizeof(int));L->length=0;L->listsize=listinitsize;} //初始化表void add(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=(int*)malloc((Lc->listsize)*sizeof(int));pa_last=La->elem+(La->length-1);pb_last=Lb->elem+(Lb->length-1);while(pa<=pa_last&&pb<=pb_last){if(*pa_last<*pb_last)*pc++=*pa_last--;else if(*pa_last>*pb_last)*pc++=*pb_last--;else{*pc=*pa_last;pc++;pa_last--;pb_last--;}}while(pa<=pa_last)*pc=*pa_last--;while(pb<=pb_last)*pc=*pb_last--;}//将两个表合并成Lc3. 主函数void main(){void initlist(sqlist *L);void add(sqlist *La,sqlist *Lb,sqlist *Lc);sqlist *La,*Lb,*Lc;int i,p,num;initlist(La);initlist(Lb);initlist(Lc);printf("please input the numbers of you want about La:\n"); scanf("%d",&num);printf("\n");for(i=0;i<num;i++){scanf("%d",&p);La->elem[i]=p;La->length++;}printf("please input the numbers of you want about Lb:\n"); scanf("%d",&num);printf("\n");for(i=0;i<num;i++){scanf("%d",&p);Lb->elem[i]=p;Lb->length++;}printf("\n\n\n\nthe list of La:\n");for(i=0;i<La->length;i++){printf("%6d",La->elem[i]);}printf("\n\n\n\nthe list of La:\n");for(i=0;i<Lb->length;i++){printf("%6d",Lb->elem[i]);}printf("\n\n\n");add(La,Lb,Lc);printf("\n\n\nthe list of Lc:\n");for(i=0;i<La->length+Lb->length;i++){printf("%6d",Lc->elem[i]);}getch();}4 .函数调用关系maininitlist四、调试分析⒈调试程序时，因为没有注意到指针变量与普通变量对成员的引用所用符号不同，将指针变量引用所用符号写成‘.’，导致程序出现大量错误，耽误了大量的调试时间。
警告shunxu~1.c 18: 可能在'La'定义以前使用了它在 main 函数中，将'La'放在main前即可消除警告。
注意定义各线性表变量为指针变量，这样可以返回函数。
⒉程序采用逐个输入的方法创建La,Lb,在元素较多时，会使得程序很庞大，不利于检查错误等。
⒊算法的时空分析各操作的算法时间复杂度比较合理Init（）为O(1)，void add()为O(mn)。
4.本次实验采用数据抽象的程序设计方法，将程序化为三层次结构，设计时思路清晰，使调试也较顺利，各模块有较好的可重用性。
五、用户手册⒈本程序的运行环境为windows xp操作系统，执行文件为shunxubiao.c；⒉进入演示程序后，按规定输入数值后便可看到结果，按任意键退出。
六、测试结果1、键入数值2、输出结果3、键入任意字符，退出演示界面，回到编辑状态。
七、附录：题一源程序#include<stdio.h>#define listinitsize 20#define listincrement 10typedef struct{int *elem;int length;int listsize;}sqlist;main(){void initlist(sqlist *L);void add(sqlist *La,sqlist *Lb,sqlist *Lc);sqlist *La,*Lb,*Lc;int i,p,num;initlist(La);initlist(Lb);initlist(Lc);printf("please input the numbers of you want about La:\n"); scanf("%d",&num);printf("\n");for(i=0;i<num;i++){scanf("%d",&p);La->elem[i]=p;La->length++;}printf("please input the numbers of you want about Lb:\n"); scanf("%d",&num);printf("\n");for(i=0;i<num;i++){scanf("%d",&p);Lb->elem[i]=p;Lb->length++;}printf("\n\n\n\nthe list of La:\n");for(i=0;i<La->length;i++){printf("%6d",La->elem[i]);}printf("\n\n\n\nthe list of La:\n");for(i=0;i<Lb->length;i++){printf("%6d",Lb->elem[i]);}printf("\n\n\n");add(La,Lb,Lc);printf("\n\n\nthe list of Lc:\n");for(i=0;i<La->length+Lb->length;i++){printf("%6d",Lc->elem[i]);}getch();}void add(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=(int*)malloc((Lc->listsize)*sizeof(int));pa_last=La->elem+(La->length-1);pb_last=Lb->elem+(Lb->length-1);while(pa<=pa_last&&pb<=pb_last){if(*pa_last<*pb_last)*pc++=*pa_last--;else if(*pa_last>*pb_last)*pc++=*pb_last--;else{*pc=*pa_last;pc++;pa_last--;pb_last--;}}while(pa<=pa_last)*pc=*pa_last--;while(pb<=pb_last)*pc=*pb_last--;}void initlist(sqlist *L){L->elem=(int*)malloc(listinitsize*sizeof(int));L->length=0;L->listsize=listinitsize;}（注：文档可能无法思考全面，请浏览后下载，供参考。