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

合集下载

数据结构与算法分析实验报告

数据结构与算法分析实验报告

数据结构与算法分析实验报告一、实验目的本次实验旨在通过实际操作和分析,深入理解数据结构和算法的基本概念、原理和应用,提高解决实际问题的能力,培养逻辑思维和编程技巧。

二、实验环境本次实验使用的编程语言为 Python,使用的开发工具为 PyCharm。

操作系统为 Windows 10。

三、实验内容(一)线性表的实现与操作1、顺序表的实现使用数组实现顺序表,包括插入、删除、查找等基本操作。

通过实验,理解了顺序表在内存中的存储方式以及其操作的时间复杂度。

2、链表的实现实现了单向链表和双向链表,对链表的节点插入、删除和遍历进行了实践。

体会到链表在动态内存管理和灵活操作方面的优势。

(二)栈和队列的应用1、栈的实现与应用用数组和链表分别实现栈,并通过表达式求值的例子,展示了栈在计算中的作用。

2、队列的实现与应用实现了顺序队列和循环队列,通过模拟银行排队的场景,理解了队列的先进先出特性。

(三)树和二叉树1、二叉树的遍历实现了先序、中序和后序遍历算法,并对不同遍历方式的结果进行了分析和比较。

2、二叉搜索树的操作构建了二叉搜索树,实现了插入、删除和查找操作,了解了其在数据快速查找和排序中的应用。

(四)图的表示与遍历1、邻接矩阵和邻接表表示图分别用邻接矩阵和邻接表来表示图,并比较了它们在存储空间和操作效率上的差异。

2、图的深度优先遍历和广度优先遍历实现了两种遍历算法,并通过对实际图结构的遍历,理解了它们的应用场景和特点。

(五)排序算法的性能比较1、常见排序算法的实现实现了冒泡排序、插入排序、选择排序、快速排序和归并排序等常见的排序算法。

2、算法性能分析通过对不同规模的数据进行排序实验,比较了各种排序算法的时间复杂度和空间复杂度。

四、实验过程及结果(一)线性表1、顺序表在顺序表的插入操作中,如果在表头插入元素,需要将后面的元素依次向后移动一位,时间复杂度为 O(n)。

删除操作同理,在表头删除元素时,时间复杂度也为 O(n)。

数据结构实验报告-线性表(顺序表实现)

数据结构实验报告-线性表(顺序表实现)

实验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线性表的顺序存储结构

数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一,它是一种有序的数据元素集合,其中的数据元素之间具有一对一的关系。

线性表的存储结构有多种方式,其中顺序存储结构是最简单的一种,它使用一段连续的存储单元来存储线性表中的元素。

第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。

顺序存储结构的特点是可以快速地访问任意位置的元素,但插入和删除操作需要移动大量的元素。

第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现,数组的长度应该大于等于线性表的长度,以防止溢出。

存储空间的分配可以使用静态分配或动态分配两种方式来实现。

2.线性表的初始化初始化线性表时,需要设置线性表的长度和当前元素的个数。

3.线性表的增删改查操作●插入操作:________在指定位置插入一个元素时,需要将插入位置之后的元素依次后移,给待插入的元素腾出位置。

●删除操作:________删除指定位置的元素时,需要将删除位置之后的元素依次前移,覆盖删除位置上的元素。

●修改操作:________修改指定位置的元素时,直接对该位置上的元素进行修改即可。

●查找操作:________根据指定的元素值,查找其在顺序存储结构中的位置。

4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素,可以使用循环结构实现遍历操作。

第四章顺序存储结构的优缺点分析1.优点:________可以快速地访问任意位置的元素,节省存储空间。

2.缺点:________插入和删除操作需要移动大量的元素,不适用于频繁插入和删除的场景。

第五章实验过程和结果分析在本次实验中,我们以顺序存储结构为基础,实现了线性表的增删改查操作,并进行了遍历操作。

通过实验,我们发现顺序存储结构在查询操作上有较好的性能,但在插入和删除操作上的性能较差。

第六章附件本文档涉及的附件详见附件文件。

数据结构实验报告-线性表的顺序存储

数据结构实验报告-线性表的顺序存储
学 号
姓 名
专业班级
实验地点
指导教师
实验时间
一、实验目的及要求
本次实验目的是通过上机练习,熟悉和掌握课堂所讲授的基本知识点。要求上机以前要认真复习课堂教学内容。完成教师带领实验,完成线性表的顺序存储实验。
二、实验设备(环境)及要求
计算机;学生不许把食物带到机房吃;不许上网做与实验无关的内容;不许同学之间聊天;保持实验室安静卫生。下课把键盘,座椅放回原处。
Integer length;/*当前线性表长度,线性表中现有元素个数*/
Integer listsize;/*当前分配的存储量以下定义线性表的操作*/
Integer InitList(Class_List *SqList)
/*构造一个空的线性表*/
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int Integer;
typedef char *String;
typedef struct
{
Integer number;
String name[10];
Integer age;
String interest[50];
完成一个有多于3个学生的线性表。并且显示学生信息。删除其中一个学生。然后再打印显示。
Source.cpp
#include"header.h"
void main()
{
Class_List xinji2013;
InitList(&xinji2013);
Student st;
Integer i,n=2,w,q,e;
三、实验内容与步骤

线性表的顺序存储结构实验报告

线性表的顺序存储结构实验报告

南昌航空大学实验报告课程名称:数据结构实验名称:实验一线性表的顺序存储结构班级:XXX 学生姓名:XXX 学号:XXXXX指导教师评定:XXX 签名:XXX设计并实现以下算法:有两张非递增有序的线性表A,B,采用顺序存储结构,两张表合并用C表存,要求C仍为非递增有序的,并删除C表中值相同的多余元素。

一、需求分析⒈本程序中,要求输入到表A,B中的元素是整形的,并且要按非递增顺序输入,否则系统会给出“出错信息”。

输出结果应该是一个不含有重复元素的非递增的表。

⒉本程序以用户和计算机的对话方式执行,即在计算机演示界面上显示“提示信息”后,由用户在键盘上输入相应的信息;相应的输入数据和运算结果显示在其后。

⒊程序执行的命令包括:(1)构造线性表A (2)构造线性表B (3)检验表A,B是否非递减有序(4)求表A与B的合并(5)删除表中值相同的多余元素(6)结束。

4.测试数据(1)A=1 2 3(2)A=9 5 0 -2B=10 5 0 -1 -3 -5 -10二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT Stack {数据对象:D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系:R1={<a i-1,a i>|a i-1,a i∈D,i=2,…n}基本操作:init(list *L)操作结果:构造一个空的线性表L。

InputList(List *L)初始条件:线性表L已经存在操作结果:人工输入了一张表。

CheckList(List *L)初始条件:线性表L已经存在操作结果:判断L是否非递增有序,若为否,则重新输入。

MergeList(List *La,List *Lb,List *Lc)初始条件:非递增线性表La,Lb已经存在操作结果:合并La,Lb得到Lc,Lc仍按非递增有序排列。

DeleteSame(List *L)初始条件:非递增线性表L已经存在操作结果:删除了L中值相同的元素。

数据结构实验报告1-线性结构的顺序存储

数据结构实验报告1-线性结构的顺序存储
评定等级为:优秀、良好、中等、及格、不及格
教师签名: 2008 年 月 日
第2页共2页
2、参照课本,定义一个向量类模板,编写它的成员函数模板,对类模板加以实现;编写向量的并、 交运算功能函数;编写主程序,对两个向量进行分别进行合并、交运算。
3、通过阅读课本栈类板代码,理解栈类操作特点;编写一个借助于栈,将二进制数转换为十进制数 字串的程序;编写汉诺塔问题程序,理解函数的递归调用。
4、参照课本,定义一个顺序队列类模板,编写它的成员函数模板 ,对类模板加以实现;编写主程序, 对队列进行各种基本操作,理解队列的操作特性。
五、 实验总结(包括心得体会、问题回答及实验改进意见,可附页)
通过本次实验,基本上能够理解线性结构的顺序存储方式及各种不同线性结构的操作方式;顺序存 储方式主要用于线性的数据结构,它把逻辑上相邻的数据元素存储在物理上相邻的存储单元里结点之间 的关系由存储单元的邻接关系来体现。线性表、向量、栈、队列都属于线性结构的顺序存储,各结点的 物理地址是相邻的,每一次插入、删除运算会引起相应结点物理地址的重新排列;栈的操作特点是先进 后出,而队列的操作特点是先进先出。
2、 对两个向量进行合并、交运算,结果如下: 输入向量 La 的结点元素:1 2 3 4 5,输入 Lb 的结点元素:1 2 3 4 5 6,则两向量的交集为:1 2 3 4 5;并集为:1 2 3 4 5 6。
3、(1)将二进制数转换为十进制数字串的程序,结果如下: 输入要转换的带符号整数 x:+3;则 x 转换成十进制数字串输出为:+3
Байду номын сангаас
第1页共2页
四、 实验结果(包括程序或图表、结论陈述、数据记录及分析等,可附页)
1、 对线性表进行插入、删除、定位等操作,结果如下: 输入线性表元素:1 2 3 4 5,(1)选择插入,输入插入位置 2,插入值 9,则新的线性表为:1 2 9 3 4 5;(2)选择删除,输入删除元素序号 5,则新的线性表为:1 2 9 3 4;(3)选择取值,输入要求 值元素序号 2,则屏幕输出:第2个元素的值为 9;(4)选择查找,输入要查找的元素值 9,则屏幕输 出:要查找元素的序号为 2。

实习01_线性表的顺序存储和操作(有序表的合并)

实习01_线性表的顺序存储和操作(有序表的合并)

实验一线性表的顺序存储和操作(有序表的合并)1.目的用顺序表(SqList)类型实现书上算法2.1和2.2,了解线性表及在计算机中的两类不同的存储结构;熟练掌握线性表的查找、插入和删除等算法并灵活运用这些算法。

2.要求用C语言编写程序,其中Lb={2,4,6,8,10} La={1,2,3,4,5},①算法2.1执行后,得到的new La = 1,2,3,4,5,6,8,10②修改Lb=2,6,8,9,11,15,20,并利用新生成的La,得到合并后的Lc,Lc= 1,2,2,3,4,5,6,6,8,8,9,10,11,15,203、预习要求:1、复习书上第20页的例2-1和例2-2;2、复习算法2.3,理解如何构造线性表;3、复习算法2.7,理解算法的执行步骤和含义;4、项目介绍:前面的课程已经学习了如何用C语言描述顺序表、如何初始化顺序表、以及如何在顺序表中插入和删除数据元素。

现在通过两个顺序表的合并的实验,加深对顺序表的理解,熟悉如何将逻辑上的数学模型转化为计算机能够理解的指令代码。

该实验是数据结构课程的第一个实验,实验的目标除了加深理解课堂内容外,还对学生的动手能力提出了更高的要求,锻炼学生动手的能力。

5、算法设计#include <stdio.h>#include <stdlib.h>#include <malloc.h># define TRUE 1# define ERROR 0# define OK 1# define OVERFLOW -2# define FALSE 0# define LIST_INIT_SIZE 10# define LISTINCREMENT 5void main(){List La,Lb,Lc;int j,b[7]={2,6,8,9,11,15,20};InitList(La); // 创建空表La。

如不成功,则会退出程序的运行for(j=1;j<=5;j++) // 在表La中插入5个元素,依次为1、2、3、4、5 ListInsert(La,j,j);printf("La= ");ListTraverse(La,printer); // 输出表La的内容InitList(Lb); // 创建空表Lbfor(j=1;j<=5;j++) // 在表Lb中插入5个元素,依次为2、4、6、8、10 ListInsert(Lb,j,2*j);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容Union(La,Lb); // 调用算法2.1,将Lb中满足条件的元素插入La(不改变Lb) printf("new La= ");ListTraverse(La,printer); // 输出新表La的内容ClearList(Lb); // 清空表Lbfor(j=1;j<=7;j++) // 在表Lb中重新依次插入数组b[]的7个元素ListInsert(Lb,j,b[j-1]);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容MergeList(La,Lb,Lc); // 调用算法2.2,生成新表Lc(不改变表La和表Lb)printf("Lc= ");ListTraverse(Lc,printer); // 输出表Lc的内容}6.小结线性表是软件设计中最基础的数据结构。

数据结构线性表实验报告

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告实验目的:本次实验主要是为了学习和掌握线性表的基本操作和实现方式。

通过实验,我们可以加深对线性表的理解,并能够熟悉线性表的基本操作。

实验设备与环境:本次实验所需的设备包括计算机和编程环境。

我们选择使用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.实验目的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线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解和掌握线性表的顺序存储结构,通过实际编程实现线性表的基本操作,如创建、插入、删除、查找和遍历等,从而提高对数据结构的理解和编程能力。

二、实验环境本次实验使用的编程语言是 C 语言,开发环境为 Visual Studio 2019。

三、实验原理线性表是一种最基本、最简单的数据结构,它是由 n(n≥0)个数据元素组成的有限序列。

在顺序存储结构中,线性表的元素存储在一块连续的存储空间中,逻辑上相邻的元素在物理位置上也相邻。

通过数组来实现顺序存储结构,可以方便地进行随机访问,但插入和删除操作的效率较低,因为可能需要移动大量元素。

四、实验内容及步骤1、定义线性表的数据结构```cdefine MAXSIZE 100 //线性表的最大长度typedef struct {int dataMAXSIZE; //存储线性表元素的数组int length; //线性表的当前长度} SeqList;```2、初始化线性表```cvoid InitList(SeqList L) {L>length = 0;}```3、判断线性表是否为空```cint ListEmpty(SeqList L) {if (Llength == 0) {return 1;} else {return 0;}}```4、求线性表的长度```cint ListLength(SeqList L) {return Llength;}```5、按位置查找元素```cint GetElem(SeqList L, int i, int e) {if (i < 1 || i > Llength) {return 0;}e = Ldatai 1;return 1;}```6、按值查找元素的位置```cint LocateElem(SeqList L, int e) {int i;for (i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}return 0;}```7、插入元素```cint ListInsert(SeqList L, int i, int e) {int j;if (L>length == MAXSIZE) {//表已满return 0;}if (i < 1 || i > L>length + 1) {//插入位置不合法return 0;}if (i <= L>length) {//插入位置不在表尾for (j = L>length 1; j >= i 1; j) {L>dataj + 1 = L>dataj;}}L>datai 1 = e;L>length++;return 1;}```8、删除元素```cint ListDelete(SeqList L, int i, int e) {int j;if (L>length == 0) {//表为空return 0;}if (i < 1 || i > L>length) {//删除位置不合法return 0;}e = L>datai 1;if (i < L>length) {//删除位置不在表尾for (j = i; j < L>length; j++){L>dataj 1 = L>dataj;}}L>length;return 1;}```9、遍历线性表```cvoid TraverseList(SeqList L) {int i;for (i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```五、实验结果与分析1、对创建的空线性表进行初始化操作,通过判断线性表是否为空的函数验证初始化是否成功。

实验一线性表的顺序存储结构实验报告页

实验一线性表的顺序存储结构实验报告页
sca nf("%d",&L.data[i]);
L.n=n;
实验报告附页
L.n=0;
}
int Length(SeqList&L)//计算顺序表的长度{
return L.n;
}
int isEmpty(SeqList&L)//判断空否
{
return (L. n==0)?1:0;
}
int isFull(SeqList&L)//判断满否
{
{
L1.data=new DataT yp e[L1.maxSize]; if(! L1.data)
{
cout<<"存储分配错误!\n";
exit(1);
}
}
for(i nt i=1;i<=L2. n;i++)
L1.data[i-1]=L2.data[i-1];
};
int In sert(SeqList&L,i nt iQataTy pe& x)//顺序表插入
if(!L1.data)
主函数代码如下:
void mai n()
{
int ch;
int i;
DataT ype x;
SeqList L;
L.n=0;
in itList(L);
printf(”
**************\n");
顺序表复制
};
if(!L. n)return 0; if(i<1 || i>L. n)return 0; x=L.data[i-1];
for(i nt戸;j<L .n ;j++)

数据结构实验报告-线性表

数据结构实验报告-线性表

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,此题中循环链表可不设头结点,而且必须注意空表和"非空表"的界限。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。

(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。

(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。

数据结构实验一 线性表的顺序存储及其操作 - 副本

数据结构实验一 线性表的顺序存储及其操作 - 副本

实验一线性表的顺序存储及其操作一、【实验目的】掌握线性表在顺序存储下的插入与删除等基本运算二、【指导思想】用数组和线性表长存储线性表,实现线性表的基本操作。

三、【实验内容】实现顺序表的建立、输入、输出、查找、插入、删除等功能,每个功能用一个函数实现。

(1)顺序表的基本操作实践。

1. 建立4个元素的顺序表list[]={2,3,4,5},实现顺序表建立的基本操作。

2. 在list[]={2,3,4,5}的元素4和5之间插入一个元素9,实现顺序表插入的基本操作。

3. 在list[]={2,3,4,9,5}中删除指定位置(i=3)上的元素9,实现顺序表的删除的基本操作。

(2)请编写求两个集合A、B的交集A∩B的程序。

集合A、B用顺序表存储。

例如A={2,3,4,1,5,6,7},B={3,2,9,8,7,6},输出A∩B的结果={2,3,7,6}例如:四、【源程序及运行结果】参考:顺序表的存储结构定义typedefstruct{ElemType data[MAXSIZE]; /*存放顺序表的元素*/int length; /*顺序表的实际长度*/} SqList;#include<stdio.h>#include<stdlib.h>#define NULL 0typedefstruct element//集合元素的结构体{char data;struct element *next;}element;element init_element(element *head)//初始化集合(集合是用单链表存储结构存储的){head=(element*)malloc(sizeof(struct element));head->next=NULL;return *head;}void readdata_element(element *head)//键盘输入每个集合的元素{char c;printf("请输入集合中的数据元素(以“F”为结束标志,结束输入):\n");scanf("%c",&c);while(c!='F'){if((c>'a' && c<'z') ||( c>'0' && c<'9')){element *p;p=(element*)malloc(sizeof(struct element));p->data=c;p->next=head->next;head->next=p;scanf("%c",&c);}elseprintf("输入错误!必须是小写字母或者0~9的数字!请重新输入:\n");}}void display_element(element * head)//输出集合中的所有元素{element *p;p=head->next;while(p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}void bing_element(element *head1,element * head2,element * head3)//求两个集合的并集{element *p1,*p2,*p3;p1=head1->next;while(p1!=NULL){p3=(element*)malloc(sizeof(struct element));p3->data=p1->data;p3->next=head3->next;head3->next=p3;p1=p1->next;}p2=head2->next;while(p2!=NULL){p1=head1->next;while((p1!=NULL) && (p1->data!=p2->data))p1=p1->next;if(p1==NULL){p3=(element*)malloc(sizeof(struct element));p3->data=p2->data;p3->next=head3->next;head3->next=p3;}p2=p2->next;}}void jiao_element(element *head1,element *head2,element *head3)//求两个集合的交集{element *p1,*p2,*p3;p1=head1->next;while(p1!=NULL){p2=head2->next;while((p2!=NULL) && (p2->data!=p1->data))p2=p2->next;if(p2->data==p1->data){p3=(element*)malloc(sizeof(struct element));p3->data=p1->data;p3->next=head3->next;head3->next=p3;}p1=p1->next;}}void cha_element(element *head1,element *head2,element *head3)//求两个集合的差集{element *p1,*p2,*p3;p1=head1->next;while(p1!=NULL){p2=head2->next;while((p2!=NULL) && (p2->data!=p1->data))p2=p2->next;if(p2==NULL){p3=(element*)malloc(sizeof(struct element));p3->data=p1->data;p3->next=head3->next;head3->next=p3;}p1=p1->next;}}void bu_element(element *head1,element *head2,element *head3)//求集合的补集{element *p1,*p2,*p3;p1=head1->next;p2=head2->next;while(p1!=NULL){while((p2!=NULL) && (p1->data!=p2->data)){p2=p2->next;}if(p2==NULL){p3->data=p1->data;p3->next=head3->next;head3->next=p3;p3=head3->next;}p1=p1->next;}}void main(){element *head1,*head2,*head3,*head4;init_element(head1);init_element(head2);init_element(head3);init_element(head4);printf("请输入集合1:\n");readdata_element(head1);printf("请输入集合2:\n");readdata_element(head2);printf("请输入集合3(全集):\n");readdata_element(head3);printf("集合1为:\n");display_element(head1);printf("集合2为:\n");display_element(head2);printf("集合3(全集)为:\n");display_element(head3);char c1;printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");scanf("%c",&c1);if(c1=='A'){printf("集合1与集合2的并集为:\n");bing_element(head1,head2,head4);display_element(head4);head4->next=NULL;}if(c1=='B'){printf("集合1与集合2的交集为:\n");bing_element(head1,head2,head4);display_element(head4);head4->next=NULL;}if(c1=='C'){printf("集合1与集合2的差集为:\n");bing_element(head1,head2,head4);display_element(head4);head4->next=NULL;}if(c1=='D'){printf("集合1的补集为:\n");bing_element(head3,head1,head4);display_element(head4);head4->next=NULL;}if(c1=='E'){printf("集合2的补集为:\n");bing_element(head3,head2,head4);display_element(head4);head4->next=NULL;}}******************************************************************************* *******落实单位姓名性别民族年龄党龄学历职业曾任党内职务与党组织失去联系时间(失联填)失去联系情形(失联填)党组织类别联系电话备注(任填,未注明的必填)是否落实学长学姐,你们好,我是江理信息学院党建小组成员,由于学校开展党员组织梳理排查,需要填好以下信息如果对所填信息有不明白的请尽快联系我,所填信息于明天晚上7点之前发给我,麻烦了,谢谢落实单位姓名性别民族年龄党龄学历职业曾任党内职务与党组织失去联系时间(失联填)失去联系情形(失联填)党组织类别(①国有企业;②非公有制企业:③农村;④党政机关;⑤学校;⑥其他事业单位;⑦街道社区;⑧社会组织;⑨其他。

数据结构线性表实验报告

数据结构线性表实验报告

数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法,并通过实际编程实现来提高对线性表的应用能力和编程技能。

二、实验环境本次实验使用的编程语言为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线性表的逻辑结构特征1.1以元素在计算机内“物理位置相邻”来表示线性表中数据元素之间的逻辑关系。

1.2有且仅有一个开始结点,没有直接前驱,且仅有一个直接后继;有且仅有一个终结结点,没有直接后继,且仅有一个直接前驱。

1.3其余内部结点都有且仅有一个直接前驱和一个直接后继。

2掌握线性表的基本操作在顺序存储结构上的实现。

【实验原理】1顺序表的特点1.1逻辑位置上相邻和物理位置上相邻1.2是一种随机存储结构,其存储位置可以用一简单直观的公式表示2顺序表的类C语言表示:#define LIST_INIT_SIZE 9 II线性表存储空间的初始分配量#define LISTINCREMENT? II线性表存储空间的分配增量typedef struct{ElemType * elem;//存储空间基址int len gth;II 当前长度int listsize;II 当前分配的存储容量(以sizeof ( ElemType)为单位)}SqList;【实验环境】VC++6.0、【实验内容】【实验方案】编写主函数,调用顺序表的初始化建空表,插入和删除算法,调试运行得出结果【实验过程】(实验步骤、记录、数据、分析)*(p+1)=*p;*q=e;++L .len gth; return OK;}Status ListDelect_Sq(SqList &L,int i,ElemType &e) {if((i<1)||(i>L.length)) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L .len gth-1;for(++p;p<=q;++p)*(p-1)=*p;--L .len gth;return OK;}void main(){SqList L;int i;In itList_Sq(L); for(i=0;i<LIST_INIT_SIZE;i++){scan f("%d",&L.elem[i]); L.len gth++;} for(i=0;i<L .len gth;i++) prin tf("%d ",L .elem[i]);prin tf("\n");ElemType e;sca nf("%d%d", &i,& e);ListI nsert_Sq(L,i,e);for(i=0;i<L .len gth;i++)prin tf("%d",L.elem[i]);prin tf("\n");sca nf("%d",&i);ListDelect_Sq(L,i,e);for(i=0;i<L .len gth;i++) prin tf("%d ",L .elem[i]);prin tf("\n");}2. 调试第一次出现的错误:C214:<: syntax error : missing befcre ***: Eienriipe^ : nlssirtg storage-class or specifiers CZFhl : ' elpn 11 : mi^ini| ?>Lordt|i?-tla^^ ur Lypt? spt?tiFiers C2146: 5i|ritax error : missing ' ;' before identif ier ' InitList _Sq C2591: 1Status * : missing storage-class or type ^pocifier£ error C130*ure»p&cted pnd oF Fil® found原因:由于许多变量未定义,以及没有头文件与宏定义所以错误许多,还有更多错 误没有显示出来3. 将以下语句编入程序中:#include "stdio.h" #inelude "stdlib.h" #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define LIST_INIT_SIZE 9#define LISTINCREMENT 2 typedef int ElemType; typedef int Status;4. 调试第二次出现以下错误:.cpp(9£) : error C2965; *ncMbase" : Ufidrcl^rrd identifier■ eppe 蓟 :trror 02^0; : Cdniml cutivcrt fruin 'ibl *ftv 'inL rpi rirprprpt c^^T r J c-^ryi p r cr Funrttnn^^ryip r^«;r.cpp(3S> : error '-' : cannot convert fram 'int 1 ta 1int **pe to pointer type requires i pinterprrt cast, C style cast or functioncast:umJecltireij iJentifii?r :cannot convert +rom "int 备* to or Function-style cjst ;uiideLldreL iJetitifier :cannnr cflruprt 卡ram -i nr *■ tn cast oi* Punction-ft^lc c^stcpp■ - error cpp<^) ■ -error cpp(3) ■ errorcpp(6) - 启■cpp(e ■ ■■ errorcpp(8)■■ ■aFatal .) : t-rrtirC?965: .cpp)(Ji1 > : errorC2JPiU : * =' reinterpretoast, a C-st^le 工: trror CZ905: p".rp pl 即2》:frrur cpiuin : ' = ■ reinterpretcast, 2 C-'inL 'inr -^es a reinterpret cast * a C-style cast or function-style cast us _cpp(52) :error C2018: unknown character * 0xa1* us _cpp<52) : error C2 018: unknown character 'Qxa!*a reinterpretcast, a C^style cast or function^style cast fvs.cppCSS) : error C2100:illegal indirection Fus.cpp(55) : error C2100: illegal indirection Fus.cpp(55) : error原因:是在每个算法中有许多变量未定义,导致许多错误 5.再将语句:int *newbase;int *q; int *p;写入插入算法中; 将语句:int *p; int *q;写入删除算法中;6. 调试第三次显示没有错误:Compiling … asFvs ・(7ppasfus.obj - & error(s), 0 warning(s) 7. 运行第一次显示结果为:FUS.cpp(52) fus .cpp(S2) FUS .cpp(52) fU5.cpp(52) Fvs«cpp(52) 丽scpp(53) error error error error error error C2 018: C2EMB : C2018: C2 01«: unknown unknovjn unknovm unkin om character ch^ract^r character character• Oxal 1■'0xa1' 'Oxal 1C210O: illegal C2^40: indirection・:cannot convertfrom *int *pto 'int ' "es a reinterpret cast, a C^style cast or Function-st^le cast ^asFus _cpp02) tasfiis >cpp(42) ^asFus.cpp(42) ^asfus>cpp(U3) 需弓fu 与 _cpp<51) IQS F US _C PPCE1) idsFus .cpp (51 j idsFu^ >cpp(51) ^asfu^.cpp(51) error error error error error □ rr or error error err or C21OO: illegal indirectioin C21oo : illegal indirectionC2196: 1=' : left operand must be 1-ualueC210C: illegalC2018: C20i8:C2918: C2C18: unknown unicnoun unknown unknownC244C :' indirection character 10xa11character '* character '0xa1* character 'Oxa1*:cannot conuert from 'int to * int' C2106: • : left operand must be 1-ualueuunt xyui auxutt. i 忖丄Compiling ____asfvs.cppasfus.ob j - Q error(s)r0 warning(s)13.运行第四次显示结果为:*H:\De bug時临恚或咗序表尹W实現芒灼耳请输入您想构建的顺序表(元素为9个)=1 2 3 4 E 6 7 S 9您构建的顺序表杲:■£22456789请输入您想在第几个元素位置前插入元素二18输入的数字错误.(只乘U下瞅重新输入符合要求的数字的机会)常入的数字错误.(只剩Ft枕重新输入符合要求的数字的机会){青输入您想插入的数:6183形成的新顺序表为;彳7 4 4 C 仇 ~(曲4 £."5 Q o睛输入您想删除的是第几个元素:13输入的数字诸误.(只剩下2次重新输入符合要求的数字的机会)易入的数字错误,(只剩下丄次重新输入符合要求的数字的机会)电除的数为:協咸的新顺序表为=1 2 3 4 5 6183 ? 8 9Press ani^ y to comtinue1 刑这样那么程序就完整了,清晰明了,用户运行的时候也容易知道自己要输入什么了【实验结论】(结果)i 曲%谍性義的1驚表示与实现心b L 口 |屈*3^附录1源程序\n",p);附录2:实验报告填写说明1.实验项目名称:要求与实验教学大纲一致。

数据结构线性表的顺序表示和实现的实习报告

数据结构线性表的顺序表示和实现的实习报告

数学与计算科学学院实验报告实验项目名称线性表的顺序表示与实现所属课程名称数据结构实验类型验证型实验日期班级学号姓名成绩2.调试第一次出现的错误:原因:由于许多变量未定义,以及没有头文件与宏定义所以错误许多,还有更多错误没有显示出来3.将以下语句编入程序中:#include "stdio.h"#include "stdlib.h"#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define LIST_INIT_SIZE 9#define LISTINCREMENT 2typedef int ElemType;typedef int Status;4.调试第二次出现以下错误:原因:是在每个算法中有许多变量未定义,导致许多错误5.再将语句:int *newbase;int *q;int *p;写入插入算法中;将语句:int *p;int *q;写入删除算法中;6.调试第三次显示没有错误:7.运行第一次显示结果为:8.但运行后的界面显得很单调;要是忘记下一个算法是什么就容易输入出错,也不适合大众使用;因此为了将程序优化,所以在主函数中增加以下输入输出语句和条件语句;为了让程序更加严谨,因此还加入一些循环语句。

int i,p,q;p=2,q=2;printf("请输入您想构建的顺序表(元素为%d个):\n",LIST_INIT_SIZE);printf("您构建的顺序表是:\n");printf("请输入您想在第几个元素位置前插入元素:\n",LIST_INIT_SIZE);while((i<=0||i>L.length)&&p>=0){printf("输入的数字错误,(只剩下%d次重新输入符合要求的数字的机会)\n",p);--p;if(p<0){printf("原因:您输入数字错误过多,程序终止运行\n");return ERROR;}scanf("%d",&i);}printf("请输入您想插入的数:\n");printf("形成的新顺序表为:\n");printf("请输入您想删除的是第几个元素:\n");while((i<=0||i>L.length)&&q>=0){printf("输入的数字错误,(只剩下%d次重新输入符合要求的数字的机会)\n",q);--q;ListInsert_Sq(L,i,e);printf("形成的新顺序表为:\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");printf("请输入您想删除的是第几个元素:\n");scanf("%d",&i);while((i<=0||i>L.length)&&q>=0){printf("输入的数字错误,(只剩下%d次重新输入符合要求的数字的机会)\n",q);--q;if(q<0){printf("原因:您输入数字错误过多,程序终止运行\n");return ERROR;}scanf("%d",&i);}ListDelect_Sq(L,i,e);printf("删除的数为:\n");printf("%d\n",e);printf("形成的新顺序表为:\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");return 0;}10. 调试第四次显示没错误:11.运行第二次显示结果为:12.运行第三次显示结果为:13.运行第四次显示结果为:这样那么程序就完整了,清晰明了,用户运行的时候也容易知道自己要输入什么了【实验结论】(结果)附录1:源程序附录2:实验报告填写说明1.实验项目名称:要求与实验教学大纲一致。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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);
if(length==listArray.length){
Object[] p=newObject[length*2];
for(inti=0;i<length;i++) p[i]=listArray[i];
listArray=p;
}
for(inti=length;i>=pos;i--)
listArray[i]=listArray[i-1];
list.listArray[j+1]=list.listArray[j];
elsebreak;
}
list.listArray[j+1]=x;
}
returnlist;
}
}
五、上机步骤、出现的问题及解决的方法:
输入List接口类
输入Sequencelist类实现List类
输入主类运行
实验中出现了以下错误
18错误原因是if条件语句后面多加了导致后面的判断永远为false修改后成功运行六上机结果结果分析与体会
信息管理学院专业课实验报告
上机日期:2016年3月18日上机地点与机号:Sc614指导教师:李爱军
班级: 2014级信息一班学号: 2上机人:王坚
一、实验名称:线性表的顺序存储和操作实现
二、上机目的:
}
length=0;//线性表的初始长度为0
listArray=newObject[n];//数组的初始长度为n的值
}
publicObject value(intpos){//返回线性表中第
if(pos<1||pos>length){
System.out.println("参数pos的值不合法,无法得到元素!");
listArray[pos-1]=obj;
length++;
returntrue;
}
publicObject remove(intpos){
if(pos<1||pos>length){
System.out.println("参数pos的值不合法,无法删除元素!");
returnnull;
}
Object x=listArray[pos-1];
}
publicvoidnextOrder(){
for(inti=0;i<length;i++)
System.out.println(listArray[i].toString());
}
publicvoidpreOrder(){
for(inti=length-1;i>=0;i--)
System.out.println(listArray[i].toString());
通过JAVA进行顺序存储线性表操作
三、上机内容:
通过Sequencelist类实现List接口实现顺序存储线性表的功能t
四、程序清单与测试数据:(可附页)
publicclasschap3_1 {
publicstaticvoidmain(String[] args) {
//TODO自动生成的方法存根
List list1=newsequenceList(10);
list1.modify(33, 4);
System.out.println("n1,n2="+n1+","+n2);
list1.nextOrder();
System.out.println("线性表list长度:"+list1.size());
List list2=list1.sort();
list2.nextOrder();
错误原因是If条件语句后面多加了“:”导致后面的判断永远为false
修改后成功运行
六、上机结果、结果分析与体会:
n1,n2=16,42
20
38
80
33
29
线性表list长度:5
20
29
33
38
80
80
38
33
29
20
线性表list2长度:5
体会:
上机操作切不可粗心大意
教师评语:
inti,j;
Comparablex,y;
for(i=1;i<list.length;i++){
x=(Comparable)list.listArray[i];
for(j=i-1;j>=0;j--){
y=(Comparable)list.listArray[j];
if(pareTo(y)<0)
Exception in thread "main"ng.ArrayIndexOutOfBoundsException: 5
at study3.sequenceList.sort(sequenceList.java:97)
at study3.chap3_1.main(chap3_1.java:18)
Object remove(intpos);
intfind(Object obj,intpos);
booleanmodify(Object obj,intpos);
booleanisEmpty();
intsize();
voidnextOrder();
voidpreOrder();
voidclear();
}
publicvoidclear(){
length=0;
}
publicList sort(){
sequenceList list;
list=newsequenceList(length);
list.length=length;
for(inti=0;i<length;i++)
list.listArray[i]=listArray[i];
for(inti=pos;i<=length-1;i++)
listArray[i-1]=listArray[i];
length--;
returnx;
}
publicintfind(Object obj,intpos){
if(pos<1||pos>length);{
System.out.println("参数pos的值不合法,无法查找元素!");
returnnull;
}
returnlistArray[pos-1];
}
publicbooleanadd(Object obj,intpos){
if(pos<1||pos>length+1){
System.out.println("参数pos的值不合法,无法插入元素!");
returnfalse;
}
System.out.println("参数pos的值不合法,无法修改元素!");
returnfalse;
}
listArray[pos-1]=obj;
returntrue;
}
publicbooleanisEmpty(){
returnlength==0;
}
publicintsize(){
returnlength;
listArray=newObject[maxSize];//数组初始长度为maxSize的值为10
}
publicsequenceList(intn){//带初始长度参数的构造函数的定义
if(n<=0){
System.out.println("数组长度要大于0,否则退出程序运行");
System.exit(1);
相关文档
最新文档