线性表大作业任务书
《数据结构与算法实验》任务书
《数据结构与算法实验》任务书《数据结构与算法实验》任务书实验一动态链表的设计与应用一、实验目的、要求1、掌握使用VC 6.0上机调试线性表的基本方法；2、掌握线性表的基本操作：插入、删除、查找以及线性表合并等运算在顺序存储结构和链式存储结构上的运算。
二、实验内容1．输入一组学生信息，建立一个单链表。
2．遍历该链表,输出学生信息。
3．查找某特定的学生,查找成功返回1,否则返回0。
4．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个非递减有序单向链表。
5．利用算法4建立两个非递减有序单向链表，然后合并成一个非递增链表。
*6．采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。
7．编写一个主函数,调试上述算法。
*8．综合训练：利用链表实现一个班级学生信息管理（数据录入、插入、删除、排序、查找等，并能够实现将数据存储到文件中）三、实验说明1.存储定义#define MAXSIZE 100 //表中元素的最大个数typedef int ElemType；//元素类型typedef struct list{ElemType elem[MAXSIZE];//静态线性表int length; //表的实际长度}SqList;//顺序表的类型名2.建立顺序表时可利用随机函数自动产生数据。
四、注意问题１．插入、删除时元素的移动原因、方向及先后顺序。
２．了解不同的函数形参与实参的传递关系。
一、实验目的、要求1．掌握栈、队列的思想及其存储实现。
2．掌握栈、队列的常见算法的程序实现。
二、实验内容1．采用链式存储实现栈的初始化、入栈、出栈操作。
2．采用顺序存储实现栈的初始化、入栈、出栈操作。
3．采用链式存储实现队列的初始化、入队、出队操作。
4．采用顺序存储实现循环队列的初始化、入队、出队操作。
5．在主函数中设计一个简单的菜单，分别测试上述算法。
*6．综合训练:1)利用栈实现表达式求值算法。
数据结构实验报告-线性表(顺序表实现)
实验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、熟练掌握线性表的基本操作在两种存储结构上的实现，其中以熟悉各种链表的操作为重点。
2、巩固高级语言程序设计方法与技术，会用线性链表解决简单的实际问题。
二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书，提前做好实验预习与准备工作。
2、加“*”题目必做，其他题目任选；多选者并且保质保量完成适当加分。
3、严格按照数据结构实验报告模板和规范，及时完成实验报告。
四、实验步骤（说明：依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作（成员函数）的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码）㈠、数据结构与核心算法的设计描述（程序中每个模块或函数应加注释，说明函数功能、入口及出口参数）1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释，说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释，说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针，返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针，本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计（可用函数的调用关系图说明）㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图：2、程序清单（程序过长，可附主要部分）说明：以后每次实验报告均按此格式书写。
第二章线性表作业-答案
2.8已知由单链表表示的线性表中，含有三类字符的数据元素( 2.8已知由单链表表示的线性表中，含有三类字符的数据元素(如：字母字符、数字字符 已知由单链表表示的线性表中，含有三类字符的数据元素 和其它字符) 和其它字符)，试编写算法构造三个以循环链表表示的线性表，使每个表中只含同一类 的字符，且利用原表中的结点空间作为这三个表的结点空间，头结点可另辟空间。
2.8 已知由单链表表示的线性表中，含有三类 字符的数据元素( 字符的数据元素(如：字母字符、数字字符和 其它字符) 其它字符)，试编写算法构造三个以循环链表 表示的线性表，使每个表中只含同一类的字 符，且利用原表中的结点空间作为这三个表 的结点空间，头结点可另辟空间。 2.9 假设在长度大于1的单循环链表中，既无 假设在长度大于1 头结点也无头指针。s 头结点也无头指针。s为指向链表中某个结 点的指针，试编写算法删除结点* 点的指针，试编写算法删除结点*s的直接前 趋结点。 2.10设顺序表L 2.10设顺序表L是一个递增有序表，试写一算 法，将x插入L中，并使L 法，将x插入L中，并使L仍是一个有序表。
Status locatenode(dullinklist &L,elemtype x) {dulnode *p,*q; p=q=Lp=q=L->next; while(p) (pp=p{if (p->data!=x) p=p->next; else {p->freq++; break;} } {pwhile(q) {if(q->freq>pq=q{if(q->freq>p->freq) q=q->next; {p->prior->next=pp->next->prior=pelse {p->prior->next=p->next; p->next->prior=p->prior; p->prior=qp->next=q; p->prior=q->prior; q->prior->next=p; q->prior=p} >priorq} return ok; }
软件大作业 - 副本
软件技术基础大作业班级xxx学号xxx姓名xxx实验一线性表一、实验目的1．熟悉线性表的顺序和链式存储结构2．掌握线性表的基本运算3．能够利用线性表的基本运算完成线性表应用的运算二、实验内容1．设有一个线性表E={e1, e2, … , e n-1, e n}，设计一个算法，将线性表逆置，即使元素排列次序颠倒过来，成为逆线性表E’={ e n , e n-1 , … , e2 , e1 }，要求逆线性表占用原线性表空间，并且用顺序表和单链表两种方法表示，分别用两个程序来完成。
（文件夹：顺序表逆置、单链表逆置）2．已知由不具有头结点的单链表表示的线性表中，含有三类字符的数据元素（字母、数字和其他字符），试编写算法构造三个以循环链表表示的线性表，使每个表中只含有同一类的字符，且利用原表中的结点空间，头结点可另辟空间。
（文件夹：分解单链表）1.顺序表逆置//顺序表逆置.cpp#include<stdio.h>#include<malloc.h>typedef char datatype;const int maxsize=1024;typedef struct{ datatype data[maxsize];int last;}sequenlist;void create(sequenlist*&);void print(sequenlist*);void invert(sequenlist*);void main(){sequenlist*L;create(L);//建立顺序表print(L);//输出顺序表invert(L);//调用顺序表逆值的函数print(L);//输出顺序表}//建立顺序表void create(sequenlist*&L){L=(sequenlist*)malloc(sizeof(sequenlist));L->last=0;char ch;while((ch=getchar())!='*'){L->last++;L->data[L->last]=ch;}}//输出顺序表void print(sequenlist*L){for(int i=1;i=L->last;i++)printf("%c ",L->data[i]);printf("\n");}//顺序表逆置void invert(sequenlist*L){int n=L->last/2;for(int i=1;i=n;i++){char temp=L->data[i];L->data[i]=L->data[L->last-i+1];L->data[L->last-i+1]=temp;}}仿真结果2．单链表逆置//单链表逆置的程序代码#include<malloc.h>#include<stdio.h>//单链表结构类型定义typedef char datatype;typedef struct node{datatype data;struct node *next;}linklist;void create(linklist*&);void print(linklist *);void invert(linklist*);void main(){linklist*head;create(head);print(head);invert(head);//调用单链表逆置的函数print(head);}//采用尾插法建立具有头结点的单链表void create(linklist*&head){char ch;linklist *s,*r;head=(linklist*)malloc(sizeof(linklist));r=head;while((ch=getchar())!='*'){s=(linklist*)malloc(sizeof(linklist));s->data=ch;r->next=s;r=s;}r->next=NULL;}//输出单链表void print(linklist *head){linklist*p=head->next;while(p!=NULL){printf("%2c",p->data);p=p->next;}printf("\n");}//单链表逆置仿真结果：3.分解单链表#include<stdio.h>#include<stdlib.h>typedef char datatype;typedef struct node{datatype data;struct node *next;}linklist;linklist *create();linklist *InitC();void print1(linklist*);void print2(linklist*);void insert(linklist*h,linklist*p);void resolve(linklist*,linklist*,linklist*,linklist*); void main(){linklist*head,*LA,*LB,*LC;head=create();print1(head);LA=InitC(LA);LB=InitC(LB);LC=InitC(LC);resolve(head,LA,LB,LC);print2(LA);print2(LB);print2(LC);}linklist *create(){datatype x;linklist *head,*p;head=NULL;while ((x=getchar())!='\n'){p=(linklist*)malloc(sizeof(linklist));p->data=x;if(head==NULL){p->next=NULL;head=p;}else{p->next=head;head=p;}}return head;}linklist*InitC(linklist*p){p=(linklist*)malloc(sizeof(linklist));p->next=p;return p;}void insert(linklist*h,linklist*p){linklist *r=h;r=r->next;h->next=p;p->next=r;}void print1(linklist*head){linklist*p=head->next;while(p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}void print2(linklist*head){linklist*p=head->next;while(p!=head){printf("%c",p->data);p=p->next;}printf("\n");}void resolve(linklist*head,linklist*LA,linklist*LB,linklist*LC){linklist*p=head,*q;while(p){if ( p->data>='a' &&p->data<='z'|| p->data>='A' &&p->data<='Z'){q=p;p=p->next;insert(LA,q);}else if( p->data>='0' && p->data<='9'){q=p;p=p->next;insert(LB,q);}else{q=p;p=p->next;insert(LC,q);}}}实验二栈和队列一、实验目的1．熟悉栈和队列的顺序和链式存储结构2．掌握栈和队列的基本运算3．能够利用栈和队列的基本运算完成栈和队列应用的运算二、实验内容1．设单链表中存放有n个字符，试编写算法，判断该字符串是否有中心对称的关系，例如xyzzyx是中心对称的字符串。
数据结构实验指导书-线性表的操作
数据结构实验指导书-线性表的操作实验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],注两者区别。
第二章线性表作业参考答案PPT课件
else
while(p->data<=maxk && p!=NULL) { r=p; //删除链结点p
p=p->next;
free(r);
} q->next=p; //删除若干链结点后，重新建立链接
}// DELmink_maxk
2020/10/13
7
作业2.2
设线性表A=(a1,a2,…,an)，B=(b1,b2,…,bm)， 试写一个按下列规则合并A、B为线性表C的 算法，即使得
C=(a1,b1,a2,b2,…,am,bm,bm+1,…,bn) 当m<=n 或 C=(a1,b1,a2,b2,…,an,bn,an+1,…,am) 当m>n
线性表A、B和C均为单链表作存储结构，且C表 利用A表和B表中的结点空间构表。注意：单 链表的长度值m和n均未显式存储。
2020/10/13
8
算法：
status COMBINE(linklist A, linklist B, linklist &C) {
C=A; a=A->next; b=B->next;
if(j==B.length) //表示A.elem[i]不在B中，将其放到 C中
C.elem[k++]=A.elem[i]; } C.length=k; }
2020/10/13
3
作业1.2 试写一个算法，实现顺序表的就地 逆置。
实验任务书(8个)
目录实验1 线性表顺序存储的应用 (2)实验2 线性表链式存储的应用 (5)实验3 栈及其应用 (6)实验4 队列及其应用 (7)实验5 树及其应用 (8)实验6 图的遍历和连通性应用 (9)实验7 图的最短路径应用 (11)实验8 查找和排序应用 (12)实验1 线性表顺序存储的应用实验目的1．熟悉C语言的上机环境，掌握C语言的基本结构。
2．会定义线性表的顺序存储结构。
3．熟悉对顺序表的一些基本操作和具体的函数定义。
4．掌握在线性表的顺序存储结构上的一些其它操作。
实验要求1．独立完成；2．程序调试正确，有执行结果。
实验内容1、基础题：编写应用程序（填空），实现可以在顺序表中插入任意给定数据类型（定义为抽象数据类型）数据的功能。
要求在主函数中定义顺序表并对该顺序表插入若干个整数类型的数据（正整数），对它们求和并输出。
请使用动态内存分配的方式申请数组空间，并把主函数设计为一个文件SeqList.cpp，其余函数设计为另一个文件SeqList.h。
请填空完成以下给出的源代码并调试通过。
（1）文件SeqList.h:typedef struct List{ElemType *list;int size;int MaxSize;}SeqList;void InitList(SeqList &L){ //初始化线性表…………}void ClearList(SeqList &L){ //清除线性表………………}int LengthList(SeqList L){ //求线性表长度………..}bool InsertList(SeqList &L, ElemType item, int pos){ //按给定条件pos向线性表插入一个元素…….}ElemType GetList(SeqList L, int pos){ //在线性表L中求序号为pos的元素，该元素作为函数值返回…………..}（2）文件SeqList.cpp：#include <stdio.h>#include <stdlib.h>typedef ElemType;#define MAXSize 10#include "SeqList.h"void main(void){SeqList myList;int i=1, x, sum=0, n;InitList ( );scanf(“%d”, &x);while ( x!= -1 ){if ( InsertList (myList, , i )==0) {printf("错误!\n");return ;}i++;scanf(“%d”, &x);}n = LengthList (myList);for (i=1; i<=n; i++){x=GetList(myList, i);sum = + x;}printf("%d\n ", sum);ClearList(myList);}2、提高部分：编写函数bool DeleteElem(SeqList &L, int min, int max)实现从顺序表中删除其值在给定值min和max之间（min < max）的所有元素，要求把该函数添加到文件SeqList.h中，并在主函数文件SeqList.cpp中添加相应语句进行测试。
线性表大作业任务书
作业1：线性表一、作业目的1．了解线性表的逻辑结构特性，以及这种特性在计算机内的两种存储结构。
2．掌握线性表的顺序存储结构的定义及其C语言的实现。
3．掌握线性表的链式存储结构——单链表的定义及其C语言的实现。
4．掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5．掌握线性表在链式存储结构——单链表的各种基本操作。
二、作业要求1.认真阅读和掌握本实验的程序。
2.上机运行本程序。
3.保存和打印出程序的运行结果，并结合程序进行分析。
4.按照对线性表和单链表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果。
三、作业内容1. 顺序表的操作请编制C程序，利用顺序存储方式来实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；然后根据屏幕菜单的选择，可以进行表的创建，数据的插入删除并在插入和删除数据后再输出线性表；最后在屏幕菜单中选择0，即可结束程序的运行。
分析：当我们要在顺序表的第i个位置上插入一个元素时，必须先将线性表的第i个元素之后的所有元素一次后移一个位置，以便腾出一个位置，再把新元素插入到该位置。
当要删除第i个元素时，也只需将第i个元素之后的所有元素前移一个位置。
算法描述：对每个算法，都要写出算法的中文描述。
要求分别写出在第i个（从1开始计数）结点前插入数据为x的结点、删除指定结点、创建一个线性表。
打印线性表等的算法描述。
2.单链表的操作请编制C程序，利用链式存储方式来实现线性表的创建、插入、删除和查找等操作。
具体地说，就是要根据键盘输入的数据建立一个单链表；然后根据屏幕菜单的选择，可以进行数据的插入或删除，并在插入或删除数据后，再输出单链表；最后在屏幕菜单中选择0，即可结束程序的运行。
算法描述：要求分别写出在带头结点的单链表中第i（从1开始计数）个位置之后插入元素、创建带头结点的单链表、在带头结点的单链表中删除第i个位置的元素、顺序输出单链表的内容等的算法描述。
实验一：1.实验程序源代码#define TURE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#include<stdio.h>#include<stdlib.h>#define ML 1//线?性?表À¨ª#define TURE 1#define FALSE 0#define OK 1#define ERR 0typedef struct{int list[ML];int size;int MAXSIZE;}sqList;sqList *Init_List(sqList *L,int ms);void Disp_List(sqList *L);int LocateElem_List(sqList *L,int x);int Insert_List(sqList *L,int x,int mark);int Delete_List1(sqList *L,int item);int Delete_List2(sqList *L,int mark);sqList *Init_List(sqList *L,int ms){L=(sqList *)malloc(ms*sizeof(sqList));if(!L){printf("申¦¨º请?内¨²存ä?空?间?出?错䨪\n");exit(OVERFLOW);}elseL->size=0;L->MAXSIZE=ms;return L;}void Disp_List(sqList *L){int i;for(i=0;i<L->size;i++)printf("%d",L->list[i]);printf("\n");}int LocateElem_List(sqList *L,int x){int i=0;for(i=0;i<=L->size;i++)if(L->list[i]==x)return i;if(i>L->size)return -1;}int Insert_List(sqList *L,int x,int mark){int i=1;if(L->size>=L->MAXSIZE)return -1;if(mark>0){for(i=L->size+1;i>=mark;i--)L->list[i+1]=L->list[i];L->list[i]=x;}else if(mark<0)L->list[L->size]=x;L->size++;return FALSE;}int Delete_List1(sqList *L,int item){int i,j;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(j=i+1;j<L->size-1;j++)L->list[j]=L->list[j+1];L->size--;return i;}return FALSE;}int Delete_List2(sqList *L,int mark){int i,item;if(mark>0){item=L->list[mark];for(i=mark+1;i<L->size-1;i++)L->list[i]=L->list[i+1];L->size--;return i;}return FALSE;}void main(){int p,n,x=0;sqList a,*b;b=Init_List(&a,ML);printf("listaddr=%d\tsize=%d\tMaxSize=%d",b->list,b->size,b->MAXSIZE);while(1){printf("\n请?输º?入¨?值¦Ì，ê?0为a结¨¢束º?输º?入¨?：êo");scanf("%d",&x);if(!x) break;printf("\n请?输º?入¨?插?入¨?位?置?：êo\n");scanf("%d",&p);Insert_List(b,x,p);printf("\n线?性?表À¨ª为a：êo\n");Disp_List(b);}while(1){printf("\n请?输º?入¨?查¨¦找¨°值¦Ì，ê?输º?入¨?0结¨¢束º?查¨¦找¨°操¨´作Á¡Â：êo\n");scanf("%d",&x);if(!x) break;n=LocateElem_List(b,x);if(n<0) printf("\n没?找¨°到Ì?\n");elseprintf("\n又®?符¤?合?条¬?件t的Ì?值¦Ì，ê?位?置?为a：êo%d\n",n+1);}while(1){printf("\n请?输º?入¨?删¦?除y值¦Ì，ê?输º?入¨?0结¨¢束º?查¨¦找¨°操¨´作Á¡Â：êo\n");scanf("%d",&x);if(!x) break;n=Delete_List1(b,x);if(n<0)printf("\n没?找¨°到Ì?\n");else{printf("\n删¦?除y成¨¦功|，ê?线?性?表À¨ª为a:\n");Disp_List(b);}}while(1){printf("\n请?输º?入¨?删¦?除y值¦Ì位?置?，ê?输º?入¨?o结¨¢束º?查¨¦找¨°操¨´作Á¡Â:\n");scanf("%d",&p);if(!p) break;n=Delete_List2(b,p);if(p<0) printf("\n位?置?越?界?\n");else{printf("\n线?性?表À¨ª为a:\n");Disp_List(b);}}}2.实验运行图3.算法分析：（1）顺序表的初始化即是创造一个空表顺序表的初始化即构造一个空表，这对表是一个加工型的运算，因此，将L设为指针参数，首先动态分配存储空间，然后，将表中length指针置为0，表示表中没有数据元素。
实验一线性表操作实验报告
实验一_线性表操作_实验报告实验一：线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作，包括插入、删除、查找等。
3.通过实验，提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构，它包含零个或多个数据元素，相邻元素之间有前后关系。
线性表具有以下特点：1.元素之间一对一的顺序关系。
2.除第一个元素外，每个元素都有一个直接前驱。
3.除最后一个元素外，每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表：首先创建一个链表，并给链表添加若干个节点。
节点包括数据域和指针域，数据域存储数据，指针域指向下一个节点。
2.插入节点：在链表中插入一个新的节点，可以选择在链表的头部、尾部或中间插入。
3.删除节点：删除链表中的一个指定节点。
4.查找节点：在链表中查找一个指定数据的节点，并返回该节点的位置。
5.遍历链表：从头节点开始，依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果：我们成功地创建了一个链表，每个节点都有数据域和指针域，数据域存储数据，指针域指向下一个节点。
2.插入节点结果：我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1)，因为我们只需要修改指针域即可。
3.删除节点结果：我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果：我们成功地在链表中查找了一个指定数据的节点，并返回了该节点的位置。
查找操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果：我们成功地遍历了整个链表，并访问了每个节点的数据。
遍历操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表。
通过本次实验，我们更加深入地理解了线性表的基本概念和特点，掌握了线性表的基本操作，包括插入、删除、查找等。
西电数据结构大作业
题目：数据结构上机报告学院：电子工程学院专业：信息对抗技术学生姓名：甘佳霖学号：14020310092西安电子科技大学数据结构课程实验报告实验名称线性表电子工程学院 1402031 班Array姓名甘佳霖学号 14020310092同作者实验日期 2017 年 3 月 18 日实验一线性表一、实验目的1．熟悉线性表的顺序和链式存储结构2．掌握线性表的基本运算3．能够利用线性表的基本运算完成线性表应用的运算二、实验要求1.设有一个线性表E={e1, e2, … , e n-1, e n}，设计一个算法，将线性表逆置，即使元素排列次序颠倒过来，成为逆线性表E’={ e n, e n-1 , … , e2 , e1 }，要求逆线性表占用原线性表空间，并且用顺序表和单链表两种方法表示，分别用两个程序来完成。
2.已知由不具有头结点的单链表表示的线性表中，含有三类字符的数据元素（字母、数字和其他字符），试编写算法构造三个以循环链表表示的线性表，使每个表中只含有同一类的字符，且利用原表中的结点空间，头结点可另辟空间。
三、设计思路1.顺序表做逆置操作时将对应的首尾元素位置交换，单链表的指针end指向链表的末尾，指针start指向链表头结点，指针s用来找到指向end节点的节点，将指向链表末尾和头结点的存储内容交换，然后头结点指针指向下一节点，s指针从start节点开始遍历寻找指向end 指针的节点，并将end指针赋值为s指针，就完成了单链表的逆置，可以看出单链表和顺序表都可以完成线性表的逆置。
2.分解单链表的实现思路是首先新建3个循环链表，然后顺序遍历单链表，ASCII码判断链表中的元素属于哪一类元素，然后将这个元素添加到对应的循环链表中，从而实现分解单链表的功能。
四、运行结果1.单链表逆置：顺序表逆置：2.分解单链表五、实验总结线性表和单链表是最简单的、最常用的数据结构类型，是实现其他数据结构的基础，熟悉对它们的操作有助于后面对数据结构课程的学习和理解。
线性系统第二次大作业
目录第一章矩阵论基础........................................................................................... - 1 -1.1子空间与不变子空间 ........................................................................... - 1 -1.2 线性定常系统解的结构....................................................................... - 1 - 第二章控制论的相关概念 ............................................................................... - 2 -2.1稳定性理论........................................................................................... - 2 -2.2 能控性与能观性 .................................................................................. - 2 - 第三章基于不变子空间的系统分析 ................................................................ - 3 -3.1 不变子空间与系统的解集结构 ........................................................... - 3 -3.2不变子空间与能控能观性.................................................................... - 4 -3.2.1 不变子空间与能控性 ....................................................................... - 4 -3.3不变子空间与卡尔曼分解.................................................................... - 6 - 第四章BIBO稳定性和李雅普诺夫稳定的关系 ............................................ - 10 -4.1 BIBO稳定的充要条件....................................................................... - 10 -4.2 李雅普诺夫稳定的充要条件............................................................. - 10 -4.3 渐进稳定的充要条件 ........................................................................ - 11 -4.4 内部稳定必定BIBO稳定 ................................................................. - 11 -4.5 外部稳定不一定内部稳定................................................................. - 11 -4.6 临界稳定不一定BIBO稳定 ............................................................. - 12 -4.7 特定初态的内部稳定性..................................................................... - 14 -4.8 内部稳定与BIBO稳定等价条件...................................................... - 14 -4.9 初始状态，输入矩阵，输出矩阵对状态稳定的影响....................... - 15 - 第五章总结 .................................................................................................... - 17 - 第六章参考文献............................................................................................. - 18 -第一章 矩阵论基础1.1子空间与不变子空间1.1.1子空间设W 是数域P 上线性空间V 的非空子集，则W 是V 的线性子空间的充要条件是：a) 若,W W ∈+∈，则αβαβ b) ,W k P k W ∈∈∈，则αα1.2.1不变子空间设T 是线性空间V 的一个线性变换，又W 是V 的一个子空间，若对于任意W ∈，α都有T W ∈α，即：()T W W ⊂则称W 是线性变换T 的不变子空间。
严蔚敏《数据结构与算法》实验任务书.
第二章实验
1 线性表的顺序存储结构
一、实验目的
1、熟悉 C 语言的上机环境,进一步掌握 C 语言的结构特点。
2、掌握线性表的顺序存储结构的定义及 C 语言实现。
3、掌握线性表在顺序存储结构即顺序表中的各种基本操作。
4、利用线性表的顺序存储结构解决实际问题。
二实验内容
完成顺序表中的基本操作的实现
1建立顺序表并初始化。
2 在顺序表中插入一元素,并保持顺序表原有顺序不变。
3 删除顺序表中某元素,并保持顺序表原有顺序不变。
4按值查找顺序表。
5按位置查找顺序表。
2 线性表的链式存储结构
一、实验目的
1、掌握线性表的链式存储结构——单链表的定义及 C 语言实现。
2、理解和掌握单链表的类型定义方法和结点生成方法。
3、掌握线性表在链式存储结构——单链表中的各种基本操作。
4、利用线性表在链式存储结构解决实际问题。
二、实验内容
1、建立一个单链表,并从屏幕显示单链表元素列表。
2、删除链表某位置上的元素,并保持链表原有的顺序不变。
3、在链表中插入某个元素,并保持链表原有顺序不变。
4、输入一个元素,查找该元素是否在链表中。
3 设计实验
约瑟夫环算法
设有 n 个人坐在圆桌周围,从第 s 个人开始报数,报到 m 的人出列,然后再从下一个人开始报数,报到 m 的人又出列,┅如此重复, 直到所有的人都出列为止。
要求按出列的先后顺序输出每个人的信息。
计算机网络技术课程设计(大作业)任务书
上海电力学院课程设计（大型作业）任务书（2010/2011学年第1学期）课题名称计算机网络技术课程设计课题代码院（系）电自学院信控系专业自动化（含电站、核电运行方向）班级学生时间2011年1月14日~18日（第20周）老师签名：教研室主任（系主任）签名：一、设计目的计算机网络是理论性与实践性都很强的学科。
网络技术必须在学习原理和算法的基础上，通过严格的实验训练和实践演练才可能掌握。
计算机网络实践是本课程重要的动手操作的教学环节。
实践的目的是巩固授课內容和实践锻练。
实践不仅仅是让学生验证抽象的理论知识，更重要的是通过实验加强学生的实验手段与实践技能，培养学生分析问题、解决问题、应用知识的能力和创新精神，全面提高学生的综合素质。
二、设计内容、要求及组织形式1、掌握RJ-45网线接头的制作方法1) 双绞线的性能指标、分类2) RJ-45接头线序，各线的位置、作用3) 制作RJ-45接头的步骤、方法2、掌握路由器的使用方法1）路由器的主要功能2）如何配置和使用路由器3、掌握局域网的配置方法1）如果配置一个小型局域网络2）简述ping、ipconfig命令的使用方法4、掌握网络服务器配置方法1） IIS的安装、配置和使用方法2） WEB服务器的配置和使用方法5、个人网站制作1）网站主题和内容不限2）可使用Dreamweaver、Frontpage等工具，也可加入ASP、PHP代码及数据库功能三、设计进度安排（时间及地点）（1）本次课程设计时间：2011年1月14日至18日，答辩时间1月18日，并上交课程设计报告（每人1份）。
报告要求有标题、课程实践目的、实验内容、贴图、实践中的问题及收获（具体格式见格式举例）。
（2）每个班级一人一组，要求独立完成，可相互讨论，并参考各种资料。
（3）利用网络实验室的计算机网络设备，组建局域网，并配置各类服务器。
四、考核形式及成绩评定办法每位同学要上交一份完整的设计方案（统一用A4纸打印），内容一般应包括：（1）实验报告封面（2）设计题目（3）开发目的（4）设计方案以及论证（5）课程设计内容（6）网站制作的流程、成果的贴图等（7）结果评述或总结（对实验结果进行分析，对实验过程进行总结，系统改进升级建议或者提出新的方案等。
《面向对象程序设计》大作业要求和任务书范文
《面向对象程序设计》大作业要求和任务书一、目的和要求检验学生学习《面向对象程序设计》课程后的学习成果，对于软件程序设计主流方法和思想——面向对象程序设计方法和思想的牢固掌握和熟练应用是一个非常重要的检测，是后续实践课程得以顺利进行的必要保证，对学生的程序设计能力培养和软件工程能力的培养具有重要的作用和意义。
要求学生综合应用已学的相关知识，例如程序设计基本思想和方法、C++语言、面向对象程序设计思想和方法，通过对真实世界的模拟和抽象来解决一些比较简单的实际问题。
要求学生针对比较系统的题目进行编码、测试，并进行设计说明书的撰写，从而培养和锻炼学生初步的工程意识和做法。
加深对所学知识的理解和掌握，巩固课程学习的内容，培养学生掌握面向对象程序设计(OOP)的思想，锻炼其使用面向对象的程序设计思想分析和解决实际问题的能力，培养上机动手能力，培养文档报告书面表达和思辨的能力。
要求学生对自己学过的C++知识进行综合运用，要求要用到类的特性：即类的封装、类的抽象、继承和多态，编写一些小型的具有一定应用价值的程序，通过对真实世界的模拟和抽象来解决一些比较简单的实际问题；掌握在Visual C++集成开发环境下编辑、编译、链接和运行一个C++程序的基本方法。
二、任务内容参考后附的大作业题目，规定每位同学完成两道题目（第一个题目是计算机类，第二个题目从第2-4题中任选一题）。
针对所选题目完成如下具体任务：1. 问题分析和任务定义：根据设计题目的要求，充分地分析和理解问题，明确问题要求做什么？对功能进行说明；2. 类设计：综合考虑系统功能，对问题描述中涉及的操作对象定义相应的数据类型。
抽象数据类型的实现尽可能做到数据封装，充分运用继承、派生、多态等知识，给出用UML描述的类之间的关系图；3. 详细设计：给出各个主要模块的算法，并画出模块之间的调用关系图；要使得系统结构清晰、合理、简单和易于调试，写出主要函数的算法框架；4. 程序编码：把详细设计的结果进一步求精为程序设计语言程序。
实验一线性表.docx
本科实验报告课程名称：数据结构实验项目：线性结构、树形结构、图结构、查找、排序实验地点：逸夫楼502专业班级：软件1223班学号：2012005646 学生姓名：王萌指导教师：杨崇艳2013年11 月20日实验一线性表一．目的与要求1.实习的主要目的:2.要求:二．例题○1问题描述 :○2输入:○3输出:○4存储结构:○5算法的基本思想:○6程序:#define NULL 0typedef struct node{char a;struct node *link;}node,*nodelink;void readlink(nodelink head){nodelink p,q;char c;p=head;printf("Input a linktable(a string):");scanf("%c",&c);if (c=='\n') printf("This string is empty。
");while(c!='\n'){q=(nodelink)malloc(sizeof(node));q->a=c;p->link=q;p=q;scanf("%c",&c);}p->link=NULL;}void writelink(nodelink head){nodelink q;if (head->link==NULL) printf(" This link is empty。
\n");for(q=head->link;q;q=q->link)printf("%c",q->a);printf("\n");}int insert(nodelink head,char k1,char k2){nodelink p,q;p=head->link;while(p->a!=k1&&p)p=p->link;if(p){q=(nodelink)malloc(sizeof(node));q->a=k2;q->link=p->link;p->link=q;return 1;}else {printf("There is no %c\n",k1);return 0;}}int delete(nodelink head,char k){nodelink p,q;q=head;p=head->link;while(((p->a)!=k)&&p){q=q->link;p=p->link;}if(p){q->link=p->link;return 1;}else{printf("There is no %c\n",k);return 0;}}void opside(nodelink head){nodelink p,q;p=head->link;while(p->link){q=p->link;p->link=q->link;q->link=head->link;head->link=q;}}main(){char k1,k2,k3;nodelink head;head=(nodelink)malloc(sizeof(node));head->link=NULL;readlink(head);if (head->link!=NULL){printf("Build link is :");writelink(head); }if (head->link!=NULL){printf("Please input a char you want to insert after:");k1=getch();printf("%c\n",k1);printf("Please input a char you want to insert:");k2=getch();printf("%c\n",k2);if (insert(head,k1,k2)) {printf("After %c insert %c,link is:",k1,k2);writelink(head);}printf("Please input a char you want to delete:");k3=getch();printf("%c\n",k3);if (delete(head,k3)){ printf("after delete %c,link is:",k3);writelink(head);}if (head->link!=NULL){printf("Opsite result is :");opside(head);writelink(head);free(head);}}}○7调试结果：○8程序的优缺点、时空性能以及改进思想，写出心得体会。
数据结构实验：基于线性表的图书信息管理
void Count( LinkList L )；//输出数据个数的函数
O(1)
void Compare( LinkList L )；//比较价格函数
O(n)
void Average( LinkList L )；//求平均价格函数
O(n)
void Search_name( LinkList L )；//按照书名查找
当没有此书时会有提示7按照指定的位置查找图书信息当输入非法时有提示8在指定位置插入图书信息当位置不合法或者空间不足时有提示9删除指定位置的图书信息当输入位置不合法是提示10图书信息逆序链表1当输入超出菜单所给选项的数字时有提示2输出所有的图书信息3统计图书个数4查找价格最高的图书如果有多本书同时为最高价可全部输出5计算所有图书的平均价格6按书名查找图书可查找多本同名图书当无查找书籍信息时有提示7按输入位置查找图书信息当位置不合法是有提示8在指定位置插入信息当位置不合法是有提示9删除指定位置的图书信息当位置不合法是有提示10将所有图书信息逆序11将所有图书信息按照价格由高到低排序3
void MultiplyPolyn( Polynomial &Pa, Polynomial &Pb )；//一元多项式相乘
3. 主要功能算法的时间复杂度
⑴顺序表
函数名称
时间复杂度
Status InitList( SqList &L )；//顺序表初始化
O(1)
void Input( SqList &L )；//输入函数
提示
（7）按输入位置查找图书信息，当位置不合法是有提示
（8）在指定位置插入信息，当位置不合法是有提示
（9）删除指定位置的图书信息，当位置不合法是有提示
数据结构实验二 线性表
数据结构实验二线性表数据结构实验二线性表1. 实验目的1.1 理解线性表的概念和特性1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的基本操作：初始化、插入、删除、查找、修改、遍历等1.4 熟悉线性表的应用场景2. 实验内容2.1 线性表的顺序存储结构实现2.1.1 定义线性表结构体2.1.2 初始化线性表2.1.3 插入元素2.1.4 删除元素2.1.5 查找元素2.1.6 修改元素2.1.7 遍历线性表2.2 线性表的链式存储结构实现2.2.1 定义链表节点结构体2.2.2 初始化链表2.2.3 插入元素2.2.4 删除元素2.2.5 查找元素2.2.6 修改元素2.2.7 遍历链表3. 实验步骤3.1 实现顺序存储结构的线性表3.2 实现链式存储结构的线性表3.3 编写测试程序，验证线性表的各种操作是否正确3.4 进行性能测试，比较两种存储结构的效率差异4. 实验结果与分析4.1 执行测试程序，检查线性表的操作结果是否正确4.2 对比顺序存储结构和链式存储结构的性能差异4.3 分析线性表的应用场景，总结线性表的优缺点5. 实验总结5.1 总结线性表的定义和基本操作5.2 回顾实验中遇到的问题和解决方法5.3 提出对线性表实现的改进方向和思考附件：请参考附件中的源代码和实验报告模板。
法律名词及注释：1. 版权：指对某一作品享有的法律上的权利，包括复制权、发行权、改编权等。
2. 法律责任：指违反法律或合同规定所承担的责任。
3. 保密义务：指个人或组织根据法律、法规、合同等规定需要承担的保密责任。
4.知识产权：指人们在社会实践中所创造的智力劳动成果所享有的权利，包括专利权、著作权、商标权等。
数据结构实验二 线性表(2023版)
数据结构实验二线性表数据结构实验二线性表一、实验目的本实验的目的是通过编程实现线性表（顺序表和链表）的基本操作，并对其性能进行比较分析。
二、实验内容1.设计并实现顺序表的基本操作函数。
1.1 初始化顺序表1.2 插入元素1.3 删除元素1.4 查找元素1.5 修改元素1.6 获取顺序表长度1.7 输出顺序表2.设计并实现链表的基本操作函数。
2.1 初始化链表2.2 插入节点2.3 删除节点2.4 查找节点2.5 修改节点2.6 获取链表长度2.7 输出链表3.比较分析顺序表和链表的性能差异。
三、实验原理1.顺序表是使用一段连续的内存存储数据，插入、删除时需要移动大量元素，但随机访问、查找等操作效率较高。
2.链表是使用多个结点通过指针进行连接，插入、删除时只需修改结点指针，但随机访问、查找等操作效率较低。
四、实验步骤1.设计顺序表结构及基本操作函数。
1.1 初始化顺序表：分配内存空间，设置长度为0。
1.2 插入元素：判断插入位置的合法性，移动后续元素，插入新元素。
1.3 删除元素：判断删除位置的合法性，移动后续元素，减少表长度。
1.4 查找元素：遍历表中元素，找到匹配位置。
1.5 修改元素：判断修改位置的合法性，修改指定位置元素的值。
1.6 获取顺序表长度：返回表中元素的个数。
1.7 输出顺序表：遍历表中元素，输出各个元素的值。
2.设计链表结构及基本操作函数。
2.1 初始化链表：分配头结点内存。
2.2 插入节点：创建新节点，修改前后节点指针。
2.3 删除节点：查找目标节点，修改前后节点指针，释放资源。
2.4 查找节点：遍历链表，找到匹配节点。
2.5 修改节点：查找目标节点，修改节点值。
2.6 获取链表长度：遍历链表，返回节点个数。
2.7 输出链表：遍历链表，输出各个节点的值。
3.调用相关函数进行测试，比较顺序表和链表的性能。
五、实验结果与分析通过测试，我们得到了以下实验结果和分析：1.顺序表的插入和删除操作需要移动大量元素，当数据规模较大时，效率较低。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
作业1：线性表一、作业目的1．了解线性表的逻辑结构特性，以及这种特性在计算机的两种存储结构。
2．掌握线性表的顺序存储结构的定义及其C语言的实现。
3．掌握线性表的链式存储结构——单链表的定义及其C语言的实现。
4．掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5．掌握线性表在链式存储结构——单链表的各种基本操作。
二、作业要求1.认真阅读和掌握本实验的程序。
2.上机运行本程序。
3.保存和打印出程序的运行结果，并结合程序进行分析。
4.按照对线性表和单链表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果。
三、作业容1. 顺序表的操作请编制C程序，利用顺序存储方式来实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；然后根据屏幕菜单的选择，可以进行表的创建，数据的插入删除并在插入和删除数据后再输出线性表；最后在屏幕菜单中选择0，即可结束程序的运行。
分析：当我们要在顺序表的第i个位置上插入一个元素时，必须先将线性表的第i个元素之后的所有元素一次后移一个位置，以便腾出一个位置，再把新元素插入到该位置。
当要删除第i个元素时，也只需将第i个元素之后的所有元素前移一个位置。
算法描述：对每个算法，都要写出算法的中文描述。
要求分别写出在第i 个（从1开始计数）结点前插入数据为x的结点、删除指定结点、创建一个线性表。
打印线性表等的算法描述。
2.单链表的操作请编制C程序，利用链式存储方式来实现线性表的创建、插入、删除和查找等操作。
具体地说，就是要根据键盘输入的数据建立一个单链表；然后根据屏幕菜单的选择，可以进行数据的插入或删除，并在插入或删除数据后，再输出单链表；最后在屏幕菜单中选择0，即可结束程序的运行。
算法描述：要求分别写出在带头结点的单链表中第i（从1开始计数）个位置之后插入元素、创建带头结点的单链表、在带头结点的单链表中删除第i个位置的元素、顺序输出单链表的容等的算法描述。
实验一：1.实验程序源代码#define TURE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2#include<stdio.h>#include<stdlib.h>#define ML 1//线?性?表À¨ª#define TURE 1#define FALSE 0#define OK 1#define ERR 0typedef struct{int list[ML];int size;int MAXSIZE;}sqList;sqList *Init_List(sqList *L,int ms);void Disp_List(sqList *L);int LocateElem_List(sqList *L,int x);int Insert_List(sqList *L,int x,int mark);int Delete_List1(sqList *L,int item);int Delete_List2(sqList *L,int mark);sqList *Init_List(sqList *L,int ms){L=(sqList *)malloc(ms*sizeof(sqList));if(!L){printf("申¦¨º请?¨²存ä?空?间?出?错䨪\n");exit(OVERFLOW);}elseL->size=0;L->MAXSIZE=ms;return L;}void Disp_List(sqList *L){int i;for(i=0;i<L->size;i++)printf("%d",L->list[i]);printf("\n");}int LocateElem_List(sqList *L,int x){int i=0;for(i=0;i<=L->size;i++)if(L->list[i]==x)return i;if(i>L->size)return -1;}int Insert_List(sqList *L,int x,int mark){int i=1;if(L->size>=L->MAXSIZE)return -1;if(mark>0){for(i=L->size+1;i>=mark;i--)L->list[i+1]=L->list[i];L->list[i]=x;}else if(mark<0)L->list[L->size]=x;L->size++;return FALSE;}int Delete_List1(sqList *L,int item){int i,j;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(j=i+1;j<L->size-1;j++)L->list[j]=L->list[j+1];L->size--;return i;}return FALSE;}int Delete_List2(sqList *L,int mark){int i,item;if(mark>0){item=L->list[mark];for(i=mark+1;i<L->size-1;i++)L->list[i]=L->list[i+1];L->size--;return i;}return FALSE;}void main(){int p,n,x=0;sqList a,*b;b=Init_List(&a,ML);printf("listaddr=%d\tsize=%d\tMaxSize=%d",b->list,b->size,b->MAXSIZE);while(1){printf("\n请?输º?入¨?值¦Ì，ê?0为a结¨¢束º?输º?入¨?：êo");scanf("%d",&x);if(!x) break;printf("\n请?输º?入¨?插?入¨?位?置?：êo\n");scanf("%d",&p);Insert_List(b,x,p);printf("\n线?性?表À¨ª为a：êo\n");Disp_List(b);}while(1){printf("\n请?输º?入¨?查¨¦找¨°值¦Ì，ê?输º?入¨?0结¨¢束º?查¨¦找¨°操¨´作Á¡Â：êo\n");scanf("%d",&x);if(!x) break;n=LocateElem_List(b,x);if(n<0) printf("\n没?找¨°到Ì?\n");elseprintf("\n又®?符¤?合?条¬?件t的Ì?值¦Ì，ê?位?置?为a：êo%d\n",n+1);}while(1){printf("\n请?输º?入¨?删¦?除y值¦Ì，ê?输º?入¨?0结¨¢束º?查¨¦找¨°操¨´作Á¡Â：êo\n");scanf("%d",&x);if(!x) break;n=Delete_List1(b,x);if(n<0)printf("\n没?找¨°到Ì?\n");else{printf("\n删¦?除y成¨¦功|，ê?线?性?表À¨ª为a:\n");Disp_List(b);}}while(1){printf("\n请?输º?入¨?删¦?除y值¦Ì位?置?，ê?输º?入¨?o结¨¢束º?查¨¦找¨°操¨´作Á¡Â:\n");scanf("%d",&p);if(!p) break;n=Delete_List2(b,p);if(p<0) printf("\n位?置?越?界?\n");else{printf("\n线?性?表À¨ª为a:\n");Disp_List(b);}}}2.实验运行图3.算法分析：（1）顺序表的初始化即是创造一个空表顺序表的初始化即构造一个空表，这对表是一个加工型的运算，因此，将L设为指针参数，首先动态分配存储空间，然后，将表中length指针置为0，表示表中没有数据元素。
算法如下：Status InitList_Sq(SqList *L){L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//分配存储空间if(!L->elem) exit(OVERFLOW); //存储分配失败L->length=0; //空表长度为0L->listsize=LIST_INIT_SIZE; //初始存储容量return OK;} // InitList_Sq此算法的时间复杂度为O(1)。