数据结构实验一 线性表的实现

合集下载

实验一 线性表的基本操作实现及其应用

实验一 线性表的基本操作实现及其应用

实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。

2、会用线性链表解决简单的实际问题。

二、实验内容题目一、该程序的功能是实现单链表的定义和操作。

该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。

其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。

单链表操作的选择以菜单形式出现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表(设为输出元素)7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。

其中黑体部分必做题目二、约瑟夫环问题:设编号为1,2,3,……,n的n(n>0)个人按顺时针方向围坐一圈,每个人持有一个正整数密码。

开始时任选一个正整数做为报数上限m,从第一个人开始顺时针方向自1起顺序报数,报到m时停止报数,报m的人出列,将他的密码作为新的m值,从他的下一个人开始重新从1报数。

如此下去,直到所有人全部出列为止。

令n最大值取30。

要求设计一个程序模拟此过程,求出出列编号序列。

struct node(一)1.进入选择界面后,先选择7,进行插入:2.选择4,进行遍历,结果为:3.选择2,得出当前链表长度.4.选择3,得出当前链表为.5.选择分别选择5、6进行测试.6.选择8,分别按位置和元素值删除.7.选择9,或非1-8的字符,程序结束.(二) 实验总结通过这次实验,我对线性链表有了更深的理解,深入明白了线性存储结构与链式存储结构在内存存储的不同特点,同时我还学会了用这些知识实际解决一些问题,能够更加熟练地将算法转化为实际程序。

同时,在写程序和调试程序的过程中,学会了一些书写技巧和调试技巧,这对于自己能在短时间高效的写出正确地程序有很大作用。

四、主要算法流程图及程序清单 1. 主要算法流程图:(1) 从单链表表中查找与给定元素值相同的元素在链表中的位置p=p->nextp&&!(p->data==xtrue调用函数,传入参数L ,xp=L->next2.程序清单:#include<iostream> using namespace std; #include<>#include<>/* 预处理命令 */#define OK 1;#define ERROR 0;#define OVERFLOW -1;/* 单链表的结点类型 */typedef struct LNode{int data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){空"<<endl;cout<<"\t\t\t"<<"2.求链表长度"<<endl;cout<<"\t\t\t"<<"3.检查链表是否为空"<<endl;cout<<"\t\t\t"<<"4.遍历链表"<<endl;cout<<"\t\t\t"<<"5.从链表中查找元素 "<<endl;cout<<"\t\t\t"<<"6.从链表中查找与给定元素值相同的元素在表中的位置"<<endl;cout<<"\t\t\t"<<"7.向链表中插入元素"<<endl;cout<<"\t\t\t"<<"8.从链表中删除元素"<<endl;cout<<"\t\t\t"<<"9.退出"<<endl;}/*主函数*/int main(){链表长度case 2:{cout<<"\t\t\t链表长度为:"<<LinkedListLength(L)<<endl;getch();}break;查链表是否为空case 3:{if (!LinkedListEmpty(L)){cout<<"\t\t\t链表不为空!"<<endl;}else{cout<<"\t\t\t链表为空!"<<endl;}getch();}break;历链表case 4:{LinkedListTraverse(L);getch();}break;链表中查找元素case 5:{cout<<"\t\t\t请输入要查询的位置i:";int j;cin>>j;if (LinkedListGet(L,j)){cout<<"\t\t\t位置i的元素值为:"<<LinkedListGet(L,j)->data<<endl;}else{cout<<"\t\t\ti大于链表长度!"<<endl;}getch();}break;链表中查找与给定元素值相同的元素在表中的位置case 6:{cout<<"\t\t\t请输入要查找的元素值:";int b;cin>>b;if (LinkedListGet1(L,b)){cout<<"\t\t\t要查找的元素值位置为:"<<LinkedListGet1(L,b)<<endl;cout<<"\t\t\t要查找的元素值内存地址为:"<<LinkedListLocate(L,b)<<endl;}else{cout<<"\t\t\t该值不存在!"<<endl;}getch();}break;链表中插入元素case 7:{cout<<"\t\t\t请输入要插入的值:";int x; cin>>x;cout<<"\t\t\t请输入要插入的位置:";int k; cin>>k;if(LinkedListInsert(L,k,x)){cout<<"\t\t\t插入成功!"<<endl;}else{cout<<"\t\t\t插入失败!"<<endl;}getch();}break;链表中删除元素case 8:{cout<<"\t\t\t1.按位置删除"<<endl;cout<<"\t\t\t2.按元素删除"<<endl;int d;cout<<"\t\t请选择:";cin>>d;switch(d){case 1:{cout<<"\t\t\t请输入删除位置:";cin>>d;int y;if (LinkedListDel(L,d,y)){cout<<"\t\t\t"<<y<<"被删除!"<<endl;}else{cout<<"\t\t\t删除失败!"<<endl;}}break;case 2:{cout<<"\t\t\t请输入删除元素:";int y;cin>>y;if (LinkedListDel(L,y)){cout<<"\t\t\t"<<y<<"被删除!"<<endl;}else{cout<<"\t\t\t删除失败!"<<endl;}}}getch();}break;}}return 1;}题二约瑟夫环问题算法、思想为了解决这一问题,可以先定义一个长度为30(人数)的数组作为线性存储结构,并把该数组看成是一个首尾相接的环形结构,那么每次报m的人,就要在该数组的相应位置做一个删除标记,该单元以后就不再作为计数单元。

数据结构实验C语言实现线性表

数据结构实验C语言实现线性表

p=p->next; h=p->next; p->next=p->next->next; h->next=p->next->next; p->next->next=h; p->next->next->next=h->next; //free(h); //以下为链表的输出 p=L->next; printf("交换后输出\n"); while(p!=NULL) { printf("%d\n",p->num); p=p->next; } //以下为链表的倒置 p=L; while(p->next->next!=NULL) p=p->next; q=p->next; q->next=p; p->next=NULL; p=L; for(i=0;i<4;i++) {while(p->next->next!=NULL) p=p->next; k=p->next; k->next=p; p->next=NULL; p=L; } L->next=q;
课题一的具体实验内容 1、构造元素类型为整型的线性表,将以下元素插入分别插入线性 表: <34 56 20 9 15 5> 2、查找表中是否存在元素20,实现元素20与元素9的交换; 3、按照课题要求编写函数,实现线性表元素<34 56 9 20 15 5>的倒 置,即倒置后的表应为< 5 15 20 9 56 34 >。 #include<stdio.h> #include<stdlib.h> #define NULL 0 struct node { int num; struct node *next; }; void main() { int i; struct node *L,*s,*p,*h,*q,*k; L=(node*)malloc(sizeof(struct node)); //L->num=NULL; p=L; printf("请输入\n"); for(i=0;i<6;i++) { s=(node*)malloc(sizeof(struct node)); scanf("%d",&s->num); p->next=s; p=s; } p->next=NULL; //以上为链表的建立和输入 //以下为元素的交换 p=L; while(p->next->numgt;next; printf("倒置后输出\n"); while(p!=NULL) { printf("%d ",p->num); p=p->next; } }

数据结构线性表实验报告

数据结构线性表实验报告

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

二、实验环境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);六、实验总结通过该实验的学习,对课堂内容再次巩固,对顺序表也有了更深的了解。

哈工大 数据结构 实验一 线性表的实验

哈工大 数据结构 实验一 线性表的实验
n.push(w*y);
}
else if(input[i]=='/'){
y=n.pop();w=n.pop();
n.push(w/y);
}
}
cout<<n.pop()<<endl;
}
int main(){
int i,j;
double a[64];
char input[512],o;
stack<char> s;
printf("do you want to try again?(Y/N) ");
o=getchar();
if(o=='n'||o=='N') break;
getchar();printf("\n");
}
printf("thanks for using it...\n");
}
stack<double> n;
while(true){
i=0;j=0;s.null();n.null();
printf("please input the expression: ");
change(i,j,a,input,s);
printf("the answer is: ");
compute(i,j,a,input,n);
哈尔滨工业大学计算机科学与技术学院
实验报告
课程名称:数据结构与算法
课程类型:必修
实验项目名称:线性表实验
实验题目:算术表达式求值
班级:0903201
学号:1090320110
姓名:王岳

数据结构实验报告-实验:1线性表的顺序存储和操作实现

数据结构实验报告-实验:1线性表的顺序存储和操作实现
System.exit(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.简介本实验报告旨在介绍数据结构中线性表的实现和应用。

线性表是一种重要的数据结构,它的特点是数据元素之间存在一对一的前后关系,且具有唯一的起点和终点。

本实验通过实现线性表的基本操作,加深对线性表的理解,并通过实例应用展示线性表在实际问题中的应用。

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 顺序存储结构的实现●初始化顺序表:________创建一个空的顺序表,并指定最大容量。

续元素依次后移。

●删除元素:________删除指定位置的元素,并将后续元素依次前移。

●查找元素:________根据值或位置查找指定元素,并返回其位置或值。

●修改元素:________根据位置修改指定元素的值。

●清空顺序表:________将顺序表中的所有元素清空。

●扩容:________当顺序表容量不足时,自动进行扩容。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

数据结构实验一线性表的实现一、实验目的:1.熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现;2.以线性表的各种操作的实现为重点;3.通过本次学习帮助学生加深C语言的使用,掌握算法分析方法并对已经设计出的算法进行分析,给出相应的结果。

二、实验要求:编写实验程序,上机运行本程序,保存程序的运行结果,结合程序进行分析并写出实验报告。

三、实验内容及分析:1.顺序表的建立建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

程序如下:头文件SqList.h的内容如下:#include<stdio.h>#include<malloc.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int ElemType;typedef int Status;typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList_Sq(SqList *L){L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem) return(OVERFLOW);L->length=0;L->listsize=LIST_INIT_SIZE;return OK;}Status CreatList_Sq(SqList *L,int n){int i;printf("输入%d个整数:\n",n);for(i=0;i<n;i++)scanf("\n%d",&L->elem[i]);return OK;}//以下是整个源程序:#include<stdio.h>#include"SqList.h"int main(){int i,n;SqList a;SqList *l = &a;if(InitList_Sq(l)==-2) printf("分配失败");printf("\n输入要建立的线性表l的长度n:");//输入线性表得长度scanf("%d",&n);l->length=n;printf("线性表的长度是:%d\n",l->length);CreatList_Sq(l,n);//生成线性表printf("输出线性表l中的元素值:");//输出线性表中的元素for(i=0;i<l->length;i++)printf("%7d",l->elem[i]);getchar();}程序的运行结果:2.顺序表的插入利用前面的实验先建立一个顺序表L,然后再第i个位置插入元素,通过对比插入元素前后的线性表发生的变化,判断插入操作是否正确。

参考程序:#include<stdio.h>#include<malloc.h>#include"SqList.h"Status ListInsert_Sq(SqList *L,int i,ElemType e){//在线性表L中的第i个位置前插入一个值为e的元素//i的取值范围:1<=i<=ListLength_Sq(L)ElemType *newbase,*q,*p;if(i<1||i>L->length+1) return ERROR;//i值不合法if(L->length>=L->listsize){ //当前存储空间已满,增加分配量newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase) return (OVERFLOW); //存储分配失败L->elem=newbase; //新基址L->length=+LISTINCREMENT; //增加存储容量}//ifq=&(L->elem[i-1]); //q为插入位置for(p=&(L->elem[L->length-1]);p>=q;--p) *(p+1)=*p;//插入位置及以后的元素右移*q=e; //插入e++L->length; //表长增1return OK;}//ListInsert_Sqint main(){int n,i,x;SqList *L,a;L=&a;InitList_Sq(L);printf("\n输入要建立的线性表L得长度:");scanf("%d",&n);L->length=n;CreatList_Sq(L,n);printf("\n插入元素之前线性表L的长度是:%d",L->length);printf("\n插入元素之前线性表L中的元素是:");for(i=0;i<L->length;i++)printf("%5d",L->elem[i]);printf("\n输入要插入元素的位置:");scanf("%d",&i);printf("\n输入要插入的元素的值:");scanf("\n %d",&x);if(ListInsert_Sq(L,i,x)>0){printf("\n插入元素之后线性表L的长度是: %d ",L->length);printf("\n插入元素之后线性表L的元素是:\n");for(i=0;i<L->length;i++)printf("%5d", L->elem[i]);}//ifelseprintf("不能插入这个元素!\n");getchar();}运行结果:4.单链表的实现新建链表,生成一个有一定结点的链表,并且顺序输出。

程序代码:#include"stdio.h"#include"stdlib.h"#include"string.h"#define null 0#define MAX 100 //最多元素个数#define LENGTH sizeof(struct Node)typedef int Elem ; //数据元素类型//单链表实现线性表struct Node{Elem data; //数据域struct Node *next; //指针域};typedef struct Node NODE;typedef struct Node *LINKLIST;//初始化链表,产生一个空链表LINKLIST InitList()//返回空链表的头指针{LINKLIST head;head=null;return head;}//新建链表,生成一个有一定结点的链表LINKLIST CreateList()//返回新链表的首地址(指针){LINKLIST head=null,p,q;int n,i;Elem temp;do{printf("请输入要建的结点数:");scanf("%d",&n);if(n<1 || n>MAX)printf("对不起!请输入的数在1-%d之间,请重新输入。

\n",MAX);}while(n<1 || n>MAX);for(i=0;i<n;i++){p=(LINKLIST)malloc(LENGTH); //开辟新结点空间printf("请输入第%d结点数据:",i+1);scanf("%d",&temp); //输入结点数据p->data=temp;if(head==null) //如果head指向空,则p结点为第一个结点{head=q=p;p->next=null;}else //不是第一个结点,则结点放到结尾并且,尾指针后移{p->next=null;q->next=p;q=p;}}return head; //返回新链表的首地址(指针)}//遍历打印链表int printList(LINKLIST h)//返回打印结果,0表示无数据,1表示成功打印完成{LINKLIST pt=h;if(pt==null) //没有数据直接返回{printf("对不起,没有数据!");return 0;}while(pt) //结点不为空就打印结点内容{printf("%d ",pt->data);pt=pt->next;}printf("\n");return 1;}//求的链表的长度int ListLength(LINKLIST h)//求的链表长度,返回链表长度,若链表为空则返回0 {LINKLIST pt=h;int len=0; //初始化计数器为0while(pt){len++;pt=pt->next;}return len; //返回链表长度}/*//向链表链表尾部添加结点,无输入LINKLIST AddNode(LINKLIST h,Elem e){LINKLIST head,pt,p;pt=head=h; //指向起始结点p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=null; //结点后继指向空if(pt==null) //若链表为空,直接作为第一个结点head=p;else //若不为空,将结点插在最后{while(pt->next){pt=pt->next;}pt->next=p;}return head; //返回头结点指针}*//*//向链表链表尾部添加结点,有输入LINKLIST AddNode(LINKLIST h){LINKLIST head,pt,p;pt=head=h; //指向起始结点p=(LINKLIST)malloc(LENGTH); //开辟结点空间printf("请输入要添加的数据:");scanf("%d",&p->data);p->next=null; //结点后继指向空if(pt==null) //若链表为空,直接作为第一个结点head=p;else //若不为空,将结点插在最后{while(pt->next){pt=pt->next;}pt->next=p;}return head; //返回头结点指针}*///将结点插入到链表的指定位置LINKLIST AddNode(LINKLIST h,int i,Elem e)//插入位置i,0<i,若i大于链表长度,则直接插在链表最后{LINKLIST head,pt,p;int j;pt=head=h;if(i<1) //插入位置错误(i<1),输出信息并结束程序{printf("程序出错,请检查参数!");exit(1);}if(pt && i>ListLength(h)) //链表不为空,且位置大于链表长度时{while(pt->next){pt=pt->next;}p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=null; //结点后继指向空pt->next=p;}else if(pt==null) //链表为空时{p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=null; //结点后继指向空head=p;}else //参数正确且链表不为空时{if(i==1) //插入点为第1个位置{p=(LINKLIST)malloc(LENGTH); //开辟结点空间p->data=e; //向结点数据赋值p->next=pt; //结点后继指向空head=p;}else //插入在链表中间位置时{p=(LINKLIST)malloc(LENGTH); //开辟结点空间 p->data=e; //向结点数据赋值for(j=1;j<i-1;j++){pt=pt->next;}p->next=pt->next;pt->next=p;}}return head; //返回头结点指针}//删除链表中的某位置结点LINKLIST ListDelete(LINKLIST h,int i)//i在1到ListLength(h)之间{LINKLIST head,pt;int j=1;pt=head=h;if(h==null) //空表{printf("对不起,没有内容!");return null;}if(i<1 || i>ListLength(h)) //检查i的范围{printf("程序出错,请检查参数!");exit(1);}else //i合法,{if(i==1) //删除首结点{head=pt->next;free(pt);}else //删除中间节点或尾结点{while(j<i-1){pt=pt->next;j++;}pt->next=pt->next->next;}}return head; //返回头结点指针}//链表是否为空int ListEmpty(LINKLIST h)//返回0表示空,1表示链表不空{if(h==null)return 0;return 1;}//取得指定位置的元素的值Elem GetElem(LINKLIST h,int i)//返回结点的元素值{LINKLIST pt=h;int j=1;if(i>ListLength(h) || i<1) //检查参数{printf("程序出错,请检查参数!");exit(1);}while(j<i) //找到第i个结点{pt=pt->next;j++;}return (pt->data); //返回结点值}//链表的逆置LINKLIST Invert(LINKLIST h){LINKLIST head,middle,trail; //定义三个指针指向三个相邻的结点middle=null;while(h){ //循环交换相邻两个的指针指向trail=middle;middle=h;h=h->next;middle->next=trail;}head=middle; //将最后的结点变为链表头return head; //返回链表表头}//将两个链表合并为一个链表LINKLIST Union(LINKLIST La,LINKLIST Lb)//将La和Lb连接在一块,返回连接后的链表头指针{LINKLIST head,pa;if(La==null)head=Lb;else{head=pa=La;while(pa->next){pa=pa->next;}pa->next=Lb; //将Lb表头连接在链表La的结尾}return head; //返回链表表头}//将链表按非递减排序LINKLIST ToUpSort(LINKLIST h)//返回排好序后的头指针{LINKLIST p=h,q,temp;temp=(LINKLIST)malloc(LENGTH); //开辟临时交换结点while(p){q=p->next;while(q){if(q->data<p->data) //比较大小交换数据{temp->data=p->data;p->data=q->data;q->data=temp->data;}q=q->next;}p=p->next;}free(temp); //释放临时空间return h; //返回头结点}//将链表按非递增排序LINKLIST ToDownSort(LINKLIST h)//返回排好序后的头指针{LINKLIST p=h,q,temp;temp=(LINKLIST)malloc(LENGTH); //开辟临时交换结点while(p){q=p->next;while(q){if(q->data>p->data) //比较大小交换数据{temp->data=p->data;p->data=q->data;q->data=temp->data;}q=q->next;}p=p->next;}free(temp); //释放临时空间return h; //返回头结点}//比较结点大小int compare(NODE e1,NODE e2)//若e1>e2返回1,若e1=e2返回0,若e1<e2返回-1{return 0;}int main(){LINKLIST p,q;Elem n=8,i;p=CreateList();p=ToUpSort(p);printList(p);return 0;}运行结果:。

相关文档
最新文档