数据结构_实验二_线性表及其实现

实验报告二线性表班级：姓名：学号：专业：一、实验目的：（1）理解线性表的逻辑结构、两种存储结构和数据操作；（2）应用顺序表的基本算法实现集合A=AUB算法，应用顺序表的基本算法实现两有序顺序表的归并算法；（3）掌握单链表的遍历、插入和删除等操作算法，实现多项式相加。

二、实验内容：1、设有线性表 LA＝（3,5,8,11）和 LB=（2,6,8,9,11,15,20）；①若LA和LB分别表示两个集合A和B，求新集合A＝A U B（‘并’操作，相同元素不保留）；预测输出：LA=（3,5,8,11,2,6,9,15,20）实现代码：package Ex1;public class Point {int a=0;public Point next=null;public Point(int a){this(a,null);}public Point(int a, Point next) {this.a=a;this.next=next;}}-----------------------------------package Ex1;public class SeqList {private Point head=null;private Point tail=null;public SeqList(){head=null;tail=null;}public boolean isEmpty(){return head==null;}public void addHead(int a){head=new Point(a,head);if(tail==null)tail=head;}public void addTail(int a){if(isEmpty()){this.addHead(a);}else{Point temp=new Point(a);tail.next=temp;tail=tail.next;}}public boolean Find(int a){if(isEmpty())return false;else{for(Point temp=head;temp!=null;temp=temp.next){ if(temp.a==a)return true;}}return false;}public void addList(SeqList list){for(Point temp=list.head;temp!=null;temp=temp.next){ if(Find(temp.a)){continue;}else{Point temp1=new Point(temp.a);tail.next=temp1;tail=tail.next;}}}public void Pri() {// TODO Auto-generated method stubfor(Point temp=head;temp!=null;temp=temp.next){ System.out.printf("%4d",temp.a);}}}------------------------ package Ex1;public class Test {static int[] x={3,5,8,11};static int[] x1={2,6,8,9,11,15,20};static SeqList List1=new SeqList();static SeqList List2=new SeqList();public static void Def(){for(int i=0;i<x.length;i++){List1.addTail(x[i]);}for(int i=0;i<x1.length;i++){List2.addTail(x1[i]);}}public static void Pri(){System.out.println("链表内容为：");List1.Pri();System.out.println("");List2.Pri();System.out.println("");}public static void Add(){List1.addList(List2);}public static void Pri1(){System.out.println("合并后链表内容为：");List1.Pri();}public static void main(String ars[]){Def();Pri();Add();Pri1();}}粘贴运行结果：②将LA与LB表归并，要求仍有序（相同元素要保留）(两种存储结构)预测输出：LC=（2,3,5,6,8,8,9,11,11,15,20）package Ex1;public class Point {int a=0;public Point next=null;public Point(int a){this(a,null);}public Point(int a, Point next) {this.a=a;this.next=next;}}----------------------------------------------------- package Ex1;public class SeqList {Point head=null;Point tail=null;public SeqList(){head=null;tail=null;}public boolean isEmpty(){return head==null;}public void addHead(int a){head=new Point(a,head);if(tail==null)tail=head;}public void addTail(int a){if(isEmpty()){this.addHead(a);}else{Point temp=new Point(a);tail.next=temp;tail=tail.next;}}public boolean Find(int a){if(isEmpty())return false;else{for(Point temp=head;temp!=null;temp=temp.next){ if(temp.a==a)return true;}}return false;}public void addList(SeqList list){for(Point temp=list.head;temp!=null;temp=temp.next){ if(Find(temp.a)){continue;}else{Point temp1=new Point(temp.a);tail.next=temp1;tail=tail.next;}}}public void addList1(SeqList list){Point temp1,c,temp2;for(Point H=this.head;H!=null;H=H.next){if(H.next==null){H.next=list.head;break;}for(Point temp=list.head;temp!=null;temp=temp2){ temp2=temp.next;if(H.a<temp.a || H.a==temp.a){if(H.a==temp.a || temp.a<H.next.a){c=H.next;H.next=temp;temp.next=c;list.head=temp2;break;}}else{this.head=temp;this.head.next=H;list.head=temp2;break;}}}/*Point la=this.head;Point lb=list.head;Point temp;if(la.a==0)la=la.next;for(;la!=null;la=temp){temp=la.next;for(;lb.next!=null;lb=lb.next){if(la.a<lb.next.a || la.a==lb.next.a){la.next=lb.next;lb.next=la;break;}}if(lb.next==null)lb.next=la;return list.head;}return list.head;*/}public void Pri() {// TODO Auto-generated method stubfor(Point temp=head;temp!=null;temp=temp.next){System.out.printf("%4d",temp.a);}}}--------------------------------------------------------- package Ex1;import java.util.*;public class Test {static Scanner scan=new Scanner(System.in);static int[] x={3,5,8,11};static int[] x1={2,6,8,9,11,15,20};static SeqList List1=new SeqList();static SeqList List2=new SeqList();public static void Def(){for(int i=0;i<x.length;i++){List1.addTail(x[i]);}for(int i=0;i<x1.length;i++){List2.addTail(x1[i]);}}public static void Pri(){System.out.println("链表内容为：");List1.Pri();System.out.println("");List2.Pri();System.out.println("");}public static void Add(){List1.addList(List2);}public static void Pri1(){List1.Pri();}public static void main(String ars[]){Def();Pri();System.out.println("请选择要进行的功能：");System.out.println(" A、合并去相同项 B、合并并排序，不去相同项");String x=scan.next();if(x.equals("A")){Add();Pri1();}else{List1.addList1(List2);List1.Pri();}scan.close();}}粘贴运行结果：2、在SinglyLinkedList类中增加下列成员方法。

实验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：实现顺序表各种基本运算的算法一、实验目的学会并运用顺序表存储结构及各种运算。

二、实验环境VC++6.0三、实验准备(1) 复习课件中理论知识(2)练习课堂所讲的例子四、实验内容编写一个程序实现SqList.cpp,实现顺序表基本运算，并在此基础上设计个主程序exp1.cpp，完成如下功能：（1）初始化顺序表L;（2）依次插入a、b、c、d、e元素；（3）输出顺序表L;（4）输出顺序表L长度；（5）判断顺序表L是否为空：（6）输出顺序表L的第3个元素；（7）输出元素a的位置；（8）在第4个位置上插入f元素；（9）输出顺序表L；（10）删除顺序表L的第3 个元素；（11）输出顺序表L;（12）顺序表L;五、实验步骤1、构造一个空的线形表并分配内存空间Status InitList_Sql(SqList &L){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW);L.length=0; L.listsize=LIST_INIT_SIZE; return OK; }2、求线性表的长度Status ListLength(SqList L) {return L.length; }3、线性表清空void ClearList(SqList &L){ L.length = 0; }4、在顺序线形表 L 中第 i 个位置之前插入新的元素 eStatus ListInsert_Sq(SqList &L,int i,ElemType e)5、查找'm'在顺序表中的位序e = 'm'; i = LocateElem_Sq(L,e);printf("元素 m 在顺序表中的位序是：%d\n",i);6、在第4个位置上插入f元素printf("（在第 4 个元素位置上插入 f 元素\n");ListInsert_Sq(L,4,'f');7、删除第 3 个元素printf("（删除顺序表 L 中第 3 个元素:"); ListDelete_Sq(L, 3, e);printf("被删除的第 3 个元素值是：%c",e);8、重新申请空间ElemType*newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof( ElemType)); if(!newbase) exit(OVERFLOW);L.elem=newbase;新的存储空间基址 L.listsize+=LISTINCREMENT;9、初始化并插入元素InitList_Sql(L); printf("依次插入 a,b,c,d,e 元素\n");10、输出顺序表、释放顺序表printf("输出顺序表 L:"); ListTraverse(L); printf("（释放顺序表L\n"); DestroyList(L);六、实验总结通过该实验的学习，对课堂内容再次巩固，对顺序表也有了更深的了解。

《数据结构》实验报告专业：学号：姓名：实验二线性表【实验目的】1.熟悉VC环境，学习如何使用C语言实现线性表的两种存储结构。

2.通过编程、上机调试，进一步理解线性表的基本概念，东运用C语言实现线性表基本操作。

3.熟练掌握线性表的综合应用问题。

【实验内容】1、一个线性表有n个元素（n-MAXSIZE.MAXSIZE指线性表的最大长度），且递增有。

现有一元素x要插入到线性表的适当位置上，并保持线性表原有的顺序不变。

设计程序实现。

要求：采用顺序存储表示实现；采用链式存储表示方法实现：比较两种方法的优劣。

2.从单链表中删除指定的元素x，若x在单链表中不存在，给出提示信息。

要求：①指定的值x由键盘输入；②程序能处理空链表的情况。

3.设有头结点的单链表，编程对表中的任意值只保留一个结点，删除其余值相同的结点。

要求：①该算法用函数（非主函数)实现；②在主函数中调用创建链表的函数创建一个单链表，并调用该函数，验证算法的正确性。

LinkedList Exchange（LinkedList HEAD,p)//HEAD是单链表头结点的指针，p是链表中的一个结点。

本算法将p所指结点与其后继结点交换。

（q=head->next；//q是工作指针，指向链表中当前待处理结点。

pre=head；//pre是前驱结点指针，指向q的前驱。

while（q'=null &&q1=p)(pre=q；q=q->next；]/未到p结点，后移指针。

if（p->next==null)printf(“p无后继结点\n”）；/p是链表中最后一个结点，无后继。

else/处理p和后继结点交换（q=p->next；//暂存p的后继。

pre->next=q://p前驱结点的后继指向p的后继。

p->next=q->next；//p的后继指向原p后继的后继。

q->next=p：//原p后继的后继指针指向p。

数据结构实验报告线性表数据结构实验报告：线性表引言数据结构是计算机科学中非常重要的一个概念，它是用来组织和存储数据的一种方式。

线性表是数据结构中最基本的一种，它是由n个数据元素组成的有限序列。

在本次实验中，我们将对线性表进行深入研究，并进行实验验证。

实验目的1. 了解线性表的基本概念和特性2. 掌握线性表的顺序存储结构和链式存储结构3. 熟练掌握线性表的基本操作：插入、删除、查找等4. 通过实验验证线性表的操作和性能实验内容1. 学习线性表的基本概念和特性2. 熟悉线性表的顺序存储结构和链式存储结构3. 实现线性表的基本操作：插入、删除、查找等4. 对线性表的操作进行性能测试和分析实验步骤1. 学习线性表的基本概念和特性，包括线性表的定义、顺序存储结构和链式存储结构等2. 实现线性表的基本操作：插入、删除、查找等3. 设计实验用例，对线性表的操作进行性能测试4. 对实验结果进行分析和总结实验结果1. 实现了线性表的顺序存储结构和链式存储结构2. 实现了线性表的基本操作：插入、删除、查找等3. 对线性表的操作进行了性能测试，并得出了相应的性能数据4. 对实验结果进行了分析和总结，得出了相应的结论结论通过本次实验，我们深入了解了线性表的基本概念和特性，掌握了线性表的顺序存储结构和链式存储结构，熟练掌握了线性表的基本操作，并对线性表的性能进行了测试和分析。

这些都为我们进一步深入学习和应用数据结构打下了坚实的基础。

总结数据结构是计算机科学中非常重要的一部分，线性表作为数据结构中最基本的一种，对我们学习和应用数据结构具有重要的意义。

通过本次实验，我们对线性表有了更深入的了解，并且掌握了相关的操作和性能测试方法，这将为我们今后的学习和应用提供很大的帮助。

数据结构实验报告一实验名称:线性表及其实现栈和队列及其应用1 实验目的及实验要求1.线性表目的要求：（1）熟悉线性表的基本运算在两种存储结构（顺序结构和链式结构）上的实现，以线性表的各种操作（建立、插入、删除等）的实现为实验重点；（2）通过本次实验帮助学生加深对顺序表、链表的理解，并加以应用；（3）掌握循环链表和双链表的定义和构造方法2.栈和队列目的要求：（1）掌握栈和队列这两种特殊的线性表，熟悉它们的特性，在实际问题背景下灵活运用它们；（2）本实验训练的要点是“栈”的观点及其典型用法；（3）掌握问题求解的状态表示及其递归算法，以及由递归程序到非递归程序的转化方法。

2实验内容及实验步骤（附运行结果截屏）1.线性表实验内容：（1）编程实现线性表两种存储结构（顺序存储、链式存储）中的基本操作的实现（线性表的创建、插入、删除和查找等），并设计一个菜单调用线性表的基本操作。

（2）建立一个按元素递增有序的单链表L，并编写程序实现：a）将x插入其中后仍保持L的有序性；b）将数据值介于min和max之间的结点删除，并保持L的有序性；c）（选做）将单链表L逆置并输出；（3）编程实现将两个按元素递增有序的单链表合并为一个新的按元素递增的单链表。

注：（1）为必做题，（2）~（3）选做。

2.栈和队列实验内容：（1）编程实现栈在两种存储结构中的基本操作（栈的初始化、判栈空、入栈、出栈等）；（2）应用栈的基本操作，实现数制转换（任意进制）；（3）编程实现队列在两种存储结构中的基本操作（队列的初始化、判队列空、入队列、出队列）；（4）利用栈实现任一个表达式中的语法检查（括号的匹配）。

（5）利用栈实现表达式的求值。

注：（1）～（2）必做，（3）～（5）选做。

实验步骤：先编写线性表和栈和队列的类模板，实现各自的基础结构，之后按照要求编写适当的函数方法（公共接口），最后完成封装。

编写主函数直接调用即可。

核心代码：//LinearList.h 顺序表//类的声明1.template<class T>2.class LinearList3.{4.public:5.LinearList(int sz = default_size);6.~LinearList();7.int Length()const; //length of the linear8.int Search(T x)const; //search x in the linear and return its order number9.T GetData(int i)const; //get i th order's data10.bool SetData(int i,T x); //change i th order's data to x11.bool DeleteData(int i);12.bool InsertData(int i,T x);13.void output(bool a,int b,int c); //print the linear14.void ReSize(int new_size);15.16.private:17.T *data;18.int max_size,last_data;19.};//构造函数1.template<class T>2.LinearList<T>::LinearList(int sz)3.{4.if(sz>0)5.{6.max_size = sz;st_data=-1;8.data=new T[max_size];9.if(data == NULL)10.{11.cerr<<"Memory creat error!"<<endl;12.exit(1);13.}14.}15.else16.{17.cerr<<"Size error!"<<endl;18.exit(1);19.}20.}//Qlist.h 链式表//模板类的声明1.template<class T>2.struct LinkNode3.{4.T data;5.LinkNode<T> *link;6.LinkNode(LinkNode<T> *ptr = NULL)7.{8.link = ptr;9.}10.LinkNode(const T item,LinkNode<T> *ptr = NULL)11.{12.data = item;13.link = ptr;14.}15.};16.17.template<class T>18.class Qlist: public LinkNode<T>19.{20.public:21.Qlist();22.Qlist(const T x);23.Qlist(Qlist<T>&L);24.~Qlist();25.void MakeEmpty();26.int Length()const; //length of the linear27.int Search(T x)const; //search x in the linear and return its order number28.LinkNode<T> *Locate(int i);29.T GetData(int i); //get i th order's data30.bool SetData(int i,T x); //change i th order's data to x31.bool DeleteData(int i);32.bool InsertData(int i,T x);33.void output(bool a,int b,int c); //print the linear34.35.protected:36.LinkNode<T> *first;37.};//构造函数1.template<class T>2.Qlist<T>::Qlist(Qlist<T>&L)3.{4.T value;5.LinkNode<T>*src = L.getHead();6.LinkNode<T>*des = first = new LinkNode<T>;7.while(src->link != NULL)8.{9.value = src->link->data;10.des->link = new LinkNode<T>(value);11.des = des->link;12.src = src->link;13.}14.des->link = NULL;15.}截屏：3 实验体会（实验遇到的问题及解决方法）刚开始的时候本想先写线性表的类模板然后分别进行继承写顺序表和链式表甚至是以后的栈和队列。

第二章线性表及其应用【实验目的】1. 熟练掌握线性表的基本操作在顺序存储和链式存储上的实现；2. 以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点；3. 掌握线性表的动态分配顺序存储结构的定义和基本操作的实现；4. 通过本章实验帮助学生加深对C语言的使用（特别是函数的参数调用、指针类型的应用和链表的建立等各种基本操作）。

第一节知识准备一、线性表的逻辑结构线性表是由一组具有相同特性的数据元素组成的有限序列。

至于每个数据元素，它可以是一个数，一个符号，也可以是一页书，甚至更复杂的信息。

例如：26个英文字母构成一个线性表（A，B，C，…，Y，Z）一串数字构成另一个线性表（45，45，32，65，123）每个数据元素可以由若干数据项组成，常把此数据元素称为记录。

能唯一标识一个记录的数据项的值称为关键字。

如：一个学校的学生情况表如表2-1所示，表中每个学生的情况为一个记录，它由学号、姓名、性别、年龄、年级等五个数据项组成。

学号姓名性别年龄年级96001 张平女 21 大二96002 王极男 20 大一96003 膨磊男 23 大三96004 严正英女 19 大一96005 李强男 20 大二综上所述，线性表有如下特性：1．除第一个和最后一个元素以外，每个元素有且仅有一个直接前趋和一个直接后继；第一个结点只有直接后继，最后一个结点只有直接前趋。

2．线性表中的每个数据元素，其数据类型是一致的。

3．数据元素之间的相对位置是线性的，结构中的数据元素之间存在一个对一个的关系。

二、线性表的顺序表示和实现计算机的内存是由有限多个存储单元组成的，每个存储单元都有对应的整数地址，各存储单元的地址是连续编号的。

对于一个线性表，如果用一组连续的存储单元依次存放它的各个数据元素，这就是线性表的顺序分配。

也就是说，在线性表的顺序分配结构中，逻辑结构上相邻的数据元素，其物理位置也是相邻的。

若一个数据元素只占用一个存储单元，则这种分配方式如图2-1所示。

数据结构实验报告线性表数据结构实验报告：线性表引言：数据结构是计算机科学中的重要概念，它涉及到如何组织和存储数据，以及如何有效地操作和管理这些数据。

线性表是数据结构中最基本的一种，它是一种有序的数据元素集合，其中的元素之间存在着一对一的关系。

一、线性表的定义和特点线性表是由n个数据元素组成的有限序列，其中n为表的长度。

这些数据元素可以是相同类型的，也可以是不同类型的。

线性表中的数据元素按照一定的顺序排列，并且每个数据元素都有唯一的前驱和后继。

线性表的特点有以下几个方面：1. 数据元素之间是一对一的关系，即每个数据元素只有一个直接前驱和一个直接后继。

2. 线性表中的元素是有序的，每个元素都有一个确定的位置。

3. 线性表的长度是有限的，它的长度可以是0，也可以是任意正整数。

二、线性表的实现方式线性表可以使用不同的数据结构来实现，常见的实现方式有数组和链表。

1. 数组实现线性表：数组是一种连续存储的数据结构，它可以用来存储线性表中的元素。

数组的优点是可以快速访问任意位置的元素，但是插入和删除操作需要移动其他元素，效率较低。

2. 链表实现线性表：链表是一种非连续存储的数据结构，它通过指针将线性表中的元素链接起来。

链表的优点是插入和删除操作简单高效，但是访问任意位置的元素需要遍历链表，效率较低。

三、线性表的基本操作线性表的基本操作包括插入、删除、查找和修改等。

1. 插入操作：插入操作用于向线性表中插入一个新元素。

具体步骤是先将插入位置后面的元素依次后移，然后将新元素插入到指定位置。

2. 删除操作：删除操作用于从线性表中删除一个元素。

具体步骤是先将删除位置后面的元素依次前移，然后将最后一个元素删除。

3. 查找操作：查找操作用于在线性表中查找指定元素。

具体步骤是从线性表的第一个元素开始逐个比较，直到找到匹配的元素或者到达线性表的末尾。

4. 修改操作：修改操作用于修改线性表中的某个元素的值。

具体步骤是先查找到要修改的元素，然后将其值更新为新值。