数据结构顺序表课程设计

合集下载

数据结构实验一_顺序表的基本操作实验报告

数据结构实验一_顺序表的基本操作实验报告

实验一顺序表的基本操作一、实验目的掌握线性表的顺序表基本操作:建立、插入、删除、查找、合并、打印等运算。

二、实验要求包含有头文件和main函数;1.格式正确,语句采用缩进格式;2.设计子函数实现题目要求的功能;3.编译、连接通过,熟练使用命令键;4.运行结果正确,输入输出有提示,格式美观。

三、实验设备、材料和工具1.奔腾2计算机或以上机型2.turboc2,win-tc四、实验内容和步骤1. 建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

2. 往该顺序表中第i位置插入一个值为x的数据元素。

3. 从该顺序表中第j位置删除一个数据元素,由y返回。

4. 从该顺序表中查找一个值为e的数据元素,若找到则返回该数据元素的位置,否则返回“没有找到”。

五、程序#include<stdio.h>#include<stdlib.h>#define list_init_size 10#define increment 2typedef struct {int *elem;int length,listsize;}sqlist; //类型定义void initlist_sq(sqlist &L) //初始化顺序表{ }void output(sqlist L) //输出顺序表{ }void insertlist(sqlist &L,int i, int x) //顺序表中插入x{ }void deletelist(sqlist &L,int j, int y) //顺序表中删除y{ }int locateelem(sqlist &L,int e) //顺序表中查找e{ }void main(){ }【运行结果】void initlist_sq(sqlist &L) //初始化顺序表{L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));if(!L.elem) exit (OVERFLOW);L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}void output(sqlist L) //输出顺序表{for(int i=0;i<=L.length-1;i++)printf("%d,",L.elem[i]);return OK;}void insertlist(sqlist &L,int i, int x) //顺序表中插入x{int p,q;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){newbase=(int*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));if(!newbasde)exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1];for(p=&(L.elem[L.length-1]);p>=q;--p*(p+1)=*p;*p=x;++L.length;return ok;}void deletelist(sqlist &L,int j, int y) //顺序表中删除y{int p,q;if(i<1||I>L.length+1) return ERROR;p=&(L.elem[i-1]);y=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return ok;}int locateelem(sqlist &L,int e) //顺序表中查找e { int p;i=1;p=L.elem;while(i<=L.length&&!(*p++,e))++i;if(i<=L.length) return i;else return 0;}void main(){int d,p,a,b;int c;initlist_sq(&L);output( L);insertlist( &L, d, a);deletelist( &L, p, b);locateelem( &L, c);}。

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

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

实验1:线性表(顺序表的实现)一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。

三、实验基本原理顺序表是由地址连续的的向量实现的,便于实现随机访问。

顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素:6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。

实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败!";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败!";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量:" << endl;cin >> len;cout << "依次输入要插入的元素:" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功!" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是:" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功!" << endl << "被删除的元素是:" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是:" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置:" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;cout << "--------------1:初始化------------------" << endl;cout << "--------------2:插入元素----------------" << endl;cout << "--------------3:查询元素----------------" << endl;cout << "--------------4:删除元素----------------" << endl;cout << "--------------5:销毁线性表--------------" << endl;cout << "--------------6:清空线性表--------------" << endl;cout << "--------------7:线性表长度--------------" << endl;cout << "--------------8:线性表是否为空----------" << endl;cout << "--------------9:定位满足大小关系的元素--" << endl;cout << "--------------10:查询前驱---------------" << endl;cout << "--------------11:查询后继---------------" << endl;cout << "--------------12:输出线性表-------------" << endl;cout << "--------------13:归并线性表-------------" << endl;cout << "--------------14:奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束!" << endl;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素(返回的是数组下标,下标从0开始)4.删除元素(位置从1开始)5.销毁顺序表6.清空顺序表7.顺序表长度(销毁或清空操作前)8.判空(销毁或清空操作前)9.定位满足大小关系的元素(销毁或清空操作前)说明:这里默认找第一个小于目标元素的位置且下标从0开始,当前顺序表的数据为:1 4 2 510.前驱(销毁或清空操作前)11.后继(销毁或清空操作前)12.输出顺序表(销毁或清空操作前)13.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。

数据结构实验一顺序表

数据结构实验一顺序表

数据结构实验一1、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点,熟练掌握顺序表的基本运算2、实验内容:建立顺序表,完成顺序表的基本操作:初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空;1.问题描述:利用顺序表,设计一组输入数据(假定为一组整数),能够对顺序表进行如下操作:∙创建一个新的顺序表,实现动态空间分配的初始化;∙根据顺序表结点的位置插入一个新结点(位置插入),也可以根据给定的值进行插入(值插入),形成有序顺序表;∙根据顺序表结点的位置删除一个结点(位置删除),也可以根据给定的值删除对应的第一个结点,或者删除指定值的所有结点(值删除);∙利用最少的空间实现顺序表元素的逆转;∙实现顺序表的各个元素的输出;∙彻底销毁顺序线性表,回收所分配的空间;∙对顺序线性表的所有元素删除,置为空表;∙返回其数据元素个数;∙按序号查找,根据顺序表的特点,可以随机存取,直接可以定位于第i 个结点,查找该元素的值,对查找结果进行返回;∙按值查找,根据给定数据元素的值,只能顺序比较,查找该元素的位置,对查找结果进行返回;∙判断顺序表中是否有元素存在,对判断结果进行返回;.编写主程序,实现对各不同的算法调用。

2.实现要求:∙“初始化算法”的操作结果:构造一个空的顺序线性表。

对顺序表的空间进行动态管理,实现动态分配、回收和增加存储空间;∙“位置插入算法”的初始条件:顺序线性表L 已存在,给定的元素位置为i,且1≤i≤ListLength(L)+1 ;操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1;∙“位置删除算法”的初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) ;操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 ;∙“逆转算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行交换,为了使用最少的额外空间,对顺序表的元素进行交换;∙“输出算法”的初始条件:顺序线性表L 已存在;操作结果:依次对L 的每个数据元素进行输出;∙“销毁算法”初始条件:顺序线性表L 已存在;操作结果:销毁顺序线性表L;∙“置空表算法”初始条件:顺序线性表L 已存在;操作结果:将L 重置为空表;∙“求表长算法”初始条件:顺序线性表L 已存在;操作结果:返回L 中数据元素个数;∙“按序号查找算法”初始条件:顺序线性表L 已存在,元素位置为i,且1≤i≤ListLength(L)操作结果:返回L 中第i 个数据元素的值∙“按值查找算法”初始条件:顺序线性表L 已存在,元素值为e;操作结果:返回L 中数据元素值为e 的元素位置;∙“判表空算法”初始条件:顺序线性表L 已存在;操作结果:若L 为空表,则返回TRUE,否则返回FALSE;分析: 修改输入数据,预期输出并验证输出的结果,加深对有关算法的理解。

顺序表系统课程设计

顺序表系统课程设计

顺序表系统课程设计一、课程目标知识目标:1. 让学生理解顺序表的基本概念,掌握顺序表的存储结构及其操作方法。

2. 使学生掌握顺序表在各种算法中的应用,如插入、删除、查找等。

3. 帮助学生理解顺序表与链表的区别及联系,提高数据结构知识的系统性。

技能目标:1. 培养学生运用顺序表解决实际问题的能力,如实现一个简单的通讯录系统。

2. 培养学生通过分析问题,选择合适的数据结构(顺序表或链表)进行算法设计的能力。

3. 提高学生编程实现顺序表相关算法的技能,熟练使用相关函数和语法。

情感态度价值观目标:1. 培养学生面对复杂问题时,能够积极思考、勇于探索的良好学习态度。

2. 通过团队合作完成顺序表相关项目,提高学生的团队协作能力和沟通能力。

3. 使学生认识到数据结构在实际应用中的重要性,激发学生学习编程的兴趣。

本课程针对高年级学生,在已有编程基础和基本数据结构知识的基础上,深入讲解顺序表的相关概念和应用。

课程注重理论与实践相结合,通过实例分析和实际操作,使学生更好地掌握顺序表的知识点,提高解决实际问题的能力。

同时,课程强调学生的主动参与和团队合作,培养学生积极的学习态度和良好的职业素养。

二、教学内容本章节教学内容主要包括以下几部分:1. 顺序表基本概念:介绍顺序表的定义、特点及其存储结构。

- 顺序表的实现原理- 顺序表与线性表的关系- 存储空间分配及长度表示2. 顺序表的操作方法:讲解顺序表的各种操作,如插入、删除、查找等。

- 算法原理及实现步骤- 代码实现及优化- 时间复杂度分析3. 顺序表的应用实例:通过实际案例,展示顺序表在解决问题中的应用。

- 通讯录系统实现- 排序算法的实现(如冒泡排序、选择排序等)4. 顺序表与链表的对比:分析顺序表与链表在实现和应用上的区别与联系。

- 顺序表与链表的优缺点- 适用于不同场景的选择原则5. 课程实践:组织学生进行实际操作,巩固所学知识。

- 编程实现顺序表相关操作- 团队合作完成顺序表应用项目教学内容依据课程目标和学科特点进行安排,注重知识体系的科学性和系统性。

数据结构课程设计报告——二叉排序树(用顺序表结构存储)

数据结构课程设计报告——二叉排序树(用顺序表结构存储)

淮阴工学院数据结构课程设计报告选题名称:二叉排序树(二叉链表结构存储)系(院):计算机工程系专业:计算机科学与技术班级:计算机1091姓名:黄磊学号:1091301108指导教师:张亚红周海岩学年学期:2010 ~ 2011 学年第 1 学期2010 年12 月31 日设计任务书摘要:数据结构是研究与数据之间的关系,我们称这一关系为数据的逻辑结构,简称数据结构。

当数据的逻辑结构确定以后,数据在物理空间中的存储方式,称为数据的存储结构。

相同的逻辑结构可以具有不同的存储结构,因而有不同的算法。

本次课程设计,程序中的数据采用“树形结构”作为其数据结构。

而二叉搜索树又是一种特殊的二叉树。

本课程设中的二叉排序树是基于二叉链表作存储结构的,一共要实现五项基本的功能。

它们分别是二叉搜索树的创建、中序遍历、查找结点、删除结点和计算二叉排序树搜索成功时的平均查找长度。

关键词:二叉排序树;中序遍历;搜索结点;删除结点;平均查找长度目录1需求分析 (1)1.1课程设计题目、任务及要求 (1)1.2课程设计思想 (1)2概要设计 (2)2.1 二叉排序树的定义 (2)2.2二叉链表的存储结构 (2)2.3建立二叉排序树 (2)2.4二叉排序树的生成过程 (3)2.5中序遍历二叉树 (3)2.6二叉排序树的查找 (3)2.7二叉排序树的插入 (4)2.8平均查找长度 (4)3详细设计和实现 (4)3.1主要功能模块设计 (4)3.2主程序设计 (5)4调试与操作说明 (12)4.1程序调试 (12)4.2程序操作说明 (12)总结 (16)致谢 (17)参考文献 (18)1需求分析1.1课程设计题目、任务及要求二叉排序树。

用二叉链表作存储结构(1)以(0)为输入结束标志,输入数列L,生成一棵二叉排序树T;(2)对二叉排序树T作中序遍历,输出结果;(3)计算二叉排序树T查找成功的平均查找长度,输出结果;(4)输入元素x,查找二叉排序树T:若存在含x的结点,则删除该结点,并作中序遍历(执行操作2);否则输出信息“无x”;1.2课程设计思想建立二叉排序树采用边查找边插入的方式。

数据结构 顺序表 实验报告

数据结构 顺序表 实验报告
(四) 程序大致流程图 ..........................6
五、主要代码(略) ....................................................7
六、测试结果及说明 ....................................................7
重庆交通大学计算机与信息学院
数据结构实验报告
实验名称: 顺序表操作
实验性质: 课程安排实验
所属课程: 数 据 结 构
指导教师:
班 级: 2008级3班
七、实验体会 ...................................................10
一、实验目的
培养学生在程序设计方面知识的综合应用能力及程序设计能力(包括编制能力及程序调试能力)
二、实验内容及要求
(1)以顺序存储方式实现线性表进行简单的图书管理,图书信息由学生自行定义。
7) 自主加入了文件的读入函数,由list类入口,再调用book类的读入函数。
3、设计主函数,显示操作方式,调用各个类的成员函数
1) 显示本程序能实现的各项功能,并实现循环操作;
2) 通过定义的一个list类型对象调用各个函数实现程序功能;
3) 为实现不同的编程方式,用了很久以前的直接定义函数功能,在主程序中定义了一个函数,不属于book类,也不属于list类,它实现保存数据的功能。
3) list类的共有成员函数类似book类的定义风格,包括了受保护成员值的设定以及读取,同样重载了list类型数据的赋值即顺序表的拷贝;
4) 保留了教材上对于顺序表的判空、判满等共有成员函数;

数据结构实验报告(C语言)顺序表__排序

//冒泡排序 void BubbleSort(SqeList *L){
int i,j,n,x,change; n=L->length; change=1; for(i=1;i<=n-1 && change;++i){
change=0; for(j=1;j<=n-i-1;++j)
if(L->r[j] > L->r[j+1]){ x=L->r[j]; L->r[j]=L->r[j+1]; L->r[j+1]=x; change=1;
void QuickSort(SqeList *L,int low,int high){ int mid; if(low<high){ mid=Partition(L,low,high); QuickSort(L,low,mid-1); QuickSort(L,mid+1,high); }
}
//直接选择排序
printf("\n7-直接选择排序结果为:\n"); SelectSort(&l); PrintList(&l); printf("\n"); printf("\n8-二路归并结果为:\n"); MergeSort(&l);
PrintList(&l); printf("\n"); } else printf("请输入大于 0 的值: "); return 0; }
} else{
MR->r[k]=R->r[j]; ++j; } ++k; } while(i<=mid) MR->r[k++]=R->r[i++]; while(j<=high) MR->r[k++]=R->r[j++]; }

数据结构上机作业——顺序表

数据结构上机作业——顺序表一、实验目的理解线性表的逻辑结构、顺序存储结构和数据操作,熟练运用Java语言实现线性表的基本操作,分析各种操作算法特点和时间复杂度。

熟悉JCreator调试程序的方法。

二、主要内容1、按照教材P37编写顺序表类,在SeqList中增加main方法或者编写一个测试类测试各方法的正确性。

说明:注意package路径,导入LList,过程参考如下:1)创建工程:File->New->Project,选择Empty Project,输入工程名称及路径,点击完成。

2)鼠标指向工程ds,单击鼠标右键,在快捷菜单中选择Add->New Folder,新建文件夹dataStructure,在dataStructure新建文件夹linearList。

3)鼠标指向文件夹linearList,单击鼠标右键,在快捷菜单中选择Add Existing Files,选择LList.java(教育在线例程中)。

4)鼠标指向文件夹linearList,单击鼠标右键,,在快捷菜单中选择New Class,在Class Wizard中输入相关内容,类名:SeqList。

5)程序编辑结束后,执行Build->Build File菜单命令,编译Java程序,系统在Build Output区域输出错误信息,编译通过后将生成字节码文件(.class)。

6)测试:方法1 在SeqList类中增加main方法,例如public static void main(String args[]){SeqList<String> list=new SeqList<String>(7);list.add("");list.add("");list.add("");list.add("");System.out.println(list.toString());list.add(2,"");System.out.println(list.toString());list.remove(3);System.out.println(list.toString());}修改main方法,完成相应测试。

数据结构实验报告—顺序表

《算法与数据结构》课程实验报告一、实验目的1、实现线性表的顺序存储结构。

2、熟悉C++程序的基本结构,掌握程序中的头文件、实现文件和主文件之间的相互关系及各自的作用。

3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现。

二、实验内容及要求对顺序存储的线性表进行一些基本操作。

主要包括:(1)插入:操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入。

(2)删除:操作方式可分为删除指定元素、删除指定位置的元素等,尝试实现逻辑删除操作。

(3)显示数据。

(4)查找:查询指定的元素(可根据某个数据成员完成查询操作)。

(5)定位操作:定位指定元素的序号。

(6)更新:修改指定元素的数据。

(7)数据文件的读写操作等。

其它操作可根据具体需要自行补充。

要求线性表采用类的定义,数据对象的类型自行定义。

三、系统分析(1)数据方面:能够实现多种数据类型顺序表的创建,并进行操作,不同的数据类型数据使用不同的文本文件保存。

(2)功能方面:能够实现线性表的一些基本操作,主要包括:1.计算表最大可以容纳表项个数以及当前表的当前长度。

2.能够进行添加操作,在已有的数据文件中进行数据的添加。

3.能够进行搜索操作,返回搜索项在表中表项序号4.能够进行定位操作,定位到表中合理位置。

5.能够进行取值操作,根据用户需求取出表中某项的值。

6.能够进行修改操作,在用户选择修改项后将重新输入内容修改到对应位置。

7.能够进行插入操作,在用户选择合理位置并输入插入内容后即可。

8.能够进行删除操作,用户根据选择表中项数删除对应数据。

9.能够进行判断表空或表满。

四、系统设计(1)设计的主要思路根据实验要求,首先将顺序表模板类完成,并将需要实现的功能代码完善,在写实现各个功能的菜单并将模板类实例化为简单数据类型最后进行调试,由于还需使得顺序表能够存储自定义的学生类类型数据,故根据要求写出Student类,并将之前所写得模板类用学生类数据类型实例化,再进行调试。

数据结构实验报告顺序表1

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

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

三、顺序表的基本概念顺序表是用一组地址连续的存储单元依次存储线性表中的数据元素。

在顺序表中,逻辑上相邻的元素在物理位置上也相邻。

顺序表可以随机访问表中的任意元素,但插入和删除操作可能需要移动大量元素,效率较低。

四、顺序表的存储结构在 C++中,可以使用数组来实现顺序表。

以下是一个简单的顺序表存储结构的定义:```cppconst int MAX_SIZE = 100; //定义顺序表的最大容量class SeqList {private:int dataMAX_SIZE; //存储数据元素的数组int length; //顺序表的当前长度public:SeqList(){ length = 0; }//构造函数,初始化长度为 0//其他操作函数的声明int GetLength();bool IsEmpty();bool IsFull();int GetElement(int position);int LocateElement(int element);void InsertElement(int position, int element);void DeleteElement(int position);void PrintList();};```五、顺序表的基本操作实现1、获取顺序表长度```cppint SeqList::GetLength(){return length;}```2、判断顺序表是否为空```cppbool SeqList::IsEmpty(){return length == 0;}```3、判断顺序表是否已满```cppbool SeqList::IsFull(){return length == MAX_SIZE;}```4、获取指定位置的元素```cppint SeqList::GetElement(int position) {if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl; return -1;}return dataposition 1;}```5、查找指定元素在顺序表中的位置```cppint SeqList::LocateElement(int element) {for (int i = 0; i < length; i++){if (datai == element) {return i + 1;}}return -1; //未找到返回-1}```6、在指定位置插入元素```cppvoid SeqList::InsertElement(int position, int element) {if (IsFull()){std::cout <<"顺序表已满,无法插入!"<< std::endl; return;}if (position < 1 || position > length + 1) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = length; i >= position; i) {datai = datai 1;}dataposition 1 = element;length++;}```7、删除指定位置的元素```cppvoid SeqList::DeleteElement(int position) {if (IsEmpty()){std::cout <<"顺序表为空,无法删除!"<< std::endl; return;}if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = position; i < length; i++){datai 1 = datai;}length;}```8、打印顺序表中的所有元素```cppvoid SeqList::PrintList(){for (int i = 0; i < length; i++){std::cout << datai <<"";}std::cout << std::endl;}```六、实验结果与分析1、对顺序表进行初始化,创建一个空的顺序表。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
void deletelist(sqlist *l,int i)
{
int j;
if(i<1||i>l->length)return 0;
for(j=i;j<l->length;j++)
l->base[j-1]=l->base[j];
l->length--;
return 1;
}
void main()
{
if(!l->length)
return 1
else
return 0
}
5、.清空操作:
将顺序表L清空,只需将length值为0即可。该操作的实现算法见下:
void clearlist(sqlist &l)
{
l->length=0;
}
6、取元素操作:
当顺序表L非空时,数组下标为i-1的元素即为其第i个元素。该操作算法见下:
(4)、按照实验题目要求独立正确地完成实验内容(编写、调试算法程序,提交程序清单及及相关实验数据与运行结果);
(5)、按时提交实验报告
二.实验环境
计算机、C语言程序设计环境。
三.实验学时
10学时,必做实验。
四.实验内容
1、实现顺序表的基本操作,线性表中数据元素类型为结构体,成员包括学生的姓名、学号、若干课程的成绩(int型),按照顺序存储结构实现如下算法:
成员学号
承担的任务
成 绩
刁二亮
1032101102
程序编写及文档汇总
干敏
1032101136
程序编写及文字部分编写
顾大胜
1032101104
程序编写及文档排版
吴晴
1032101132
程序编写及概述编写
王玮
1032101112
程序编写
课题设计
目的与
设计意义
1、课题设计目的:
了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;
return 1;
}
3、.求长度操作:
顺序表L的length分量的值即为其长度。该操作的实现算法见下:
int listlength(sqlist l){
return l->length;
}
4、.判空操作:
判断顺序表L是否为空即判断其length分量的值是否为0.该操作的实现算法见下:
status lengthisempty(sqlist l)
在信息传递时,希望长度能尽可能短,即采用最短码。顺序的应用,就是采用这种有效的数据压缩技术可以节省数据文件的存储空间和计算机网络的传送时间。
指导教师:余云
2011年12月3日
一.目的
1、设计目的:
数据结构作为一门学科主要研究数据的各种逻辑结构和存储结构,以及对数据的各种操作。因此,主要有三个方面的内容:数据的逻辑结构;数据的物理存储结构;对数据的操作(或算法)。通常,算法的设计取决于数据的逻辑结构,算法的实现取决于数据的物理存储结构。数据结构是信息的一种组织方式,其目的是为了提高算法的效率,它通常与一组算法的集合相对应,通过这组算法集合可以对数据结构中的数据进行某种操作。
if(!newbase)
return -2;
l->base=newbase;
l->listsize+=listspaceincr;
}
for(j=l->length-1;j>=i-1;j--)
l->base[j+1]=l->base[j];
l->base[i-1]=e;
l->length++;
return 1;
初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;
提高综合运用所学的理论知识和方法独立分析和解决问题的能力;
训练用系统的观点和软件开发一般规范进行软件开发,培养软件工作者所应具备的科学的工作方法和作风。
2、课题设计意义:
锻炼我们的编码能力,真正理解数据结构的编码思想,并且锻炼我们的动手能力和成员间的配合,提高程序编写能力。
其中,Loc(Ai)为线性表的第一个元素A1的存储位置,通常又称作线性表的起始地址或基地址,n为线性表的表长。
六.概述
1、顺序表的概述:
通常把使用顺序存储实现的线性表称为顺序表线性表的顺序存储结构是把线性表中所有数据元素,按照其逻辑顺序一次存储到计算机存储器中从指定位置开始的一块连续的存储空间中,数据元素间的存储(物理)位置即表示了它的逻辑位置。
数据结构课程设计
设计题目:顺序表的基本实现和存储结构
学生姓名:刁二亮郭敏顾大胜吴晴王玮
专业班级:10计算机应用(1)班
指导教师:余云
完成时间:2011年12月3日
信息工程院计算机科学系
安徽新华学院课程设计成绩评定表(专科)
课题名称
顺序表基本实现和存储结构
院 系
信息工程学院
年级专业
10计应1班
成员姓名
int locateelem(sqlist l,lelemtype e)
{
int i=0;
while(i<l->length && *(l->base+i)!=e)
i++;
if(i<l->length)
return i+1;
else
return 0;
}
8、插入操作:
在线性表L的第i个位置插入一个新的元素e,则原来的第i个元素变为第i+1个,原来的第i+1个元素就变为第i+2……依次类推。该操作算法见下:
(1)、创建任意线性表,长度限定在100个学生信息之内;
(2)、打印(遍历)该线性表(依次打印出表中元素值);
(3)、在线性表中查找第i个元素,并返回其值;
(4)、在线性表中第i个元素之前插入一已知元素;(5)、在线性源自中删除第i个元素;五.需求分析
线性表的顺序存储结构是把线性表中所有数据元素,按照其逻辑顺序一次存储到计算机存储器中从指定位置开始的一块连续的存储空间中,数据元素间的存储(物理)位置即表示了它的逻辑位置。也就是说,逻辑上的第一个元素就存放在指定的第一个位置,逻辑上的第二个元素就存放在指定的空间的第二个元素,…..依次类推。
void initlist(sqlist *l,int initsize)
{
l->base=(sqlist*)malloc(sizeof(sqlist));
if(!l->base)
return;
l->length=0;
l->listsize=initsize;
}
void creatlist(sqlist *l)
scanf("%d",&a);
switch(a)
{
case 1: printf("\n请输入初始化空间的大小:");
学习数据结构是为了将实际问题中所涉及的对象在计算机中表示出来并对它们进行处理。通过课程设计可以提高学生的思维能力,促进学生的综合应用能力和专业素质的提高。通过此次课程设计主要达到以下目的:
(1)、了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;
(2)、初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;
设线性表L=(a1,a2,a3,….an),假定L中的每个元素需占用K个存储单元,则在线性表存储结构中,L的第i+1个元素的存储地址Loc(ai+1)和第i个数据元素的存储地址loc(ai)之间满足下列关系:
Loc(Ai+1)=Loc(Ai)+k
一般地,线性表中第i个数据元素Ai的存储地址为:
Loc(Ai)=Loc(Ai)+(i-1)*k (1<=i && i>=n)
void insertlist(sqlist *l,int i,int e)
{
lelemtype *newbase;
int j;
if(i<1 || i<l->length+1)
printf("不合理");
return 0;
if(l->length==l->listsize)
{printf("满表");
2、.初始化操作:
在程序中,使用SqList类型用如下语句定义顺序表L:
此时,L实际上只是一个机构体变量,其有3个分量base、length及listSize,但这3个分量并没有确切的值,并且base仅为一个指针量,还没有与之对应的顺序表所需的存储空间。因此在使用顺序表L时,首先应对其进行初始化。所以此初始化操作的作用就是从内存中申请一块可共使用顺序表L使用的大小为InitSize的存储空间。并使L成为一个空表(将其长度赋值为0)
return 0;
}
for(j=l->length-1;j>=i-1;j--)
l->base[j+1]=l->base[j];
l->base[i-1]=e;
l->length++;
return 1;
}
9、删除操作:
该操作作用于删除顺序表L的第i(0<i<=ListLength(L))个数据元素并用e返回其值.时原来的长度为n的顺序表变成长度为n-1.该操作算法见下:
status getelem(sqlist l,int i,lelemtype &e)
{
if(!l->length)
相关文档
最新文档