示例：数据结构实验——基本运算流程图
南邮数据结构上机实验一线性表的基本运算和多项式的基本运算资料
实验报告（2015 / 2016学年第二学期）课程名称数据结构A实验名称线性表的基本运算和多项式的基本运算实验时间2016 年 3 月10 日指导单位计算机科学与技术系指导教师骆健学生姓名班级学号学院(系) 管理学院专业信息管理与信息系统实习题名:线性表的基本运算班级姓名学号日期2016.03.10一、问题描述深入理解线性表数据结构,熟练掌握顺序表的各种基本操作。
在顺序表类SeqList 中增加成员函数void Reverse()，实现顺序表的逆置；在顺序表类SeqList中增加成员函数bool DeleteX(const T &x),删除表中所有元素值等于x元素。
若表中存在这样的元素，则删除之，且函数返回true，否则函数返回false。
二、概要设计文件Inverse.cpp中定义了Linearlist类, SeqList类继承Linearlist类。
在顺序表类SeqList中通过函数void Reverse()实现顺序表的逆置，通过函数boolDeleteX(const T &x),删除表中所有元素值等于x元素。
三、详细设计1.类和类的层次设计程序使用了两个类, 线性表Linearlist类和顺序表SeqList类和一个主函数mian。
Linearlist类里包括常见的线性表运算,在类SeqList里面新增成员函数void Reverse()和bool DeleteX(const T &x)。
TLinearlist#int n+virtual bool IsEmpty() const = 0;+virtual int Length() const = 0;+virtual bool Find(int i,T& x) const = 0;+virtual int Search(T x) const = 0;+virtual bool Insert(int i,T x) = 0;+virtual bool Delete(int i) = 0;+virtual bool Update(int i,T x) = 0;+virtual void Output(ostream& out) const = 0;TSeqList-int maxLength;-T *elements;+IsEmpty() const;+Length() const;+Find(int i,T& x) const;+Search(T x) const;+Insert(int i,T x);+Delete(int i);+Update(int i,T x);+Output(ostream& out) const;+Reverse();+DeleteX(const T& x);2.核心算法顺序表SeqList类中,私有段封装了两个私有数据成员maxLength和elements,公有段封装了构造、析构、查找、删除、逆置等函数。
数据结构实验报告之栈和队列
数据结构实验报告之栈和队列1. 编写程序实现顺序栈的各种基本运算：初始化、销毁、清空、判断是否为空栈、求栈的长度、取栈顶元素、进栈、出栈。
在此基础上设计⼀个主程序完成如下功能：（1）初始化栈s；（2）判断栈s是否为空；（3）依次进栈元素a，b，c，d；（4）判断栈s是否为空；（5）输出栈s的长度；（6）栈⾥元素依次出栈,并输出；（7）销毁栈s。
#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef char SElemType;#define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef struct {SElemType *base; //栈底指针SElemType *top; //栈顶指针int stacksize; //当前已分配的存储空间} SqStack;Status InitStack(SqStack &S) { //构造⼀个空栈SS.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));if (!S.base) exit(OVERFLOW);S.top = S.base;S.stacksize = STACK_INIT_SIZE;return OK;}//InitStackStatus StackLength(SqStack S) {return S.top - S.base;}//StackLengthStatus DestoryStack(SqStack &S) {S.top = S.base;free(S.base);//若base的值为NULL，则表明栈结构不存在S.base = NULL;S.top = NULL;S.stacksize = 0;return OK;}Status StackEmpty(SqStack S) {if (S.top == S.base)return1;elsereturn0;}//StackEmptyStatus GetTop(SqStack S, SElemType &e) {if (S.top == S.base) return ERROR;e = *(S.top - 1);return OK;}//GetTopStatus Push(SqStack &S, SElemType e) {if (S.top - S.base >= S.stacksize) {S.base = (SElemType*)realloc(S.base,(S.stacksize + STACKINCREMENT) * sizeof(SElemType));if (!S.base)exit(OVERFLOW);S.top = S.base + S.stacksize;S.stacksize+= STACKINCREMENT;}*S.top++=e;return OK;}//PushStatus Pop(SqStack &S, SElemType &e) {//判断栈是否为空if (S.base == S.top)return ERROR;e = *(S.top - 1);S.top--;return OK;}//Popvoid main(){SqStack s;SElemType e;printf("(1)初始化栈\n");InitStack(s);printf("(2)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(3)依次进栈元素a，b，c，d\n");Push(s, 'a');Push(s, 'b');Push(s, 'c');Push(s, 'd');printf("(4)The stack is ");if (StackEmpty(s))printf("empty.\n");elseprintf("not empty.\n");printf("(5)The length of the stack is %d\n", StackLength(s));printf("(6)The stack is ");while (!StackEmpty(s)){Pop(s, e);printf("%c \n", e);}printf("(7)销毁栈s");DestoryStack(s);}运⾏结果：2. 编写程序实现链队列的各种基本运算：初始化、销毁、清空、判断是否为空队列、求队列的长度、取队列的头元素、⼊队、出队。
数据结构实验一顺序表
数据结构实验一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；分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
《数据结构》课程设计--流程图PPT教学课件
2020/12/09
3
开始 显示主菜单 选择操作 进入对应操作
结束
int menu_stu(int num)
2020/12/09
4
开始
显示查询菜单
选择查询类型
输入查询关键字
关键字存在？
N
Y
选择查询内容
显示查询结果
结束
查询学生成绩
2020/12/09
5
开始 显示排序菜单 选择排序内容 显示排序结果
结束
学生成绩排序
2020/12/09
6
开始
输入旧密码
旧密码正确？
N
Y
输入 新密码
再次输入新密码
两次输入正确？
N
Y
密码修改成功
结束
2020/12/09
修改学生密码
7
开始
选择输入的学期
选择输入的学科
顺序输入每个学生成绩
成绩合法？
N
Y 成绩输入完成
结束
录入学生成绩
2020/12/09
ቤተ መጻሕፍቲ ባይዱ
8
2020/12/09
开始
查找需修改学生
查找成功？
N
Y 修改学生成绩
结束
修改学生成绩
9
2020/12/09
10
开始 显示欢迎界面 加载学生数据 加载老师数据
初始化指针 进入登陆界面
结束
void main()
2020/12/09
1
开始
输入账号
存在该用户？
N
Y
判断用户类型
输入密码
密码正确？
N
Y
进入主菜单
结束
2020/12/09
数据结构实验报告实现单链表各种基本运算的算法
实验截图（1）void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图（2）bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图（3）bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图（4）编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图（5）运行得到结果实验截图（6）。
数据结构-顺序表-实验报告
实验报告课程数据结构及算法实验项目 1.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机，Windows，DOS，Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算（1）问题描述顺序表时常进行的运算包括：创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。
试编程实现顺序表的这些基本运算。
（2）基本要求实现顺序表的每一个运算要求用一个函数实现。
（3）算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。
（4）算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果：构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件：顺序线性表L已存在。
数据结构实验报告图
数据结构实验报告图数据结构实验报告图问题描述：;四则运算表达式求值，将四则运算表达式用中缀表达式;一、需求分析：;1、本程序是利用二叉树后序遍历来实现表达式的转换;2、输入输出格式：;输入格式：在字符界面上输入一个中缀表达式，回车表;请输入表达式：;输入一个中缀表达式;输出格式：如果该中缀表达式正确，那么在字符界面上;式，其中后缀表达式中两相邻操作数之间利用空格隔开;果不正确，在字符界面上输出问题描述：四则运算表达式求值，将四则运算表达式用中缀表达式，然后转换为后缀表达式，并计算结果。
一、需求分析：1、本程序是利用二叉树后序遍历来实现表达式的转换，同时可以使用实验三的结果来求解后缀表达式的值。
2、输入输出格式：输入格式：在字符界面上输入一个中缀表达式，回车表示结束。
请输入表达式：输入一个中缀表达式输出格式：如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开;如果不正确，在字符界面上输出表达式错误提示。
逆波兰表达式为：3、测试用例输入：21+23*(12-6)输出：21 23 12 6 -*+ 输出逆波兰表达式运算结果为：输出运算后的结果二、概要设计：抽象数据类型二叉树类BiTree算法的基本思想根据题目要求，利用栈计算，和二叉树存储，来计算表达式该算法的基本思想是：先利用栈进行计算，然后用二叉树进行存储，和实验三算法一样来计算逆波兰表达式的值程序的流程程序由三个模块组成：(1) 输入模块：输入一个运算式(2) 计算模块：利用栈进行表达式的计算，二叉树来存储。
(3 ) 输出模块：屏幕上显示出后缀表达式和运算结果。
三、详细设计物理数据类型程序含有两个类，其中栈不再赘述，另一个类为二叉树class BiTree包含私有成员struct BiTreeNode，根节点BiTreeNode *T;索引index; int number_of_point 优先级比较函数compare(char a,char b);生成树的函数void InorderCreate(BiTreeNode *&T,char str,int start,int end);判断数字函数bool IsNumber(char a);求值函数double Operate(BiTreeNode *T);还有显示后缀表达式的函数void display(BiTreeNode *T) ;而公有成员函数则是对私有函数的重载，为方便使用，因为函数中普遍使用了递归的算法。
北京理工大学数据结构与算法设计实验二
《数据结构与算法设计》实验报告——实验二学院：自动化学院班级：06111001学号：**********姓名：宝竞宇一、实验目的掌握栈的建立，输入，删除，出栈等基本操作。
应用栈解决实际问题。
二、实验内容实现简单计算器的功能,请按照四则运算加、减、乘、除、幂（^）和括号的优先关系和惯例，编写计算器程序。
要求支持运算符：+、-、*、/、%、（）和=：①从键盘输入一个完整的表达式，以回车作为表达式输入结束的标志；②输入表达式中的数值均为大于等于零的整数，如果中间计算过程中出现小数也只取整进行计算。
例如，输入：4+2*5= 输出：14输入：(4+2)*(2-10)= 输出：-48三、程序设计1、概要设计抽象数据类型定义：两个栈结构，分别用来储存数据和计算符号宏定义：函数“成功”，“失败的返回值”在主程序程序中先依次输入各表达式，存入相应各栈，然后，调用“判断函数”来判断计算符的优先次序，然后再利用计算函数来计算，表达式值。
其中还有，取栈顶元素函数，存入栈函数。
2、详细设计数据类型实现：struct t{ char dat[200];int top;}prt;入栈函数：存入数组，栈顶指针上移void pushd(long int a){ prd.dat[prd.top++]=a;}出栈：取出对应值，栈顶指针下移long int popd( ){ return prd.dat[--prd.top];}比较优先级：建立数组，比较返回大于小于号。
计算函数：以字符型输入，运算符号，用switch来分支计算判断，返回计算数值long int operation ( long int x, long int y, char a){ s witch(a){ case '+': return x+y;case '-': return x-y;case '*': return x*y;case '/': if ( y )return x/y;else{ printf("Divide 0.\n");return 0;}case '%': return (long int) fmod(x,y);case '^': if (y>=0 ) return (long int) pow(x,y);else return (0);default: printf("Error No. 3\n");return 0;}}主程序：在主程序内，以字符串的形式输入表达式，然后分别调用函数存入各相应栈，然后用数组判断，比较运算符的优先顺序。
数据结构 实验一：实现单链表各种基本运算的算法
- 1 -实验一：实现单链表各种基本运算的算法一、 实验目的1、 掌握单链表存储结构的类型定义；2、 实现单链表各种基本运算的算法。
二、 实验环境1、 Windows 操作系统；2、 Visual C++ 6.0三、 实验内容实现单链表各种基本运算的算法。
四、 概要设计1.存储结构的类型定义：Typedef struct LNode{ElemType data;Struct LNode *next;}LinkList;2.单链表示意图：3.项目组成图:4.algo2_2.cpp 的程序文件包含的函数原型及功能:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L)判断单链表L 是否为空表ListLength(LinkList *L)返回单链表L 的元素个数DispList(LinkList *L)输出单链表LGetElem(LinkList *L,int i,ElemType &e)获取单链表L 的第i 个元素LocateElem(LinkList *L,ElemType e)在单链表L 中查找元素eListInsert(LinkList *&L,int i,ElemType e)在单链表L 中的第i 个位置上插入元素e…… head a 1 a 2 a 3 a n ∧ListDelete(LinkList *&L,int i,ElemType &e)在单链表L中删除第i个元素5.exp2_2.cpp程序文件简介:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L) 判断单链表L是否为空表ListLength(LinkList *L) 返回单链表L的元素个数DispList(LinkList *L) 输出单链表LGetElem(LinkList *L,int i,ElemType &e) 获取单链表L的第i个元素LocateElem(LinkList *L,ElemType e) 在单链表L中查找元素eListInsert(LinkList *&L,int i,ElemType e) 在单链表L中的第i个位置上插入元素e ListDelete(LinkList *&L,int i,ElemType &e) 在单链表L中删除第i个元素6.proj2-2的项目的模块结构:在文件algo2-2中，(1)定义单链表结构类型；(2)初始化单链表(3)定义释放单链表的函数(4)定义判断单链表是否为空的函数(5)定义返回单链表元素个数的函数(6)定义输出单链表的函数(7)定义获取第i个元素的函数(8)定义查找元素的函数(9)定义插入元素的函数(10)定义删除元素的函数在文件exp2-2中分别调用algo2-2中所定义的函数7.函数调用关系图:五、详细设计源代码清单见附录。
数据结构实验报告完成多项式的运算
简单介绍：本次作业力在学会链表表示线性表的插入、删除、查找等基本操作设计与实现，学习利用链表提供的接口去求解实际问题，同时熟悉链表的的存储方法。
再基于线性链表的基础设计完成多项式的相加运算程序。
一、实验目的和要求完成多项式的相加、相乘运算。
（1）掌握线性表的插入、删除、查找等基本操作设计与实现（2）学习利用线性表提供的接口去求解实际问题（3）熟悉线性表的的存储方法二、实验内容和原理1.实验内容设计一个一元多项式的简单计算程序，其基本功能有：（1）输入并建立多项式；（2）输出多项式；（3）多项式的相加运算。
利用单链表实现。
2.实验原理使用单链表实现一元多项式的存储，并实现两个一元多项式的加法运算。
三、实验环境硬件：（1）学生用微机（2）多媒体教室或远程教学（3）局域网环境软件：（1）Windows XP中文操作系统（2）VC6.0四、算法描述及实验步骤1、描述：加法：输入建立一元多项式,进行简单加法运算,输出结果；通过建立单链表A和B分别存放多项式的a和b的各项系数及指数；并且利用A使得不产生新的节点而在A中存放数据运算结果；该过程通过定义指针变量p和q使它们分别指向两个多项式的第一个节点，之后依次比较它们所指向的项的指数，即一种情况指数相等时系数相加且和不为零，修改当前p所指项的系数（和），同时删除q所指项，若和为零则同时删除p和q各自所指；情况二，p当前项指数大于q当前项，将q所指插入p所指之前作为结果项之一；情况三，p当前项指数小于q当前项，p所指作为多项式和的一项，移动p指向下一项，进行比较，在移动p，q至其中以个链空，把另一个链余下节点插在p所指之后；乘法：定义指针p,q指向所操作节点，通过A链表的每一项与B链表各项相乘，指数相加，系数相乘，将值赋给新节点各自域，构成一新的链表，最后返回头结点。
可这样有一个问题，即新生成的链表，即最终结果混乱，没有对数据进行过滤，相同指数项应在执行加法运算，所以可以这样实现，通过A链表的每一项与B链表各项相乘的新生成节点单独构成一链表，并将第一个链表加入另一新链表，循环此操作将后生成的链表加之先前的链表，即可实现排序问题。
数值分析各算法流程图
01,,n1,,n1,,)n x及数值分析各算法流程图一、插值1、 拉格朗日插值流程图：( 相应程序：lagrintp(x,y,xx))2,,n ,,j n 1,2,,n 1,,)n 2、 牛顿插值流程图(1)产生差商表的算法流程图(相应程序：divdiff(x,y))注：1、另一程序divdiff1(x,y)，输出的矩阵包含了节点向量。
而divdiff(x,y)不含节点向量。
2、另一程序tableofdd(x,y,m)，输出的是表格形式，添加了表头。
1,,),,n m 及1,,m (2)非等距节点的牛顿插值流程图(相应程序：newtint11(x,y,xx,m)) 、注：1、虽然程序newtint11(x,y,xx,m)考虑了多种情形，看上去很复杂，但基本流程结构还是如上图所示。
2、程序中调用的子程序是divdiff 。
若调用的子程序是divdiff1的话，流程图中的第三，第四，第五步要相应的改一下数字。
2,3,,1m +1,,j1,2,,n=1,2,,)n m 及(3)求差分表的流程图(相应程序：difference(y,m))注：1、difference 输出的是矩阵D 。
而另一程序tableofd(y,m)，输出的是带有表头的差分表。
n x m1,,),,1,,m注：1、程序newtforward1(x,y,xx,m))的结构与上述流程图一致，xx可以是数组。
2、另一程序newtforward(x,y,xx,m))先求出插值多项式，再求插值多项式在插值点的函数值。
基本结构还是和上面的流程图一样。
n x m1,,),,-x x1,,m注：1、程序newtbackward1(x,y,xx,m))的结构与上述流程图一致，xx可以是数组。
2、另一程序newtbackward(x,y,xx,m))先求出插值多项式，再求插值多项式在插值点的函数值。
基本结构还是和上面的流程图一样。
1,2,,n1,2,,n ,2,,)n x及3、Hermite 插值流程图(1) 已知条件中一阶导数的个数与插值节点的个数相等时的Hermite 插值流程图。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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）初始化顺序表L；（2）依次在表尾插⼊a，b，c，d，e五个元素；（3）输出顺序表L；（4）输出顺序表L的长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插⼊元素f，之后输出顺序表L；（9）删除L的第2个元素，之后输出顺序表L；（10）销毁顺序表L。
2、编写程序实现单链表的各种基本运算：初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。
在此基础上设计⼀个主程序完成如下功能：（1）初始化单链表L；（2）依次在表尾插⼊a，b，c，d，e五个元素；（3）输出单链表L；（4）输出单链表L的长度；（5）判断单链表L是否为空；（6）输出单链表L的第4个元素；（7）输出元素c的位置；（8）在第3个位置上插⼊元素f，之后输出单链表L；（9）删除L的第2个元素，之后输出单链表L；（10）销毁单链表L。
1顺序表2 #include<stdio.h>3 #include<malloc.h>4 #include<stdlib.h>56#define TRUE 17#define FALSE 08#define OK 19#define ERROR 010#define INFEASIBLE -111#define OVERFLOW -212 typedef int Status;13 typedef char ElemType;1415#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量16#define LISTINCREMENT 10 //线性表存储空间的分配增量17 typedef struct {18 ElemType *elem; //存储空间基地址19int length; //当前长度20int listsize; //当前分配的存储容量21 } SqList;2223 Status InitList_Sq(SqList &L) { //算法2.324 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));25if (!L.elem) exit(OVERFLOW); //存储分配失败26 L.length = 0; //空表长度为027 L.listsize = LIST_INIT_SIZE; //初始存储容量28return OK;29 }//InitList_Sq3031 Status ListInsert_Sq(SqList &L, int i, ElemType e) { //算法2.432 ElemType *newbase, *p, *q;33if (i<1 || i>L.length + 1) return ERROR; //i值不合法34if (L.length >= L.listsize)35 { //当前存储空间已满，增加分配36 newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));37if (!newbase) exit(OVERFLOW); //存储分配失败38 L.elem = newbase; //新基址39 L.listsize += LISTINCREMENT; //增加存储容量40 }41 q = &(L.elem[i - 1]); //q为插⼊位置42for (p = &(L.elem[L.length - 1]); p >= q; --p) *(p + 1) = *p; //元素右移43 *q = e; //插⼊e44 ++L.length; //表长增145return OK;46 }4748void DispSqList(SqList L)49 {50int i;51for (i = 0; i < L.length; i++)52 printf("%c ", L.elem[i]);53 }5455 Status ListDelete(SqList &L, int i, ElemType &e)56 {57 ElemType *p,*q;58if ((i < 1) || (i > L.length)) return ERROR;59 p = &(L.elem[i - 1]);60 e = *p;61 q = L.elem + L.length - 1;62for (++p; p <= q; ++p)63 *(p - 1) = *p;64 --L.length;65return OK;66 } //ListDelete_Sq6768 Status GetElem(SqList L, int i, ElemType &e)69 {70if (L.length == 0 || i<1 || i>L.length)71return ERROR;72 e = L.elem[i - 1];73return OK;74 }7576int ListLength(SqList L)77 {78return(L.length);79 }8081 Status DestroyList(SqList &L)82 {83 free(L.elem);84 L.length = 0;85return OK;86 }8788 Status ListEmpty(SqList L)89 {90return(L.length == 0);91 }9293int LocateElem(SqList L, ElemType e)94 {95int i = 0;96while (i < L.length && L.elem[i] != e) i++;97if (i >= L.length) return0;98else return i + 1;99 }100101void main()102 {103 SqList h;104 ElemType e;105 InitList_Sq(h);106 ListInsert_Sq(h, h.length + 1, 'a');107 ListInsert_Sq(h, h.length + 1, 'b');108 ListInsert_Sq(h, h.length + 1, 'c');109 ListInsert_Sq(h, h.length + 1, 'd');110 ListInsert_Sq(h, h.length + 1, 'e');111 DispSqList(h);112 printf("%d\n\n",ListLength(h));113 ListEmpty(h);114if (ListEmpty(h))116 printf("Empty\n\n");117 }118else119 {120 printf("Not empty\n\n");121 }122 GetElem(h, 4, e);123 printf("%c\n", e);124 printf("%d\n",LocateElem(h, 'c'));125 ListInsert_Sq(h,3,' f');126 DispSqList(h);127 ListDelete(h, 2, e);128 DispSqList(h);129 DestroyList(h);130 }131132133134135136单链表137138139140 #include<stdio.h>141 #include<malloc.h>142 #include<stdlib.h>143144#define TRUE 1145#define FALSE 0146#define OK 1147#define ERROR 0148#define INFEASIBLE -1149#define OVERFLOW -2150 typedef int Status;151152 typedef char ElemType;153154155 typedef struct LNode {156 ElemType data;157int length;158struct LNode *next;159 }LNode, *LinkList;160161162 Status InitList_L(LinkList &L) {163 L = (LinkList)malloc(sizeof(LNode));164 L->next = NULL;165return OK;166 }167168 Status ListInsert_L(LinkList L, int i, ElemType e) { 169 LinkList p = L,s;170int j = 0;171while (p && j < i - 1)172 {173 p = p->next;174 ++j;175 }176if (!p || j > i - 1)177 {178return ERROR;179 }180else181 {182 s = (LinkList)malloc(sizeof(LNode));183 s->data = e;184 s->next = p->next;185 p->next = s;186return OK;187 }188 }189190void DispList_L(LinkList L)191 {192 LinkList p = L->next;193while (p != NULL)194 {195 printf("%c\n", p->data);196 p = p->next;197 }198200201void DestoryList(LinkList &L)202 {203 LinkList p = L, q = p->next;204while (q != NULL)205 {206 free(p);207 p = q;208 q = p->next;209 }210 free(p);211 }212213 Status ListLength_L(LinkList L) {214 LinkList p = L; int n = 0;215while (p->next != NULL)216 {217 n++;218 p = p->next;219 }220return (n);221 }222223 Status ListDelete(LinkList L, int i, ElemType &e){ 224int j;225 LinkList p, q;226 p = L;227 j = 1;228while (p->next && j < i)229 {230 p = p->next;231 ++j;232 }233if (!(p->next) || j > i)234 {235return ERROR;236 }237 q = p->next;238 p->next = q->next;239 e = q->data;240 free(q);241return OK;242 }243244 Status ListEmpty_L(LinkList L)245 {246return(L->length == 0);247 }248249 Status GetElem(LinkList L, int i, ElemType &e) 250 {251int j;252 LinkList p;253 p = L->next;254 j = 1;255while (p&&j<i)256 {257 p = p->next;258 ++j;259 }260if (!p || j > i)261 {262return ERROR;263 }264 e = p->data;265return OK;266 }267268 Status LocateElem(LinkList L, int e)269 {270 LinkList p = L;271int n=0;272//p->length = 0;273while (p != NULL)274 {275if(p->data != e)276 {277 p = p->next;278 n++;279 }280else281 {282break;283 }284 }285if(p != NULL)286 {287return n;288 }289else290 {291return ERROR;292 }293 }294295void main()296 {297 LinkList h;298 ElemType e;299 InitList_L(h);300 ListInsert_L(h, 1, 'a');301 ListInsert_L(h, 2, 'b');302 ListInsert_L(h, 3, 'c');303 ListInsert_L(h, 4, 'd');304 ListInsert_L(h, 5, 'e');305 DispList_L(h);306 printf("%d\n", ListLength_L(h)); 307if (ListEmpty_L(h))308 {309 printf("Empty\n\n");310 }311else312 {313 printf("Not empty\n\n");314 }315 GetElem(h, 4, e);316 printf("%c\n", e);317 printf("%d\n", LocateElem(h, 'c')); 318 ListInsert_L(h, 3, 'f');319 DispList_L(h);320 ListDelete(h, 2, e);321 DispList_L(h);322 DestoryList(h);323 }。
数据结构--线性表的基本运算及多项式的算术运算
数据结构:线性表的基本运算及多项式的算术运算一、实验目的和要求实现顺序表和单链表的基本运算，多项式的加法和乘法算术运算。
要求：能够正确演示线性表的查找、插入、删除运算。
实现多项式的加法和乘法运算操作。
二、实验环境(实验设备)X64架构计算机一台，Windows 7操作系统，IDE: Dev C++ 5.11编译器: gcc 4.9.2 64bit二、实验原理及内容程序一：实现顺序表和单链表的实现本程序包含了四个文件，分别是LinearListMain.cpp，linearlist.h，seqlist.h，singlelist.h。
分别是主程序，线性表抽象类，顺序储存线性表的实现，链表储存顺序表的实现。
文件之间的关系图：本程序一共包含了三个类：分别是LinearList（线性表抽象类），SeqList（顺序储存的线性表），SingleList（链表储存的线性表）。
类与类之间的关系图如下：其实，抽象类LinearList规定了公共接口。
分别派生了SeqList类和SingleList。
SingleList类与SingleList类分别实现了LinearList类中的所有接口。
程序代码以及分析：Linearlist类：#include <iostream>using namespace std;template <class T>class LinearList{protected:int n; //线性表的长度public:virtual bool IsEmpty() const=0; //判读是否是空线性表virtual int Length() const=0; //返回长度virtual bool Find(int i,T& x) const=0; //将下标为i的元素储存在x中，成功返回true，否则返回falsevirtual int Search(T x) const=0; //寻找值是x的元素，找到返回true，否则返回falsevirtual bool Insert(int i,T x)=0; //在下标为i的元素后面插入xvirtual bool Delete(int i)=0; //删除下标为i的元素virtual bool Update(int i,T x)=0;//将下标为i的元素更新为x virtual void Output(ostream& out)const=0; //将线性表送至输出流};包含了一个保护数据成员n，和8种运算，具体说明见注释。
数据结构实验图的基本操作
浙江大学城市学院实验报告课程名称数据结构实验项目名称实验十三/十四图的基本操作学生姓名专业班级学号实验成绩指导老师（签名）日期2014/06/09一.实验目的和要求1、掌握图的主要存储结构。
2、学会对几种常见的图的存储结构进行基本操作。
二.实验内容1、图的邻接矩阵定义及实现：建立头文件test13_AdjM.h，在该文件中定义图的邻接矩阵存储结构，并编写图的初始化、建立图、输出图、输出图的每个顶点的度等基本操作实现函数。
同时建立一个验证操作实现的主函数文件test13.cpp（以下图为例），编译并调试程序，直到正确运行。
2、图的邻接表的定义及实现：建立头文件test13_AdjL.h，在该文件中定义图的邻接表存储结构，并编写图的初始化、建立图、输出图、输出图的每个顶点的度等基本操作实现函数。
同时在主函数文件test13.cpp中调用这些函数进行验证（以下图为例）。
3、填写实验报告，实验报告文件取名为report13.doc。
4、上传实验报告文件report13.doc到BB。
注: 下载p256_GraphMatrix.cpp(邻接矩阵)和p258_GraphAdjoin.cpp(邻接表)源程序，读懂程序完成空缺部分代码。
三. 函数的功能说明及算法思路（包括每个函数的功能说明，及一些重要函数的算法实现思路）四. 实验结果与分析（包括运行结果截图、结果分析等）五.心得体会程序比较难写，但是可以通过之前的一些程序来找到一些规律（记录实验感受、上机过程中遇到的困难及解决办法、遗留的问题、意见和建议等。
）【附录----源程序】256://p-255 图的存储结构以数组邻接矩阵表示, 构造图的算法。
#include <iostream.h>#include <stdio.h>#include <stdlib.h>#include <string.h>typedef char VertexType; //顶点的名称为字符const int MaxVertexNum=10; //图的最大顶点数const int MaxEdgeNum=100; //边数的最大值typedef int WeightType; //权值的类型const WeightType MaxValue=32767; //权值的无穷大表示typedef VertexType Vexlist[MaxVertexNum]; //顶点信息，定点名称typedef WeightType AdjMatrix[MaxVertexNum][MaxVertexNum]; //邻接矩阵typedef enum{DG,DN,AG,AN} GraphKind; //有向图,有向网,无向图,无向网typedef struct{Vexlist vexs; // 顶点数据元素AdjMatrix arcs; // 二维数组作邻接矩阵int vexnum, arcnum; // 图的当前顶点数和弧数GraphKind kind; // 图的种类标志} MGraph;void CreateGraph(MGraph &G, GraphKind kd)// 采用数组邻接矩阵表示法，构造图G{//构造有向网Gint i,j,k,q;char v, w;G.kind=kd; //图的种类printf("输入要构造的图的顶点数和弧数：\n");scanf("%d,%d",&G.vexnum,&G.arcnum);getchar();//过滤回车printf("依次输入图的顶点名称ABCD...等等：\n");for (i=0; i<G.vexnum; i++) scanf("%c",&G.vexs[i]);//构造顶点数据getchar();//过滤回车for (i=0; i<G.vexnum; i++) //邻接矩阵初始化for (j=0; j<G.vexnum; j++)if(kd==DN||kd==AN)G.arcs[i][j]=MaxValue; //网，初始值为无穷大elseG.arcs[i][j]=0; //图，初始为0if(kd==DN||kd==AN)printf("按照：尾顶点名->头顶点名，权值输入数据:如A->B,23 \n");elseprintf("按照：尾顶点名->头顶点名输入数据:A->B\n");for (k=0; k<G.arcnum; k++){ //构造邻接矩阵if(kd==DN||kd==AN)scanf("%c->%c,%d",&v,&w,&q); //输入弧的两个定点及该弧的权重elsescanf("%c->%c",&v,&w);getchar();for(i=0;i<G.vexnum; i++)if(G.vexs[i]==v) break;//查找出v在vexs[]中的位置iif(i==G.vexnum) {cerr<<"vertex ERROR!";exit(1);}for(j=0;j<G.vexnum; j++)if(G.vexs[j]==w) break;//查找出v在vexs[]中的位置jif(j==G.vexnum) {cerr<<"vertex ERROR!";exit(1);}if(kd==AN)//无向网{G.arcs[i][j]=q; //邻接矩阵对应位置置权值G.arcs[j][i]=q; //无向图为对称矩阵}else if(kd==DN)//有向网G.arcs[i][j]=q;else if(kd==AG)//无向图{G.arcs[i][j]=1; //对称矩阵G.arcs[j][i]=1;}else //有向图G.arcs[i][j]=1;// getchar();}}//CreateGraph/* 注意输入格式,按以下方式输入构造有向网输入要构造的网的顶点数和弧数：4,5依次输入网的顶点名称ABCD...等等：abcd按照：尾顶点名->头顶点名，权值输入数据:如A->B,23a->b,5a->c,8c->b,7a->d,4d->c,3输出邻接矩阵∞| 5 | 8 | 4 |∞| ∞| ∞| ∞|∞| 7 | ∞| ∞|∞| ∞| 3 | ∞|Press any key to continue*/void PrintMGraph(MGraph &G){int i,j;switch(G.kind){case DG:for (i=0; i<G.vexnum; i++){for (j=0; j<G.vexnum; j++)printf(" %2.d | ",G.arcs[i][j]);printf("\n");}break;case DN:for (i=0; i<G.vexnum; i++){for (j=0; j<G.vexnum; j++){if(G.arcs[i][j]!=MaxValue) printf(" %2.d | ",G.arcs[i][j]);else printf(" ∞| ");}printf("\n");}break;case AG:for (i=0; i<G.vexnum; i++){for (j=0; j<G.vexnum; j++){printf(" %2.d | ",G.arcs[i][j]);}printf("\n");}break;case AN: //********完成构造无向网****************/* 请模仿编写无向网*/for (i=0; i<G.vexnum; i++){for (j=0; j<G.vexnum; j++){if(G.arcs[i][j]!=MaxValue) printf(" %2.d | ",G.arcs[i][j]);else printf(" ∞| ");}printf("\n");}break;}}//*****************完成函数********************************** void countdig(MGraph G) //请完成计算图的入度或初度{if(G.kind==DG||G.kind==DN){//计算有向图或网的各个顶点的入度与出度int outD,inD;int i,j;for(i=0;i<G.vexnum;i++){outD=inD=0;for(j=0;j<G.vexnum;j++){if(G.arcs[i][j]!=0&&G.arcs[i][j]!=MaxValue)outD++;}for(j=0;j<G.vexnum;j++){if(G.arcs[j][i]!=0&&G.arcs[j][i]!=MaxValue)inD++;}printf("%c：出度是%d,入度是%d\n",G.vexs[i],outD,inD);}}else{// 计算无向图或网的度int i,j;int Du;for(i=0;i<G.vexnum;i++){Du=0;for(j=0;j<G.vexnum;j++){if(G.arcs[i][j]!=0&&G.arcs[i][j]!=MaxValue)Du++;}printf("%c的度是%d\n",G.vexs,Du);}}}//************参照p265设计深度有限搜索***********void DFSMatrix(MGraph G,int i,int n,bool*visited){cout<<G.vexs[i]<<' ';visited[i]=true;for(int j=0;j<n;j++)if(G.arcs[i][j]!=0&&G.arcs[i][j]!=MaxValue&& !visited[j])DFSMatrix(G,j,n,visited);}//************参照p268设计广度有限搜索***********void BFSMatrix(MGraph G,int i, int n , bool*visited){const int MaxSize=30;int q[MaxSize]={0};int front=0,rear=0;cout<<G.vexs[i]<<' ';visited[i]=true;q[++rear]=i;while(front!=rear){front=(front+1)%MaxSize;int k=q[front];for(int j=0;j<n;j++){if(G.arcs[i][j]!=0&&G.arcs[i][j]!=MaxValue&& !visited[j]){cout<<G.vexs[j]<<' ';visited[j]=true;rear=(rear+1)%MaxSize;q[rear=j];}}}}void main(){MGraph G;int k;printf("请选择图的种类：0:有向图,1:有向网,2:无向图,3:无向网. 请选择：");scanf("%d",&k);switch(k) { //DG,DN,AG,ANcase 0:printf("构造有向图\n");CreateGraph(G,DG); // 采用数组邻接矩阵表示法，构造有向图break;case 1:printf("构造有向网\n");CreateGraph(G,DN); // 采用数组邻接矩阵表示法，构造有向网AGGbreak;case 2:printf("构造无向图\n");CreateGraph(G,AG); // 采用数组邻接矩阵表示法，构造无向图AGGbreak;case 3:printf("构造无向网\n");CreateGraph(G,AN); // 采用数组邻接矩阵表示法，构造无向网AGGbreak;}PrintMGraph(G); //打印图的邻接矩阵bool*visited=new bool[G.vexnum];int i;cout<<"按图的邻接矩阵得到的深度优先遍历序列"<<endl;for(i=0;i<G.vexnum;i++) visited[i]=false;DFSMatrix(G,0,G.vexnum,visited);cout<<"按图的邻接矩阵得到的广度优先遍历序列"<<endl;for(i=0;i<G.vexnum;i++) visited[i]=false;BFSMatrix(G,0,G.vexnum,visited);cout<<"度："<<endl;countdig(G);}258://p-258 图的存储结构以邻接表表示, 构造图的算法。