数据结构线性表的应用实验报告
数据结构线性表实验报告

实验报告实验一线性表实验目的:1. 理解线性表的逻辑结构特性;2. 熟练掌握线性表的顺序存储结构的描述方法,以及在该存储结构下的基本操作;并能灵活运用;3. 熟练掌握线性表的链表存储结构的描述方法,以及在该存储结构下的基本操作;并能灵活运用;4•掌握双向链表和循环链表的的描述方法,以及在该存储结构下的基本操作。
实验原理:线性表顺序存储结构下的基本算法;线性表链式存储结构下的基本算法;实验内容:2 - 21设计单循环链表,要求:(1 ) 单循环链表抽象数据类型包括初始化操作、求数据元素个数操作、插入操作、删除操作、取消数据元素操作和判非空操作。
(2 ) 设计一个测试主函数,实际运行验证所设计单循环链表的正确性。
2 — 22 .设计一个有序顺序表,要求:(1 ) 有序顺序表的操作集合有如下操作:初始化、求数据元素个数、插入、删除和取数据元素。
有序顺序表与顺序表的主要区别是:有序顺序表中的数据元素按数据元素值非递减有序。
(2 ) 设计一个测试主函数,实际运行验证所设计有序顺序表的正确性。
(3) 设计合并函数ListMerge ( L1,L2,L3 ),功能是把有序顺序表 L1和L2中的数据元素合并到L3,要求L3中的数据元素依然保持有序。
并设计一个主函数,验证该合并函数的正确性。
程序代码:2-21 (1)头文件 LinList.h 如下:typedef struct node{DataType data;struct node *next;}SLNode;/* ( 1 )初始化 ListInitiate(SLNode * * head)*/void ListInitiate(SLNode * * head){ /* 如果有内存空间,申请头结点空间并使头指针 head 指向头结点 */if((*head=(SLNode *)malloc(sizeof(SLNode)))==NULL)exit(1);(*head)->next=NULL; /* 置结束标记 NULL*/}/*(2) 求当前数据元素个数 ListLength(SLNode * head)*/int ListLength(SLNode * head){SLNode *p=head;int size=0;while(p->next!=head){p=p->next;size++;}return size;}/*(3) 插入 ListInsert(SLNode * head , int i , DataType x)*//* 在带头结点的单链表的第 i(0<=i<=size) 个结点前 *//* 插入一个存放数据元素 x 的结点。
数据结构实验报告-线性表(顺序表实现)

实验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、实验目的(1)熟悉将算法转换为程序代码的过程。
(2)了解顺序表的逻辑结构特性,熟练掌握顺序表存储结构的C 语言描述方法。
(3)熟练掌握顺序表的基本运算:查找、插入、删除等,掌握顺序表的随机存取特性。
(4)了解线性表的链式存储结构,熟练掌握线性表的链式存储结构的C语言描述方法。
(5)熟练掌握线性链表(单链表)的基本运算:查找、插入、删除等,能在实际应用中灵活选择适当的链表结构。
2、实验要求(1)熟悉顺序表的插入、删除和查找。
(2)熟悉单链表的插入、删除和查找。
3、实验内容: ① 顺序表(1)抽象数据类型定义typedef struct {TypeData data[maxsize];//容量为maxsize的静态顺手表int n;//顺序表中的实际元素个数}SeqList;//静态顺序表的定义在本次实验中,首先建立一个空的静态顺序表,然后键盘输入数据存入表中,然后进入菜单选择界面,通过不同的数字输入,实现对顺序表,删除,插入,查找,显示等操作。
(2)存储结构定义及算法思想在顺序表结构体的定义中,typedef int TypeData 为整型,存储结构如下:for(n=0;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似,都是直接赋值与数组的某一位插入版块子函数:void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<k=L.data[b-1];L.data[b-1]=a;c=L.n;L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--;//通过循环,实现插入位置后的数据挨个往后移动一位}L.data[b]=k;} 顺序表的插入与删除操作类似,在插入与删除后,都要循环调整后面数组的每一位元素,同时记录数据元素的长度的标示符也要跟着改变。
数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告1.简介本实验报告旨在介绍数据结构中线性表的实现和应用。
线性表是一种重要的数据结构,它的特点是数据元素之间存在一对一的前后关系,且具有唯一的起点和终点。
本实验通过实现线性表的基本操作,加深对线性表的理解,并通过实例应用展示线性表在实际问题中的应用。
2.实验环境本次实验采用的是编程语言C,并搭配使用一些常用的开发工具和库。
具体环境如下:________●操作系统:________Windows 10●编程语言:________C●开发工具:________Visual Studio Code●辅助库:________Stdio.h、stdlib.h、conio.h3.实验内容3.1 线性表的定义和基本操作3.1.1 线性表的定义线性表是由n(n ≥ 0)个数据元素组成的有限序列,数据元素之间存在一对一的前后关系。
3.1.2 线性表的基本操作●初始化线性表:________创建一个空的线性表。
●插入元素:________在指定位置插入一个新的元素。
●删除元素:________删除指定位置的元素。
●查找元素:________根据值或位置查找指定元素。
●修改元素:________根据位置修改指定元素的值。
●清空线性表:________将线性表中的所有元素清空。
3.2 线性表的顺序存储结构3.2.1 顺序存储结构的定义顺序存储结构是指使用一段连续的存储空间,依次存储线性表中的元素。
3.2.2 顺序存储结构的实现●初始化顺序表:________创建一个空的顺序表,并指定最大容量。
续元素依次后移。
●删除元素:________删除指定位置的元素,并将后续元素依次前移。
●查找元素:________根据值或位置查找指定元素,并返回其位置或值。
●修改元素:________根据位置修改指定元素的值。
●清空顺序表:________将顺序表中的所有元素清空。
●扩容:________当顺序表容量不足时,自动进行扩容。
(完整版)数据结构线性表的应用实验报告

实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的:掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
2.实验内容:1)编写函数,实现用链表结构建立多项式;2)编写函数,实现多项式的加法运算;3)编写函数,实现多项式的显示;4)测试:编写主函数,它定义并建立两个多项式,显示两个多项式,然后将它们相加并显示结果。
变换测试用的多项式,检查程序的执行结果。
选做内容:修改程序,选择实现以下功能:5)多项式求值:编写一个函数,根据给定的x值计算并返回多项式f(x)的值。
测试该函数(从终端输入一个x的值,调用该函数并显示返回结果)。
6)多项式相减:编写一个函数,求两个多项式相减的多项式。
7)多项式相乘:编写一个函数,求两个多项式的乘积多项式。
3.算法说明:1)多项式的建立、显示和相加算法见讲义。
可修改显示函数,使输出的多项式更符合表达规范。
2)多项式减法:同次项的系数相减(缺项的系数是0)。
例如a(x)=-5x2+2x+3,b(x)= -4x3+3x,则a(x)-b(x)=4x3-5x2-x+3。
提示:a(x)-b(x) = a(x)+(-b(x))。
3)多项式乘法:两个多项式的相乘是“系数相乘,指数相加”。
算法思想是用一个多项式中的各项分别与另一个多项式相乘,形成多个多项式,再将它们累加在一起。
例如,a(x)=-5x2+2x+3,b(x)=-4x3+3x,则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。
数据结构《线性表的应用》实验报告

实验报告——线性表应用一、实验目的用单链表储存一元多项式,并实现两个多项式的相加运算。
二、实验内容1.先创建链表,存储多项式;2.输出多项式;3.两个多项式相加;4.输出多项式。
三、程序代码#include <stdio.h>#include <stdlib.h>#include <math.h>//一元多项式链式储存的节点结构typedef struct Polynode{float coef;int exp;struct Polynode * next;} Polynode , * Polylist;//建立一元多项式的链表Polylist polycreate(){Polynode * head,* rear,* s;float c;int e;head=(Polynode* )malloc(sizeof(Polynode));rear=head;scanf("%f,%d",&c,&e);while(c!=0){s=(Polynode * )malloc(sizeof(Polynode));s->coef=c;s->exp=e;rear->next=s;rear=s;scanf("%f,%d",&c,&e);}rear->next=NULL;return(head);}//输出多项式void print(Polynode*L){Polynode*p;p=L->next;printf("a=");if(p&&p->coef!=0)printf("%.2f*x^%d",p->coef,p->exp);while(p->next!=NULL){if((p->next->coef)>0&&p)printf("+");elseprintf("-");p=p->next;printf("%.2f*x^%d",fabs(p->coef),p->exp);}}//多项式相加void polyadd(Polylist polya,Polylist polyb){Polynode*p,*q,*tail,*temp;int sum;p=polya->next;q=polyb->next;tail=polya;while (p!=NULL&&q!=NULL){if(p->exp<q->exp){tail ->next=p; tail=p;p=p->next;}else if (p->exp==q->exp);{sum=p->coef+q->coef;if(sum!=0){p->coef=sum;tail->next=p;tail=p;p=p->next;temp=q;q=q->next;free(temp);}else{temp=p;p=p->next;free(temp);temp=q;q=q->next;free(temp);}}{tail ->next=q;tail=q;q=q->next;}}if(p!=NULL)tail->next=p;elsetail->next=q;}void main(){Polynode*a,*b;printf("输入a的系数和指数:\n");a = polycreate();print(a);printf("\n");printf("输入b的系数和指数:\n");b = polycreate();print(b);printf("\n");polyadd(a,b);printf("两个多项式的和为:\n");print(a);}四、实验结果五、实验过程中遇到的问题及处理方法程序运行时,在中文状态下输入“,”回车后就不能再输入了,应在英文状态下输入“,”。
数据结构实验报告线性表

数据结构实验报告线性表数据结构实验报告:线性表引言:数据结构是计算机科学中的重要概念,它涉及到如何组织和存储数据,以及如何有效地操作和管理这些数据。
线性表是数据结构中最基本的一种,它是一种有序的数据元素集合,其中的元素之间存在着一对一的关系。
一、线性表的定义和特点线性表是由n个数据元素组成的有限序列,其中n为表的长度。
这些数据元素可以是相同类型的,也可以是不同类型的。
线性表中的数据元素按照一定的顺序排列,并且每个数据元素都有唯一的前驱和后继。
线性表的特点有以下几个方面:1. 数据元素之间是一对一的关系,即每个数据元素只有一个直接前驱和一个直接后继。
2. 线性表中的元素是有序的,每个元素都有一个确定的位置。
3. 线性表的长度是有限的,它的长度可以是0,也可以是任意正整数。
二、线性表的实现方式线性表可以使用不同的数据结构来实现,常见的实现方式有数组和链表。
1. 数组实现线性表:数组是一种连续存储的数据结构,它可以用来存储线性表中的元素。
数组的优点是可以快速访问任意位置的元素,但是插入和删除操作需要移动其他元素,效率较低。
2. 链表实现线性表:链表是一种非连续存储的数据结构,它通过指针将线性表中的元素链接起来。
链表的优点是插入和删除操作简单高效,但是访问任意位置的元素需要遍历链表,效率较低。
三、线性表的基本操作线性表的基本操作包括插入、删除、查找和修改等。
1. 插入操作:插入操作用于向线性表中插入一个新元素。
具体步骤是先将插入位置后面的元素依次后移,然后将新元素插入到指定位置。
2. 删除操作:删除操作用于从线性表中删除一个元素。
具体步骤是先将删除位置后面的元素依次前移,然后将最后一个元素删除。
3. 查找操作:查找操作用于在线性表中查找指定元素。
具体步骤是从线性表的第一个元素开始逐个比较,直到找到匹配的元素或者到达线性表的末尾。
4. 修改操作:修改操作用于修改线性表中的某个元素的值。
具体步骤是先查找到要修改的元素,然后将其值更新为新值。
数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告实验目的:本次实验主要是为了学习和掌握线性表的基本操作和实现方式。
通过实验,我们可以加深对线性表的理解,并能够熟悉线性表的基本操作。
实验设备与环境:本次实验所需的设备包括计算机和编程环境。
我们选择使用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. 熟悉线性表的顺序存储结构和链式存储结构;4. 分析不同存储结构的优缺点。
实验内容:1. 实现线性表的顺序存储结构顺序存储结构是将线性表的元素按照其逻辑顺序依次存放在一块连续的存储空间中。
我们可以使用数组来实现顺序存储结构。
首先,定义一个固定大小的数组作为线性表的存储空间,然后通过数组的下标来访问和操作线性表中的元素。
在插入和删除元素时,需要移动其他元素的位置,以保持线性表的有序性。
2. 实现线性表的链式存储结构链式存储结构是将线性表的元素存储在一系列的结点中,每个结点包含一个数据元素和一个指向下一个结点的指针。
通过将各个结点用指针连接起来,形成一个链表。
在插入和删除元素时,只需要修改相邻结点之间的指针,而不需要移动其他元素的位置。
实验步骤:1. 实现顺序存储结构的线性表首先,定义一个固定大小的数组,用于存储线性表的元素。
然后,实现插入、删除、查找等基本操作。
在插入元素时,需要判断线性表是否已满,如果已满则需要扩容。
在删除元素时,需要判断线性表是否为空,如果为空则无法删除元素。
通过实现这些基本操作,可以对线性表进行增删查改等操作。
2. 实现链式存储结构的线性表首先,定义一个结点类,包含一个数据元素和一个指向下一个结点的指针。
然后,通过将各个结点用指针连接起来,形成一个链表。
实现插入、删除、查找等基本操作。
在插入元素时,需要找到插入位置,并修改相邻结点之间的指针。
在删除元素时,需要找到待删除元素的前一个结点,并修改前一个结点的指针。
数据结构实验报告(一)线性表的应用

数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。
⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。
(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。
(3)当给定x的值时,能计算表达式相加或相减的结果。
(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。
(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。
2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。
(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。
因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。
综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。
3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。
数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告1.实验目的1.1 理解线性表的概念和操作方法1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的各种基本操作算法2.实验内容2.1 实现线性表的顺序存储结构a. 定义顺序存储结构的数据类型和长度b. 实现线性表的初始化操作c. 实现线性表的插入操作d. 实现线性表的删除操作e. 实现线性表的查找操作2.1.6 实现线性表的更新操作2.1.7 实现线性表的打印操作2.2 实现线性表的链式存储结构a. 定义链式存储结构的数据类型和长度b. 实现线性表的初始化操作c. 实现线性表的插入操作d. 实现线性表的删除操作e. 实现线性表的查找操作2.2.6 实现线性表的更新操作2.2.7 实现线性表的打印操作2.3 实现线性表的其他操作a. 实现线性表的长度计算b. 实现线性表的合并操作c. 实现线性表的排序操作3.实验步骤3.1 初始化线性表a. 选择合适的存储结构b. 设置线性表的初始状态c. 完成线性表的初始化工作3.2 插入操作a. 根据线性表的存储结构选择插入点b. 将要插入的元素放入插入点位置c. 调整线性表的长度和位置3.3 删除操作a. 根据线性表的存储结构选择删除点b. 删除指定位置的元素c. 调整线性表的长度和位置3.4 查找操作a. 根据线性表的存储结构选择查找方法b. 实现线性表的按值查找3.4.3 实现线性表的按位置查找3.5 更新操作a. 根据线性表的存储结构选择更新点b. 更新指定位置的元素c. 调整线性表的长度和位置3.6 打印操作a. 根据线性表的存储结构选择打印方法b. 实现线性表的打印功能4.实验结果4.1 实现了线性表的顺序存储结构,包括初始化、插入、删除、查找、更新和打印功能4.2 实现了线性表的链式存储结构,包括初始化、插入、删除、查找、更新和打印功能4.3 实现了线性表的其他操作,包括长度计算、合并和排序操作5.实验总结5.1 通过本次实验,掌握了线性表的基本概念和操作方法5.2 熟悉了线性表的顺序存储结构和链式存储结构的实现方式5.3 熟练使用了线性表的各种基本操作算法附件:●附件1:代码实现●附件2:实验数据法律名词及注释:1.著作权:著作权是指作者对其创作的文学、艺术和科学等作品享有的法律权利。
数据结构实验报告-线性表

1 线性表1. 实验题目与环境1.1实验题目及要求(1)顺序表的操作利用顺序存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。
(2)单链表的操作利用链式存储方式实现下列功能:根据键盘输入数据建立一个线性表,并输出该线性表;对该线性表进行数据的插入、删除、查找操作,并在插入和删除数据后,再输出线性表。
(3)线性表的应用约瑟夫环问题。
有n个人围坐一圈,现从某个人开始报数,数到M的人出列,接着从出列的下一个人开始重新报数,数到M的人又出列,如此下去,直到所有人都出列为止。
要求依次输出出列人的编码。
2.问题分析(1)顺序表的操作利用一位数组来描述顺序表,即将所有元素一词储存在数组的连续单元中,要在表头或中间插入一个新元素时,需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。
同理,删除开头或中间的元素时,则将其后的所有元素向前移动一个位置以填补空位。
查找元素时,则需要利用循环语句,一一判断直到找出所要查找的元素(或元素的位置),输出相关内容即可(2)单链表的操作利用若干个结点建立一个链表,每个节点有两个域,即存放元素的数据域和存放指向下一个结点的指针域。
设定一个头指针。
在带头结点的单链表中的第i个元素之前插入一新元素,需要计数找到第i-1个结点并由一指针p指向它,再造一个由一指针s指向的结点,数据为x,并使x的指针域指向第i个结点,最后修改第i-1个结点的指针域,指向x结点。
删除第i个元素时,需要计数寻找到第i个结点,并使指针p指向其前驱结点,然后删除第i个结点并释放被删除结点的空间。
查找第i个元素,需从第一个结点开始计数找到第i个结点,然后输出该结点的数据元素。
(3)线性表的应用程序运行之后,首先要求用户指定初始报数的上限值,可以n<=30,此题中循环链表可不设头结点,而且必须注意空表和"非空表"的界限。
实验一线性表操作实验报告

实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作,包括插入、删除、查找等。
3.通过实验,提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。
线性表具有以下特点:1.元素之间一对一的顺序关系。
2.除第一个元素外,每个元素都有一个直接前驱。
3.除最后一个元素外,每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。
节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。
3.删除节点:删除链表中的一个指定节点。
4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。
5.遍历链表:从头节点开始,依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。
3.删除节点结果:我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。
查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。
遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。
通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。
数据结构线性表操作实验报告

《数据结构》实验报告实验题目:线性表的操作实验目的:1.掌握上机调试线性表的基本方法;2.掌握线性表的一些基本操作;实验内容:将两个有序链表合并为一个有序链表一、需求分析1.实验程序中先创建两个有序链表,演示程序以用户和计算机的对话方式执行,即在计算机终端上显示“提示信息”之后,由用户在键盘上输入两个链表中的相应数据。
2.将两个链表合并时可按数据从大到小或从小到大合并,用户根据提示可选择一种排序方式。
3.程序执行命令包括:(1)构造链表;(2)输入数据;(3)合并两个链表,根据用户需求选择一种排序方式;(4)将合并结果输出;(5)结束4.测试数据:链表1数据为:2,4,6,7,10链表2数据为:1,3,5,6,7,12按从小到达合并为:1,2,3,4,5,6,6,7,7,10,12;按从大到小合并为:12,10,7,7,6,6,5,4,3,2,1;二、概要设计1.基本操作Linklist creat ()操作结果:构造一个链表,并输入数据,返回头节点指针。
void print(Linklist head)初始条件:链表已存在;操作结果:将链表输出。
void MergeList_1(Linklist La,Linklist Lb)初始条件:有序线性链表La 和Lb 已存在;操作结果:将La 和Lb 两个链表按从小到大的顺序合并。
void MergeList_2(Linklist La,Linklist Lb)初始条件:有序线性链表La 和Lb 已存在;操作结果:将La 和Lb 两个链表按从大到小的顺序合并。
2.本程序包括四个模块:(1)主程序模块;(2)链表数据输入模块;(3)链表合并模块;(4)链表输出模块;三、详细设计1.元素类型,节点类型,指针类型主程序模块 数据输入 按从小到大合并两链表 按从大到小合并两链表 将新链表输出 将新链表输出typedef struct LNode //定义节点{int data;struct LNode *next;}LNode,* Linklist;2.每个模块的分析(1)主函数模块int main(){Linklist head1,head2;int i;printf("请输入链表1数据(由小到大,输入0表示输入结束):\n");head1=creat(); //创建链表1,将头结点指针返回为head1printf("请输入链表2数据(由小到大,输入0表示输入结束):\n");head2=creat();printf("请选择排序方式(输入1则从小到达合并,输入其它整数则按从大到小合并):");scanf("%d",&i); //创建链表2,将头结点指针返回为head2if(i==1) //选择两种排序方式,如果输入1,则合并后按从小到大输出;输入其它数,合成链表按从大到小输出{printf("按小到大将两表合并得:\n");MergeList1(head1,head2); //将创建好的两表的头结点地址head1,head2作为函数参数}else{ printf("按从大到小将两表合并得:\n");MergeList2(head1,head2); //将创建好的两表的头结点地址head1,head2作为函数参数}return 0;}(2)数据输入创建链表模块Linklist creat() //创建链表函数,并将创建链表的头结点指针返回{Linklist head,p,s;int z=1,x;head=(LNode *) malloc(sizeof(LNode));p=head;while(z){scanf("%d",&x);if(x!=0) //输入0表示链表数据输入结束{s=(LNode *)malloc(sizeof(LNode));s->data=x;p->next=s;s->next=NULL;p=s;}elsez=0;}return(head);}(3)合并链表模块,两个函数分别表示两种排序方式,将链表合并后直接在函数中调用链表输出函数void print(Linklist head)将链表输出void MergeList_1(Linklist La,Linklist Lb)//已知链表La和Lb元素都按从小到大排列,将La和Lb合并成新链表,其中元素也按从小到大排列{Linklist pa,pb,pc,Lc;pa = La->next; pb = Lb->next;Lc = pc = La; //把La的头节点作为新建链表Lc的头结点while (pa && pb){if (pa->data <= pb->data){pc->next = pa;pc = pa;pa = pa->next;}else{pc->next = pb;pc = pb;pb = pb->next;}}pc->next = pa ? pa : pb; //插入剩余段print(Lc); //将链表Lc输出}void MergeList_2(Linklist La,Linklist Lb)//已知链表La和Lb的元素都按从小到大排列,合并La和Lb得到新链表,其中元素按照从大到小的顺序排列{Linklist pa,qa,pb,qb,Lc; //设指针qa,qb,分别作为pa,pb的前驱的指针pa=La->next;pb=Lb->next;Lc=La;Lc->next=NULL;while(pa&&pb){if(pa->data<=pb->data){qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}else{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}}while(pa) //如果pa不为空,则将La链的剩余段倒叙插入到头节点的后面{qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}while(pb) //如果pb不为空,则将Lb链的剩余段倒叙插入到头结点的后面{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}print(Lc); //将新合成的链表Lc输出}(4)链表输出模块,实现最终链表的输出void print(Linklist head) //链表输出函数,将链表输出{LNode *p;p=head->next;if(head!=NULL)do{printf("%d ",p->data);p=p->next;} while (p);printf("\n");四、程序使用说明及测试结果1.程序使用说明(1)本程序的运行环境为VC6.0;(2)进入演示程序后显示提示信息:请输入链表1数据(由小到大,输入0表示输入结束):按要求输入数据请输入链表2数据(由小到大,输入0表示输入结束):按要求输入数据请选择排序方式(输入1则从小到达合并,输入其它整数则按从大到小合并):输入数据选择合并方式2.测试结果对链表1输入数据2,4,6,7,10,0对链表2输入数据1,3,5,6,7,12,0输入数据选择排序方式:如果输入:1 输出结果为:1,2,3,4,5,6,6,7,7,10,12如果输入:3(整数非1)输出结果为:12,10,7,7,6,6,5,4,3,2,13.调试中遇到的错误分析第一次运行时有问题,看以看出它的排序方式是对的,但是输出是多出前面一个很大的数,可能是输出函数void print(Linklist head)有问题,检查程序:此处逻辑出错,直接将p指针指向head,然后就将p->data输出,因此第一个数是头指针head所对应节点的值,所以可将p=head;改为p=head->next;这样p就指向第一个节点。
数据结构线性表实验报告五篇

数据结构线性表实验报告五篇第一篇:数据结构线性表实验报告实验报告课程名:数据结构实验名:线性表及其操作姓名:班级:学号:撰写时间:2014.09.24一实验目的与要求1.掌握线性表的实现2.掌握线性表的基本操作的实现二实验内容• 分别完成线性表的顺序表示及链式表示• 在两种表示上, 分别实现一些线性表的操作, 至少应该包括–在第i个位置插入一个元素–删除第i个元素–返回线性表长–返回第i个元素的值三实验结果与分析#include #include //---------线性表链式表示-----------struct V//声明一个结构体类型struct V { int value;struct V * next;//定义结构体变量};void PrintLink(struct V*p)//定义一个结构体指针{ while(p!=NULL)//只要指针指向的变量不为NULL;就会一直循环链表指向下一个结构体{printf(“%d, ”,(*p).value);p=(*p).next;//指针指向下一个结构体} printf(“n”);} void Link(){struct V*head;head=(struct V*)malloc(sizeof(struct V));//开辟一个长度为size的内存(*head).value=-100;//表头为-100(*head).next=NULL;printf(“------------线性表链式表示------------n”);int i,n=10;struct V*p=head;printf(“10个数据:n”);for(i=0;i(*p).next=(struct V*)malloc(sizeof(struct V));p=(*p).next;(*p).value=2*i;(*p).next=NULL;} PrintLink(head);//调用PrintLink函数printf(“删除第四个数据:n”);int k=4;p=head;for(i=1;ip=(*p).next;} struct V*temp=(*p).next;//k表示插入和删除的位置(*p).next=(*temp).next;free(temp);PrintLink(head);printf(“插入第十个数据:n”);k=10;p=head;for(i=1;ip=(*p).next;} temp=(*p).next;(*p).next=(struct V*)malloc(sizeof(struct V));(*(*p).next).value=-99;(*(*p).next).next=temp;PrintLink(head);}//---------线性表顺序表示-----------void seq1(){ int i,n=10,k=4;int a[10];//---------输出数组元素------------printf(“-------------线性表顺序表示---------n”);for(i=0;ia[i]=i;} printf(“数组元素为:n”);for(i=0;iprintf(“%3d”,a[i]);} printf(“n”);//--------插入一个数组元素---------int m=n+1,j=12;//插入元素12 int b[20];for(i=0;i if(i{b[i]=a[i];}else if(i==k){b[i]=j;}else{b[i]=a[i-1];} } printf(“输出插入一个元素的数组:n”);for(i=0;i{if(i{c[i]=a[i];}else{c[i]=a[i+1];} } printf(“输出删除一个元素的数组:n”);for(i=0;i printf(“数组元素为:n”);for(i=1;i<=a[0];i++){a[i]=i;} for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-----在k 位置插入一个元素------------for(i=a[0];i>=k;i--){a[i+1]=a[i];} a[k]=-100;++a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-------在k---------------for(i=0;i>k;i++){a[i]=a[i+1];} a[k]=-1;a[0]=n;--a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);} int main(int argc,char *argv[]){ seq1();seq2();Link();return 0;} 图1:实验结果截图实验分析:已在程序中按规定格式标注。
数据结构实验报告实验1

数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见的数据结构,如线性表、栈、队列等,并能够运用所学知识解决实际问题。
二、实验环境本次实验使用的编程环境为Visual Studio 2019,编程语言为C++。
三、实验内容与步骤(一)线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。
实现插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体,包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
(二)栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。
实现入栈、出栈、栈顶元素获取等操作。
2、栈的应用利用栈实现表达式求值。
(三)队列的实现与应用1、队列的实现使用循环数组或链表实现队列。
实现入队、出队、队头元素获取等操作。
2、队列的应用模拟银行排队系统。
四、实验结果与分析(一)线性表1、顺序表插入操作:在指定位置插入元素时,需要移动后续元素,时间复杂度为 O(n)。
删除操作:删除指定位置的元素时,同样需要移动后续元素,时间复杂度为 O(n)。
查找操作:可以直接通过索引访问元素,时间复杂度为 O(1)。
2、链表插入操作:只需修改指针,时间复杂度为 O(1)。
删除操作:同样只需修改指针,时间复杂度为 O(1)。
查找操作:需要遍历链表,时间复杂度为 O(n)。
(二)栈1、表达式求值能够正确计算简单的四则运算表达式,如 2 + 3 4。
对于复杂表达式,如(2 + 3) 4,也能得到正确结果。
(三)队列1、银行排队系统模拟了客户的到达、排队和服务过程,能够反映出队列的先进先出特性。
五、实验中遇到的问题及解决方法(一)线性表1、顺序表的空间浪费问题问题描述:当预先分配的空间过大而实际使用较少时,会造成空间浪费。
解决方法:可以采用动态分配空间的方式,根据实际插入的元素数量来调整存储空间。
2、链表的指针操作错误问题描述:在链表的插入和删除操作中,容易出现指针指向错误,导致程序崩溃。
西安邮电大学计算机学院数据结构课内实验报告(线性表的应用)

西安邮电大学(计算机学院)数据结构课内实验报告实验名称:线性表的应用专业名称:电子商务班级:学生姓名:学号(8位):指导教师:实验日期:2014年10 月15 日一. 实验目的及实验环境1.实验目的熟悉并掌握线性表如何构建,并学会线性表的基本应用和两种存储结构的实现2.实验环境VC++6.0二. 实验内容约瑟夫问题:编号为1、2、3…..,按顺时针坐在一张圆桌周围,每人持有一个密码,一个人选任意正整数为报数上限m,从第一个人开始报数报到m时停止报数,这个人出列,直到所有的人都出列,游戏结束。
用线性表的内容来实现这个程序。
三.方案设计第一步:建立n个节点的无头循环链表。
第二步:从链表的第一个节点开始计数,直到寻找到第m个节点第三步:输出该节点的id值,并将其password值,作为新的m值第四步:根据新的m值,继续删除节点,直到循环链表为空,程序结束四.测试数据及运行结果1.正常测试数据(3组)及运行结果;第一组:测试数据:9、5、2、3、4、1运行结果截图为:第二组:测试数据:5、2、6、1、2、3、4运行结果截图:运行结果截图:2.非正常测试数据(2组)及运行结果。
第一组:测试数据:1、0、2、0运行结果截图为:第二组:测试数据:0、0、0、0、0运行结果截图为:五.总结六.附录:源代码(电子版)#include<stdio.h>#include<stdlib.h>typedef struct node{int id;int password;struct node *next;}lnode,*list;list creat2(){lnode *head,*p,*q;int m,n=2;head=(lnode *)malloc(sizeof(lnode));head->next=NULL;q=head;printf("please input the initial password:");scanf("%d",&m);head->password=m;head->id=1;printf("please input(password):");scanf("%d",&m);while(m!=-1){p=(list)malloc(sizeof(lnode));p->password=m;p->id=n;q->next=p;q=p;printf("please input(password):");scanf("%d",&m);n++;}p->next=head;return head;}void print(lnode *q){lnode *p;printf("%4d,%4d\n",q->id,q->password);p=q->next;while(p!=q){printf("%4d,%4d\n",p->id,p->password);p=p->next;}printf("\n");}list front(list q){list p;p=q->next;while(p->next!=q)p=p->next;return p;}void deletee(list q){list p,r;int i,m=q->password;p=q;while(p->next!=p){i=1;while(i!=m){p=p->next;i++;}printf("%4d,%4d\n",p->id,p->password);p=front(p);r=p->next;p->next=r->next;m=r->password;free(r);p=p->next;}printf("%4d,%4d\n",p->id,p->password);}void main(){list head;head=creat2();printf("========打印队列原有情况==========\n");print(head);printf("==========打印出队情况==========\n");deletee(head);}西安邮电大学(计算机学院)数据结构课内实验报告实验名称:栈和队列的应用专业名称:电子商务班级:学生姓名:学号(8位):指导教师:衡霞实验日期:2014年11 月10 日一. 实验目的及实验环境1、实验目的掌握栈和队列的基本操作,实现栈或队列的基本应用2、实验环境VC++6.0二. 实验内容判断输入的一个字符串是否为回文三.方案设计第一步:建立一个顺序栈第二步:输入字符串的时候入栈第三步:出栈时也保存到一个数组中第四步:比较两个数组是否完全相同四.测试数据及运行结果1.正常测试数据(3组)及运行结果;第一组:测试数据:1、2、3运行结果:第二组:测试数据:a、b、c运行结果:第三组:测试数据:1、2、a、2、1运行结果:2.非正常测试数据(2组)及运行结果。
数据结构线性表实验报告

数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法,并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、实验内容(一)线性表的顺序存储结构顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。
其特点是逻辑上相邻的元素在物理位置上也相邻,便于随机存取,但插入和删除操作需要移动大量元素,效率较低。
(二)线性表的链式存储结构链表是通过指针将一组零散的存储单元链接成一个线性序列。
常见的链表有单链表、双向链表和循环链表。
链表的插入和删除操作只需修改指针,无需移动元素,但随机存取效率较低。
(三)线性表的基本操作实现1、初始化线性表2、销毁线性表3、清空线性表4、判断线性表是否为空5、获取线性表的长度6、获取指定位置的元素7、查找指定元素在线性表中的位置8、在线性表指定位置插入元素9、删除线性表指定位置的元素四、实验步骤(一)顺序表的实现1、定义顺序表的结构体,包括数据存储数组和表的长度。
2、实现顺序表的初始化函数,分配初始存储空间并设置表长度为0。
3、销毁顺序表函数,释放存储空间。
4、清空顺序表函数,将表长度置为 0。
5、判断顺序表是否为空,根据表长度判断。
6、获取顺序表长度,直接返回表长度。
7、获取指定位置元素,检查位置合法性后返回对应元素。
8、查找指定元素位置,遍历表进行比较。
9、插入元素函数,检查插入位置合法性,若合法则移动后续元素,插入新元素并更新表长度。
10、删除元素函数,检查删除位置合法性,若合法则移动后续元素,更新表长度。
(二)链表的实现1、定义链表节点结构体,包含数据域和指针域。
2、实现链表的初始化函数,创建头节点。
3、销毁链表函数,遍历链表释放节点内存。
4、清空链表函数,遍历链表删除节点但保留头节点。
5、判断链表是否为空,检查头节点的指针域是否为空。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的:掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
2.实验内容:1)编写函数,实现用链表结构建立多项式;2)编写函数,实现多项式的加法运算;3)编写函数,实现多项式的显示;4)测试:编写主函数,它定义并建立两个多项式,显示两个多项式,然后将它们相加并显示结果。
变换测试用的多项式,检查程序的执行结果。
选做内容:修改程序,选择实现以下功能:5)多项式求值:编写一个函数,根据给定的x值计算并返回多项式f(x)的值。
测试该函数(从终端输入一个x的值,调用该函数并显示返回结果)。
6)多项式相减:编写一个函数,求两个多项式相减的多项式。
7)多项式相乘:编写一个函数,求两个多项式的乘积多项式。
3.算法说明:1)多项式的建立、显示和相加算法见讲义。
可修改显示函数,使输出的多项式更符合表达规范。
2)多项式减法:同次项的系数相减(缺项的系数是0)。
例如a(x)=-5x2+2x+3,b(x)= -4x3+3x,则a(x)-b(x)=4x3-5x2-x+3。
提示:a(x)-b(x) = a(x)+(-b(x))。
3)多项式乘法:两个多项式的相乘是“系数相乘,指数相加”。
算法思想是用一个多项式中的各项分别与另一个多项式相乘,形成多个多项式,再将它们累加在一起。
例如,a(x)=-5x2+2x+3,b(x)=-4x3+3x,则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。
4.实验步骤:根据实验报告的要求,我对文件夹里的C文件进行了丰富和修改,步骤如下:链表结构建立多项式:typedef struct polynode{ float coef; //系数int exp; //指数struct polynode *next; //下一结点指针} PNode;编写函数,实现多项式的加法运算;PNode * PolyAdd (PNode *f1, PNode *f2) //实现加法功能。
{ //实现两多项式(头指针分别为f1和f2)相加,返回和多项式f3=f1+f2。
PNode *pa=f1->next,*pb=f2->next,*pc,*f3,*q;int exp;float coef;f3=(PNode *)malloc(sizeof(PNode)); //建立头指针f3->exp=-1; //对头指针初始化f3->next=f3;pc=f3; //将pc指向头指针while (pa->exp!=-1 || pb->exp!=-1) // 返回头指针时,跳出循环{if (pa->exp>pb->exp){exp=pa->exp;coef=pa->coef;pa=pa->next;}else if (pa->exp<pb->exp){exp=pb->exp;coef=pb->coef;pb=pb->next;}else{exp=pa->exp;coef=pa->coef+pb->coef;pa=pa->next;pb=pb->next;}if (coef!=0){q=(PNode *)malloc(sizeof(PNode)); //建立新的q指针存放负指数的指针q->exp=exp;q->coef=coef; //将q插入链表中q->next=pc->next;pc->next=q;pc=q;}}return f3; //返回}实现多项式的显示;void ShowPloy(PNode *h)//用if语句判断,当指数为0是,只输出系数;当指数为1时,输出系数和X;当系数为1时,输出X和指数。
{h=paixu(h); //整理函数,使之降幂排列PNode *p=h->next;if(p==h){printf("表达式为空\n");return;}if(p->coef==1)printf("x^%d",p->exp); //用if语句判断,若输出x^o和x^1值为0和1 直接输出数据。
else if(p->exp==1)printf("%gx", p->coef);else if(p->exp==0)printf("%g", p->coef);elseprintf("%gx^%d", p->coef, p->exp);p=p->next;while (p!=h){if(p->coef>0)printf("+"); //系数为负,不用输出加号if(p->coef==1)printf("x^%d",p->exp);else if(p->exp==1)printf("%gx", p->coef);else if(p->exp==0)printf("%g", p->coef);elseprintf("%gx^%d", p->coef, p->exp);p=p->next;}printf("\n");}主函数void main(){PNode *F1,*F2,*F3;float x;F1=CreatPoly();F2=CreatPoly();printf("\nf1(x)=");ShowPloy(F1);printf("\nf2(x)=");ShowPloy(F2);F3=PolyAdd(F1,F2);F3=paixu(F3);printf("\nf1+f2=:");ShowPloy(F3);F3=PolySub(F1,F2);printf("\nf1-f2=:");ShowPloy(F3);F3=PolyMult(F1,F2);printf("\nf1*f2=:");ShowPloy(F3);printf("\nx的值为: ");scanf("%f", &x);printf("\nf1(x=%.3f)=%.3f\n",x,PolyValue(F1,x));}多项式求值double PolyValue(PNode *h, float x) {//编写算法,求以h为头指针的多项式在x点的值并返回该值。
double f=0.0;//求出f=f(x);PNode *pa;h=paixu(h);pa=h->next;while(pa->exp!=-1) //使用f+=coef*pow,返回f{f+=(pa->coef)*pow(x,pa->exp);pa=pa->next;}return f;}多项式相减PNode * PolySub(PNode *f1,PNode *f2){//编写此算法,实现两多项式(头指针分别为f1和f2)相减,返回差多项式f3=f1-f2。
PNode *pa=f1->next,*pb=f2->next,*pc,*f3,*q,*head;f3=(PNode *)malloc(sizeof(PNode)); //建立头指针f3->exp=-1; //头指针的初始化f3->next=f3;pc=f3; //pc指向头指针,便于操作。
while(pb->exp!=-1) //返回头指针时,跳出循环。
{q=(PNode *)malloc(sizeof(PNode)); //建立新的q指针存放负指数的指针q->coef=pb->coef*(-1);q->exp=pb->exp; //将q插入链表中q->next=pc->next;pc->next=q;pc=q;pb=pb->next;}head=PolyAdd(f1,f3); //调用加法函数做减法return head; //返回头指针}多项式相乘PNode * PolyMult(PNode *f1,PNode *f2){//实现两多项式(头指针分别为f1和f2)相乘,返回乘积多项式f3=f1*f2。
PNode *pa=f1->next,*pb=f2->next,*pc,*u,*head;int exp;float coef;head=(PNode *)malloc(sizeof(PNode));head->exp=-1;head->next=head;pc=head;while(pa->exp!=-1) //多项式相乘,录入u指针,查到头指针。
{while(pb->exp!=-1){coef=pa->coef*pb->coef;exp=pa->exp+pb->exp;u=(PNode *)malloc(sizeof(PNode));u->coef=coef;u->exp=exp;u->next=pc->next;pc->next=u;pc=u;pb=pb->next;}pb=pb->next;pa=pa->next;}return head; //返回头指针}程序运行截图测试成功~!程序完整源代码如下:#include <stdio.h>#include <stdlib.h>#include <math.h>typedef struct polynode{ float coef; //系数int exp; //指数struct polynode *next; //下一结点指针} PNode;PNode * paixu(PNode *f) //将多项式降幂排列{PNode *p,*q,*r,*p0,*q0;p=f->next;q=p->next;p0=f;q0=p;while(p->exp!=-1) //p为q的前驱,q与p指数指数值进行比较,{while(q->exp!=-1) //q为头指针推出循环,q移动一圈{if(p->exp>q->exp) //比较,若p大于q则q后移{q0=q;q=q->next;}else if(p->exp<q->exp) //若p小于q则q插入p之前{r=q->next;q->next=p0->next;q0->next=r;p0->next=q;p=q;q=r;}else if(p->exp==q->exp) //若相等,p的coef 与q的相加,然后删除q节点,释放q的空间{p->coef+=q->coef;q0->next=q->next;q=q->next;}}p0=p;p=p->next;q=p->next;q0=p;}return f;}void ShowPloy(PNode *h)//用if语句判断,当指数为0是,只输出系数;当指数为1时,输出系数和X;当系数为1时,输出X和指数。