第三次数据结构课程实验

哈尔滨理工大学数据结构第3次实践课内容

必做●SubString (&Sub, S, pos, len)求子串●Index (S, T, pos)字符串查找#include <stdio.h>#include <stdlib.h>#define INTERLENGTH 100#define INCREASE 10#define OK 1#define ERROR -1#define overflow -2typedef struct{char *data;int length;int size;}Sqlist;int cj(Sqlist &L){L.data=(char *)malloc(INTERLENGTH*sizeof(char));if(L.data==NULL)exit(overflow);L.length=0;L.size=INTERLENGTH;return OK;}int AgainMalloc(Sqlist &L){char *newbase;newbase=(char *)realloc(L.data,(INCREASE+L.size)*sizeof(char)); if(newbase==NULL)exit(overflow);L.data=newbase;L.size+=INCREASE;return OK;}int insert(Sqlist &L,char a){if(L.length==L.size){AgainMalloc(L);}L.data[L.length]=a;L.length++;return OK;int travel(Sqlist &L){for(int i=0;i<L.length;i++)printf("%c",L.data[i]);printf("\n");return OK;}int clear(Sqlist &L){L.length=0;return OK;}int SubString(Sqlist &L,int pos,int len,Sqlist &sub) {if(pos<1||pos>L.length||len<0||len>L.length-pos+1) {printf("²»ºÏ·¨ ");exit(overflow);}cj(sub);clear(sub);int i;for(i=pos-1;i<pos+len-1;i++){insert(sub,L.data[i]);}return OK;}int index(Sqlist &L,Sqlist &sub){int i=0;int j=0;while(i<L.length&&j<sub.length){if(L.data[i]==sub.data[j]){i++;j++;}else{i=i-j+1;j=0;}}if(j>=sub.length)return i-sub.length+1;elsereturn ERROR;}int main(){Sqlist L,sub;cj(L);char c;printf("请输入字符串：\n");while((c=getchar())!='\n'){insert(L,c);}printf("求得从2位置开始4位自串如下：\n"); SubString(L,2,4,sub);travel(sub);clear(sub);printf("请输入待查找字符串；\n");while((c=getchar())!='\n'){insert(sub,c);}int a= index(L,sub);printf("%d",a);}。

数据结构实验报告三

数据结构实验报告三数据结构实验报告三引言：数据结构是计算机科学中的重要内容之一，它研究的是如何组织和存储数据以便高效地访问和操作。

本实验报告将介绍我在数据结构实验三中的实验过程和结果。

实验目的：本次实验的主要目的是熟悉并掌握树这种数据结构的基本概念和操作方法，包括二叉树、二叉搜索树和平衡二叉树等。

实验内容：1. 实现二叉树的创建和遍历在本次实验中，我首先实现了二叉树的创建和遍历。

通过递归的方式，我能够方便地创建一个二叉树，并且可以使用前序、中序和后序遍历方法对二叉树进行遍历。

这些遍历方法的实现过程相对简单，但能够帮助我们更好地理解树这种数据结构的特点。

2. 实现二叉搜索树的插入和查找接下来，我实现了二叉搜索树的插入和查找操作。

二叉搜索树是一种特殊的二叉树，它的左子树上的节点的值都小于根节点的值，右子树上的节点的值都大于根节点的值。

通过这种特性，我们可以很方便地进行插入和查找操作。

在实现过程中，我使用了递归的方法，通过比较节点的值来确定插入的位置或者进行查找操作。

3. 实现平衡二叉树的插入和查找平衡二叉树是为了解决二叉搜索树在某些情况下可能会退化成链表的问题而提出的。

它通过在插入节点的过程中对树进行旋转操作来保持树的平衡。

在本次实验中，我实现了平衡二叉树的插入和查找操作。

通过对树进行左旋、右旋等操作，我能够保持树的平衡，并且能够在O(log n)的时间复杂度内进行插入和查找操作。

实验结果：通过本次实验，我成功地实现了二叉树、二叉搜索树和平衡二叉树的相关操作。

我编写了测试代码，并对代码进行了测试，结果表明我的实现是正确的。

我能够正确地创建二叉树，并且能够使用前序、中序和后序遍历方法进行遍历。

对于二叉搜索树和平衡二叉树，我能够正确地进行插入和查找操作，并且能够保持树的平衡。

实验总结：通过本次实验，我深入了解了树这种数据结构的特点和操作方法。

二叉树、二叉搜索树和平衡二叉树是树的重要应用，它们在实际开发中有着广泛的应用。

数据结构实验-第3次试验-图的应用

第三次实验图的应用
[问题描述] 给定一个图，设计一个程序，找出一条从某一顶点A到另一顶点B边数最少的一条路径。 [输入] 图的顶点个数N，图中顶点之间的边的关系及要找的路径的起点A和终点B。 [输出] 若A到B无路径，则输出“There is no path”，否则输出A到B路径上各顶点。 [存储结构] 图采用邻接矩阵或邻接表的方式存储。
实现时采用队列记录被访问过的顶点。每次访问与队头顶点
相邻接的顶点，然后将队头顶点从队列中删去。若队空，则说明到
不存在通路。在访问顶点过程中，每次把当前顶点的序号作为与其邻接的未访问的顶点的前驱顶点记录下来，以便输出时回溯。
Байду номын сангаас
[算法的基本思想] 采用广度优先搜索的方法，从顶点A开始，依次访问与A邻接的顶点VA1,VA2,...,VAK, 访问遍之后,若没有访问B，则继续访问与VA1邻接的顶点VA11,VA12,...,VA1M，再访问与VA2邻接顶点...，如此下去，直至找到B，最先到达B点的路径，一定是边数最少的路径。

数据结构实验三实验报告

数据结构实验三实验报告数据结构实验三实验报告一、实验目的本次实验的目的是通过实践掌握树的基本操作和应用。

具体来说，我们需要实现一个树的数据结构，并对其进行插入、删除、查找等操作，同时还需要实现树的遍历算法，包括先序、中序和后序遍历。

二、实验原理树是一种非线性的数据结构，由结点和边组成。

树的每个结点都可以有多个子结点，但是每个结点只有一个父结点，除了根结点外。

树的基本操作包括插入、删除和查找。

在本次实验中，我们采用二叉树作为实现树的数据结构。

二叉树是一种特殊的树，每个结点最多只有两个子结点。

根据二叉树的特点，我们可以使用递归的方式实现树的插入、删除和查找操作。

三、实验过程1. 实现树的数据结构首先，我们需要定义树的结点类，包括结点值、左子结点和右子结点。

然后，我们可以定义树的类，包括根结点和相应的操作方法，如插入、删除和查找。

2. 实现插入操作插入操作是将一个新的结点添加到树中的过程。

我们可以通过递归的方式实现插入操作。

具体来说，如果要插入的值小于当前结点的值，则将其插入到左子树中；如果要插入的值大于当前结点的值，则将其插入到右子树中。

如果当前结点为空，则将新的结点作为当前结点。

3. 实现删除操作删除操作是将指定的结点从树中移除的过程。

我们同样可以通过递归的方式实现删除操作。

具体来说，如果要删除的值小于当前结点的值，则在左子树中继续查找；如果要删除的值大于当前结点的值，则在右子树中继续查找。

如果要删除的值等于当前结点的值，则有三种情况：- 当前结点没有子结点：直接将当前结点置为空。

- 当前结点只有一个子结点：将当前结点的子结点替代当前结点。

- 当前结点有两个子结点：找到当前结点右子树中的最小值，将其替代当前结点，并在右子树中删除该最小值。

4. 实现查找操作查找操作是在树中寻找指定值的过程。

同样可以通过递归的方式实现查找操作。

具体来说，如果要查找的值小于当前结点的值，则在左子树中继续查找；如果要查找的值大于当前结点的值，则在右子树中继续查找。

国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案

{
x=Pop(s); /*出栈*/
printf("%d ",x);
InQueue(sq,x); /*入队*/
}
printf("\n");
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
ElemType Pop(SeqStack *s); /*出栈*/
ElemType GetTop(SeqStack *s); /*取栈顶元素*/
void DispStack(SeqStack *s); /*依次输出从栈顶到栈底的元素*/
void DispBottom(SeqStack *s); /*输出栈底元素*/
} SeqQueue; /*定义顺序队列*/
void InitStack(SeqStack *s); /*初始化栈*/
int StackEmpty(SeqStack *s); /*判栈空*/
int StackFull(SeqStack *s); /*判栈满*/
void Push(SeqStack *s,ElemType x); /*进栈*/
sq=(SeqQueue *)malloc(sizeof(SeqQueue));
InitQueue(sq);
printf("(8)队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
printf("(9)出栈/入队的元素依次为:");

北邮数据结构第三次实验-实验报告

数据结构实验报告实验名称：实验三——栈和队列学生姓名：班级：班内序号：学号：日期：1.实验要求1.1 实验目的通过选择下面两个题目之一进行实现，掌握如下内容：➢掌握二叉树基本操作的实现方法➢了解赫夫曼树的思想和相关概念➢学习使用二叉树解决实际问题的能力1.2 实验内容根据二叉树的抽象数据类型的定义，使用二叉链表实现一个二叉树。

二叉树的基本功能：1、二叉树的建立2、前序遍历二叉树3、中序遍历二叉树4、后序遍历二叉树5、按层序遍历二叉树6、求二叉树的深度7、求指定结点到根的路径8、二叉树的销毁9、其他：自定义操作编写测试main()函数测试线性表的正确性2. 程序分析2.1 二叉链表2.2 二叉树的二叉链表存储示意图2.3 关键算法分析2.3.1算法1：void create(Binode<T> *&R, T data[], int i);[1] 算法功能：创建一个二叉树[2] 算法基本思想：通过构造函数创建一个二叉树，构造函数通过调用函数create()创建二叉树，关于函数create()的伪代码：1.定义根指针，输入节点储存的data，若输入“#”，则该节点为空；2.申请一个新节点，判断它的父结点是否不为空，如果不为空在判断其为左或者右孩子，并把地址付给父结点，把data写入。

[3] 算法空间、时间复杂度：O（n）[4] 代码逻辑（可用伪代码描述）：if(data[i-1]!=0){R = new Binode<T>;R->data= data[i-1];R->lch = R->rch = NULL;create(R->lch, data,2*i);create(R->rch, data, 2*i+1);}2.3.2算法2：void Destroy(Binode<T> *R);[1] 算法功能：二叉树的销毁[2] 算法基本思想：采用后序遍历的方法，释放节点。

福师大计算机系数据结构实验三

实验报告（三）：栈及其应用专业：计算机科学与技术班级：计本班姓名：学号：日期： 2012-10-11 1实验目的1)掌握顺序栈的类型定义方法。

2)掌握在顺序栈上实现的六种基本操作。

3)掌握顺序栈的简单应用。

4)掌握链栈的实现、并能够清楚对比栈的两种实现方法的优劣。

2实验内容1)设计和实现一个栈数据结构（可以是顺序栈，链栈）。

2)实现栈数据结构的各种操作，包括栈的初始化、出入栈、清空和释放栈等。

3)在上述实现的栈的基础上，实现栈的应用：写一个算法，完成表达式的求值。

4)上述栈的实现和应用不限制顺序栈或者链式栈，两者皆可。

3实验要求1)提前预习该实验相关的内容，包括栈的两种实现方法，以及具体存储结构上的各类栈操作。

2)选择其中一种存储方法加以实现，并完成相关操作实现。

3)设计并实现算法完成实验内容中表达式的求值。

4)编写完整的程序完成实验内容，并上机调试和运行。

5)整理并上交实验报告。

6)本次实验要求在4学时内完成。

4数据结构设计4.1栈结构设计（采取单链表的结构）类图的设计：字段4.2基本操作所要实现的基本操作：1)完成表达式的求值。

5实现5.1设计实现//"public.h"#pragma once#pragma region声明#include<string.h>#include<ctype.h>//malloc() 等函数#include<malloc.h>//INT_MAX#include<limits.h>//EOF (=^Z或F6)，NULL#include<stdio.h>//atoi()#include<stdlib.h>//eof()#include<io.h>#include<math.h>//exit()#include<process.h>//cout,cin#include<iostream>using namespace std;//函数结果状态代码#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status;typedef int Boolean;typedef char SElemType;#pragma endregion//"DefinitionForSqStack.h"栈的定义#pragma once#include"public.h"#define STACK_INIT_SIZE 10#define STACKINCREMENT 2//顺序栈struct SqStack{//在栈构造之前和销毁之后，base的值为NULLSElemType *base;//栈顶指针SElemType *top;//当前已经分配的存储空间，以元素为单位int stacksize;};5.2操作实现5.2.1顺序栈的操作实现//"DefinitionForSqStack.h"#pragma once#include"public.h"#define STACK_INIT_SIZE 10#define STACKINCREMENT 2Status InitStack(SqStack & s){if(!(s.base = (SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType)))){//存储分配失败exit(OVERFLOW);}s.top = s.base;s.stacksize = STACK_INIT_SIZE;return OK;}Status DestroyStack(SqStack & s){//销毁栈s，s不再存在free(s.base);s.base = NULL;s.top = NULL;s.stacksize = 0;return 0;}Status ClearStack(SqStack & s){//把s置为空栈s.top = s.base;return OK;}Status StackEmpty(SqStack & s){//若栈s为空栈，则返回TRUE，否则返回FALSEif(s.top == s.base){return TRUE;}else{return FALSE;}}Status StackLength(SqStack & s){//返回s的元素个数，即栈的长度return s.top - s.base;}Status GetTop(SqStack & s,SElemType & e){//若栈不空，则用e返回s的栈顶元素，并返回OK；否则返回ERROR if(s.top > s.base){e = *(s.top - 1);return OK;}else{return ERROR;}}Status Push(SqStack & s,SElemType & e){//插入元素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;}Status Pop(SqStack & s,SElemType & e){//若栈不空。

数据结构第三次实验报告概况

实验报告
2013-2014 学年第 1 学期任课老师：刘安丰课程名称实验名称实验环境 C++ 实验目的和内容要求数据结构班级学号实验时间姓名 12 月 5 号
实验三
图的操作算法
作算法
实现图的常用操作算法：包括建立图的存储结构、深度优先搜索和广度优先搜索，求图的最小生成树、拓扑排序、最短路径等。二、实验目的 1．掌握图的基本存储方法。 2．掌握有关图的操作算法并用高级语言实现。 3．熟练掌握图的两种搜索路径的遍历方法。 4. 掌握图的有关应用。
G.arcs[j][i].adj = G.arcs[i][j].adj; } return OK; } int LocateVex(MGraph G,char ch) //确定节点 ch 在图 G.vexs 中的位置 { int a ; for(int i=0; i<G.vexnum; i++) { if(G.vexs[i] == ch) a=i; } return a; } //typedef struct Pnode //用于普利姆算法 //{ // char adjvex; //节点 // double lowcost; //权值 //}Pnode,Closedge[MAX_VERTEX_NUM]; //记录顶点集 U 到 V-U 的代价最小的边的辅助数组定义 void MiniSpanTree_PRIM(MGraph G,char u)//普利姆算法求最小生成树 { int i,j,k; Closedge closedge; k = LocateVex(G,u); for(j=0; j<G.vexnum; j++) { if(j != k) { closedge[j].adjvex = u; closedge[j].lowcost = G.arcs[k][j].adj; } } closedge[k].lowcost = 0; for(i=1; i<G.vexnum; i++) { k = Minimum(G,closedge); cout<<"("<<closedge[k].adjvex<<","<<G.vexs[k]<<","<<closedge[k].lowcost<<")"<<endl; closedge[k].lowcost = 0; for(j=0; j<G.vexnum; ++j) { if(G.arcs[k][j].adj < closedge[j].lowcost) { closedge[j].adjvex = G.vexs[k]; closedge[j].lowcost= G.arcs[k][j].adj; } } }

北理工数据结构实验三

北理工数据结构实验三《数据结构与算法设计》实验报告——实验三学院：班级：学号：姓名：一、实验目的1.通过实验实践、巩固二叉树和队列的相关操作；2.熟悉VC环境，加强编程、调试的练习；3.用C语言实现二叉树和队列的抽象数据类型；4.用C语言编写递归函数，实现生成二叉树和遍历二叉树；5.用队列实现二叉树的层次遍历；6.理论知识与实际问题相结合，利用上述基本操作用多种方式遍历二叉树。

二、实验内容1、遍历二叉树。

请输入一棵二叉树的扩展的前序序列，经过处理后生成一棵二叉树，然后对于该二叉树输出前序、中序和后序遍历序列。

2、选做：按层次遍历二叉树。

三、程序设计1、概要设计为实现上述程序功能，需要建立抽象数据类型：二叉树和队列。

（1）、定义抽象数据类型二叉树的抽象数据类型定义为：ADT BinaryTree {数据对象D：D是具有相同特性的数据元素的集合。

数据关系R：若D=Φ，则R=Φ，称BinaryTree为空二叉树；若D≠Φ，则R={H}，H是如下二元关系；（1）在D中存在惟一的称为根的数据元素root，它在关系H下无前驱；（2）若D-{root}≠Φ，则存在D-{root}={D1,Dr}，且D1∩Dr =Φ；（3）若D1≠Φ，则D1中存在惟一的元素x1，∈H，且存在D1上的关系H1 ?H；若Dr≠Φ，则Dr中存在惟一的元素xr，∈H，且存在上的关系Hr ?H；H={,,H1,Hr}；（4）(D1,{H1})是一棵符合本定义的二叉树，称为根的左子树；(Dr,{Hr})是一棵符合本定义的二叉树，称为根的右子树。

基本操作：CreatBiTree(BiTree &T)操作结果：按先序次序建立二叉链表表示的二叉树TPreOrderTraverse(BiTree T)初始条件：二叉树T已经存在操作结果：先序遍历二叉树T ，对每个结点输出其数据元素InOrderTraverse(BiTree T)初始条件：二叉树T已经存在操作结果：中序遍历二叉树T ，对每个结点输出其数据元素PostOrderTraverse(BiTree T)初始条件：二叉树T已经存在操作结果：后序遍历二叉树T ，对每个结点输出其数据元素LevelOrderTraverse(BiTree T)初始条件：二叉树T已经存在操作结果：层次遍历二叉树T ，对每个结点输出其数据元素} ADT BinaryTree队列的抽象数据类型定义为：ADT Stack{数据对象：D={ai|ai∈ElemSet,i=1,2,3……,n,n≥0}数据关系：R1={ |ai∈D,i=1,2,……,n}约定其中a1端为队列头，an端为队列尾基本操作：InitQueue(&Q)功能：构造一个空队列Q。

数据结构第三次试验

对全部高中资料试卷电气设备，在安装过程中以及安装结束后进行高中资料试卷调整试验；通电检查所有设备高中资料电试力卷保相护互装作置用调与试相技互术关，通系电1，力过根保管据护线生高0不产中仅工资2艺料22高试2可中卷以资配解料置决试技吊卷术顶要是层求指配，机置对组不电在规气进范设行高备继中进电资行保料空护试载高卷与中问带资题负料2荷试2，下卷而高总且中体可资配保料置障试时2卷，32调需3各控要类试在管验最路；大习对限题设度到备内位进来。行确在调保管整机路使组敷其高设在中过正资程常料1工试中况卷，下安要与全加过，强度并看工且25作尽52下可22都能护可地1关以缩于正小管常故路工障高作高中；中资对资料于料试继试卷电卷连保破接护坏管进范口行围处整，理核或高对者中定对资值某料，些试审异卷核常弯与高扁校中度对资固图料定纸试盒，卷位编工置写况.复进保杂行护设自层备动防与处腐装理跨置，接高尤地中其线资要弯料避曲试免半卷错径调误标试高方中等案资，，料要编试求5写、卷技重电保术要气护交设设装底备备置。4高调、动管中试电作线资高气，敷料中课并设3试资件且、技卷料中拒管术试试调绝路中验卷试动敷包方技作设含案术，技线以来术槽及避、系免管统不架启必等动要多方高项案中方；资式对料，整试为套卷解启突决动然高过停中程机语中。文高因电中此气资，课料电件试力中卷高管电中壁气资薄设料、备试接进卷口行保不调护严试装等工置问作调题并试，且技合进术理行，利过要用关求管运电线行力敷高保设中护技资装术料置。试做线卷到缆技准敷术确设指灵原导活则。。：对对在于于分调差线试动盒过保处程护，中装当高置不中高同资中电料资压试料回卷试路技卷交术调叉问试时题技，，术应作是采为指用调发金试电属人机隔员一板，变进需压行要器隔在组开事在处前发理掌生；握内同图部一纸故线资障槽料时内、，设需强备要电制进回造行路厂外须家部同出电时具源切高高断中中习资资题料料电试试源卷卷，试切线验除缆报从敷告而设与采完相用毕关高，技中要术资进资料行料试检，卷查并主和且要检了保测解护处现装理场置。设。备高中资料试卷布置情况与有关高中资料试卷电气系统接线等情况，然后根据规范与规程规定，制定设备调试高中资料试卷方案。

《数据结构》实验报告三：几种查找算法的实现和比较

第三次实验报告：几种查找算法的实现和比较//2019-12-4//1.随机生成5万个整数，存入一个文件；//2.算法实现：（1）顺序查找：读入文件中的数据，查找一个key，统计时间；// （2）二分查找：读入文件，排序，二分查找key，统计时间；// （3）分块查找：读入文件，分100块，每块300+数字，查找key，统计时间// （4）二分查找树：读入文件，形成BST，查找key，统计时间//二叉排序树：建立，查找#include "stdio.h"#include "time.h"#include "stdlib.h"struct JD{//定义分块查找的链表结点结构int data;JD *next;};struct INDEX_T{//定义分块查找中，索引表结构int max;//这一块中最大的数字，<maxJD *block;//每一块都是一个单向链表，这是指向块的头指针};INDEX_T myBlock[100];//这是索引表的100项struct NODE{//定义的二分查找树结点结构int data;NODE *left;NODE *right;};const int COUNT=50000;//结点个数int key=666;//待查找的关键字int m=1;//int *array2;void createData(char strFileName[]){//产生随机整数，存入文件srand((unsigned int)time(0));FILE *fp=fopen(strFileName,"w");for(int i=1;i<=COUNT;i++)fprintf(fp,"%d,",rand());fclose(fp);}void createBST(NODE* &bst){//产生5万个随机整数，创建二叉排序树FILE *fp=fopen("data.txt","r");for(int i=1;i<=COUNT;i++){int num;fscanf(fp,"%d,",&num);//从文件中读取一个随机整数//若bst是空子树，第一个结点就是根结点//若bst不是空子树，从根结点开始左小右大，查找这个数字，找到了直接返回，//找不到，就插入到正确位置//创建一个结点NODE* p=new NODE;p->data=num;p->left=0;p->right=0;if(0==bst)//空子树{bst=p;continue;}//非空子树,//在bst中，查找给结点，NODE *q=bst;//总是从根结点开始查找while(1){if(p->data == q->data)//找到了，直接退出break;if(p->data < q->data && q->left==0){//小，往左找，且左边为空，直接挂在q之左q->left=p;break;}if(p->data < q->data && q->left!=0){//小，往左找，且左边非空，继续往左边找q=q->left;continue;}if(p->data > q->data && q->right==0){//大，往右找，且右边为空，直接挂在q之右q->right=p;break;}if(p->data > q->data && q->right!=0){//大，往右找，且右边非空，继续往右边找q=q->right;continue;}}}}int BST_Search(NODE *bst,int key){//在bst中找key，if(0==bst)return -1;//非空子树,//在bst中，查找给结点，NODE *q=bst;//总是从根结点开始查找while(1){if(key == q->data)//找到了，直接退出return 1;if(key < q->data && q->left==0)//小，往左找，且左边为空，找不到return -1;if(key < q->data && q->left!=0)//小，往左找，且左边非空，继续往左边找{q=q->left;continue;}if(key > q->data && q->right==0)//大，往右找，且右边为空，找不到return -1;if(key > q->data && q->right!=0){//大，往右找，且右边非空，继续往右边找q=q->right;continue;}}}void inOrder(NODE *bst){if(bst!=0){inOrder(bst->left);array2[m]=bst->data;//反写回array数组，使数组有序// printf("%7d",array2[m]);m++;inOrder(bst->right);}}int getBSTHeight(NODE *bst){if(bst==0)return 0;else{int hl=getBSTHeight(bst->left);int hr=getBSTHeight(bst->right);int h=hl>hr?hl:hr;return h+1;}}void makeArray(int array[],char strFileName[]) {//生成5万个随机整数FILE *fp=fopen(strFileName,"r");int i=1;while(!feof(fp)){fscanf(fp,"%d,",&array[i]);// printf("%6d",array[i]);i++;}}int Seq_Search(int array[],int key){//在无序顺序数组中，找data是否存在，-1=不存在，存在返回位置下标//监视哨：把要找的那个数放到首部array[0]=key;//for(int i=COUNT;array[i]!=key;i--);if(i>0)//找到了，返回下标return i;return -1;//查找不成功，返回-1}int Bin_Search(int array[],int key){//在有序存储的数组中查找key，找到返回位置，找不到返回-1 int low=1,high=COUNT,mid;while(1){if(low>high)//找不到return -1;mid=(low+high)/2;if(key == array[mid])return mid;else if(key<array[mid])high=mid-1;elselow=mid+1;}}void makeBlock(INDEX_T myBlock[],char strFileName[]) {//从文件中读取整数，分配到块中去//1.初始化块索引表，分100块，400,800,1200，for(int i=0;i<=99;i++){myBlock[i].max=400+400*i;//400,800,1200, (40000)myBlock[i].block=0;}//2.打开文件，读取整数，把每一个整数分配到相应的块中去FILE *fp=fopen(strFileName,"r");while(!feof(fp)){int num=0;fscanf(fp,"%d,",&num);//把num分配到num/400块中，挂到该块链表第一个int blockID=num/400;//求出应该挂在的块号//生成一个新节点，把num放进去，挂上JD *p=new JD;p->data=num;p->next=myBlock[blockID].block;myBlock[blockID].block=p;}fclose(fp);}int Block_Search(INDEX_T myBlock[],int key){int blockID=key/400;//找到块号JD* p=myBlock[blockID].block;while(p!=0){if(p->data==key)return blockID;//能找到p=p->next;}return -1;//找不到}void main(){clock_t begin,end;int pos=-1;//1.生成文件，存入5万个随机整数createData("data.txt");//2.顺序查找int *array=new int[COUNT+1];makeArray(array,"data.txt");//从文件中读取数据begin=clock();for(int k=1;k<=10000;k++)pos=Seq_Search(array,key);end=clock();printf("顺序查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//3.二分查找树NODE *bst=0;createBST(bst);//产生5万个随机数字，建立一个二叉排序树begin=clock();for(k=1;k<=10000;k++)pos=BST_Search(bst,key);//在bst中找key，找到返回1，找不到返回-1end=clock();printf("二叉排序树查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);array2=new int[COUNT+1];inOrder(bst);//中序输出bst// int height=getBSTHeight(bst);//求出bst的高度// printf("BST高度=%d.\n\n",height);//4.二分查找，利用前面二叉排序树产生的array2，查找key begin=clock();for(k=1;k<=10000;k++)pos=Bin_Search(array2,key);end=clock();printf("二分查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//5.分块查找，关键字范围[0,32767],分配到100块中去，每一块中存400个数字makeBlock(myBlock,"data.txt");//从文件中读取数据，产生块begin=clock();for(k=1;k<=10000;k++)pos=Block_Search(myBlock,key);//在block中查找key，找到返回块号，找不到返回-1end=clock();printf("分块查找：%d所在的块=%d.时间=%d毫秒\n",key,pos,end-begin);/*for(k=0;k<=99;k++){printf("\n\n\n第%d块<%d:\n",k,myBlock[k].max);JD *q=myBlock[k].block;//让q指向第k块的第一个结点while(q!=0){//输出第k块中所有数字printf("%7d ",q->data);q=q->next;}}*/}。

吉林大学数据结构第三次上机实验题目

第三次上机
验证试验（必作题）：
题目：二叉树相关算法的实验验证
[实验目的]
验证二叉树的链接存储结构及其上的基本操作。

[实验内容及要求]
1、定义链接存储的二叉树类。

2、实验验证如下算法的正确性、各种功能及指标：
1）创建一棵二叉树，并对其初始化；
2）先根、中根、后根遍历二叉树；
3）在二叉树中搜索给定结点的父结点；
4）搜索二叉树中符合数据域条件的结点；
3、由教师随机指定树结构，测试上述功能；
设计实验（选作题）：
题目：判别给定二叉树是否为完全二叉树。

[实验目的]
在掌握二叉树的链接存储及基本操作的基础上，设计解决问题的算法。

[实验内容及要求]
设计算法判别给定二叉树t是否为完全二叉树；实现链接存储的二叉树类。

大连东软信息学院数据结构III实验报告

实验报告（一）实验过程任务一：下面5个操作任选1个完成，写出代码。

1 修改顺序表insert方法中的for循环语句，初始化j=curLen-1实现插入功能并测试选1package三级项目Text;public class Demo {public Object[] listElem;public int curLen;public Demo(){listElem=new Object[50];}public void insert(int i,Object x)throws Exception{if(curLen==listElem.length)throw new Exception("顺序表已满");if(i<0||i>curLen)throw new Exception("插入位置不合法");for(int j=curLen;j>i;j--)listElem[j]=listElem[j-1];listElem[i]=x;curLen++;}public int indexOf(Object x){int j;for(j=0;j<curLen&&!listElem[j].equals(x);j++);if(j<curLen)return j;elsereturn -1;}}package三级项目Text;public class TestDemo {public static void main(String[]args)throws Exception{Demo L=new Demo();L.insert(0, "系");L.insert(1, "专业");L.insert(2, "Text");L.insert(3, "123123");L.insert(4, "学号");int order=L.indexOf("学号");if(order!=-1)System.out.println("顺序表中出现的值为’学号‘的数据元素的位置为："+order);elseSystem.out.println("此顺序表中不包含值为'学号'的数据元素");}}2 将顺序表查找方法indexOf（Object x）中的while循环修改为for循环并测试3 实现顺序表的输出方法display（），并测试4 定义indexOf（int i，Object x）方法，实现从顺序表第i个位置开始查找x对象第一次出现的位置,并测试5 定义indexOf2（Object x）方法，实现从顺序表逆序查找x对象第一次出现的位置，并测试任务二：下面3个操作任选1个完成，写出代码。

数据结构实验三

数据结构实验报告第三次实验一、实验目的1、复习结构体、指针；2、掌握链表的创建、遍历等操作；3、了解函数指针。

二、实验内容1、（必做题）每个学生的成绩信息包括：学号、语文、数学、英语、总分、加权平均分；采用链表存储若干学生的成绩信息；输入学生的学号、语文、数学、英语成绩；计算学生的总分和加权平均分（语文占30%，数学占50%，英语占20%）；2、（必做题）可以在链表末尾追加新学生的成绩信息；可以根据学号，删除该学生的成绩信息。

3、（选做题）可以根据学号或总分，升序排序学生的成绩信息。

三、算法描述（采用自然语言描述）首先创建链表存储n个学生的成绩信息，再通过键盘输入学生的信息，创建指针p所指结点存储学生的成绩信息，从键盘读入学生人数，求出学生的总分和加权平均分，输出结果。

四、详细设计（画出程序流程图）五、程序代码（给出必要注释）#include <stdio.h>#include <stdlib.h>typedef struct score_grade{long number;int Chinese;int Math;int English;int sum;double average;struct score_grade *next;}student;student* Input_Score(int n){int i;student *stu,*p,*q;p=(student*)malloc(sizeof(student));stu=p;q=p;printf("请输入第1个考生的信息\n");scanf("%ld",&p->number);scanf("%d",&p->Chinese);scanf("%d",&p->Math);scanf("%d",&p->English);p->sum=(p->Chinese)+(p->Math)+(p->English);p->average=(p->Chinese)*0.3+(p->Math)*0.5+(p->English)*0.2;for(i=2;i<=n;i++){p=(student*)malloc(sizeof(student));p->next=NULL;printf("请输入第%d个考生的信息\n",i);scanf("%ld",&p->number);scanf("%d",&p->Chinese);scanf("%d",&p->Math);scanf("%d",&p->English);p->sum=(p->Chinese)+(p->Math)+(p->English);p->average=(p->Chinese)*0.3+(p->Math)*0.5+(p->English)*0.2;q->next=p;q=p;}return stu;}void Output(student *stu,int n){int i;student *p;printf("学生考试信息\n");while(p->next!=NULL){printf("学生学号：%ld\n",p->number);printf("语文成绩：%d\n",p->Chinese);printf("数学成绩：%d\n",p->Math);printf("英语成绩：%d\n",p->English);printf("总分：%d\n",p->sum);printf("平均分：%.1f\n",p->average);printf("\n");p=p->next;}printf("学生学号：%ld\n",p->number);printf("语文成绩：%d\n",p->Chinese);printf("数学成绩：%d\n",p->Math);printf("英语成绩：%d\n",p->English);printf("总分：%d\n",p->sum);printf("平均分：%.1f\n",p->average);printf("\n");}void Delete(student *stu){long number;printf("请输入需要删除的考生学号\n");scanf("%ld",&number);student *a,*b;a=stu;b=stu->next;while(b){if((b->number)==number){a->next=b->next;free(b);break;}a=a->next;b=b->next;}}{int n,a,i;printf("请输入考生人数：\n");scanf("%d",&n);student *stu;stu=Input_Score(n);Output(stu,n);Delete(stu);Output(stu,n);}六、测试和结果（给出测试用例以及测试结果）七、用户手册（告诉用户如何使用程序）输入考生人数和考生信息便可以运行程序。

数据结构基础实验3

浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验三算法和算法分析学生姓名专业班级学号实验成绩指导老师（签名）日期一. 实验目的和要求1. 通过对算法的分析，了解提高算法的运算速度和降低算法的存储空间之间的矛盾。

2. 通过对算法复杂度的分析，掌握计算时间复杂度和空间复杂度的基本方法。

3. 初步掌握测试算法运行时间的基本方法。

二. 实验内容1、根据算法编写程序已知输入x ，y ，z 三个不相等的整数，试根据如下算法（N-S 图）编写一个C 语言函数，实现三个数从小到大顺序的输出。

x 中已存放最小数）y 中已存放次小数）三个数排序算法的N-S 图要求：把该程序存放在文件test3_1.cpp 中，编译并调试程序，直到正确运行。

并请分析：该算法要进行__3___次比较，在最好的情况下需要交换数据元素_0____次，在最坏的情况下需要交换数据元素_9_____次。

2、测试算法的运行时间在此，我们通过一个比较两个算法执行效率的程序例子，掌握测试算法运行时间的基本方法。

这里涉及到C语言中标准的函数库sys/timeb。

sys/timeb函数库中提供了处理与时间相关的函数。

其中函数ftime的功能是获取当前的系统时间。

步骤1：输入两个C语言主程序test3_2.cpp和test3_3.cpp。

主文件(test3_2.cpp) ：# include <stdio.h># include <sys/timeb.h> //时间函数void main(){1 timeb t1, t2;2 long t;3 double x, sum=1, sum1;4 int i, j, n;5 printf("请输入x，n：") ;6 scanf("%lf,%d", &x, &n) ;7 ftime(&t1) ; // 求得当前时间8 for(i=1; i<=n; i++)9 {10 sum1=1;11 for(j=1; j<=i; j++)12 sum1=sum1*(-1.0/x) ;13 sum+=sum1;14 }15 ftime(&t2) ; // 求得当前时间16 t=(t2.time-t1.time)*1000+(litm) ; //计算时间差，转换成毫秒17 printf("sum=%lf 用时%ld毫秒\n", sum, t) ;}该算法的N-S图如下所示。

国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案

}
/*判队空*/
int QueueEmpty(SeqQueue *sq)
{
if(sq->rear==sq->front)
return 1;
else
return 0;
}
/*循环队列入队*/
void InQueue(SeqQueue *sq,ElemType x)
{
if ((sq->rear+1)%MaxSize==sq->front) /*队满*/
InitStack(s);
printf("(2)栈为%s\n",(StackEmpty(s)?"空":"非空"));
printf("(3)输入要进栈的数据个数：");
scanf("%d",&n);
printf("依次输入进栈的%d个整数：",n);
/*数据依次进栈*/
for(i=0; i<n; i++)
{
printf("循环队列已空，不能进行出队操作！\n");
exit(1);
}
else{
x=sq->data[sq->front];
sq->front=(sq->front+1)%MaxSize;
return x;
}
}
/*取队头元素*/
ElemType GetQueue(SeqQueue *sq)
{
void InitQueue(SeqQueue *sq); /*初始化队列*/
int QueueEmpty(SeqQueue *sq); /*判队空*/

山东大学数据结构实验报告三

数据结构实验报告——实验三实验题目：排序算法学号：日期：2014.11.26 班级：物联网工程姓名：Email：实验目的：线性表操作任务要求： 1掌握线性表的基本操作。

2、使用链表存储。

3、自表首插入元素，删除一个指定元素，查找指定元素。

软件环境：Win7 操作系统开发工具：visual C++ 6.0实验步骤：#include<iostream>#include<conio.h>#define LEN sizeof(LNode) //定义LEN为一个节点的长度using namespace std;enum BOOL{False,True}; //定义BOOL型typedef struct node{int data; //数据域struct node *next;//指向下一个节点的指针}LNode,*LinkList;void CreatList(LinkList &,int); //生成一个单链表BOOL ListInsert(LinkList &,int,int); //在单链表首中插入一个元素BOOL ListDelete(LinkList &,int,int&); //在单链表中删除一个元素BOOL ListFind_keyword(LinkList,int,int &); //按关键字查找一个元素BOOL ListFind_order(LinkList,int &,int); //按序号查找一个元素void ListPrint(LinkList); //显示单链表所有元素void main() {LinkList L; BOOL temp;int num,loc,ch,j,flag=1;//---------------------程序解说-----------------------cout<<"本程序实现链式结构的线性表的操作。

数据与结构的第三次实验报告

第三次实验报告庄振涛实验题3-1实现循环单链表的各种基本运算，完成以下功能：（1）初始化循环单链表H。

（2）采用尾插法插入a,b,c,d,e。

（3）输出循环单链表H。

（4）输出循环单链表H的长度。

（5）在第3个位置上插入f。

（6）输出循环单链表H。

（7）删除第2个数据。

（8）输出循环单链表H。

程序：#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct LNode /*定义单链表结点类型*/{ElemType data;struct LNode *next;} LinkList;void InitList(LinkList *&L){L=(LinkList *)malloc(sizeof(LinkList)); /*创建头结点*/ L->next=L;}void DestroyList(LinkList *&L){LinkList *p=L,*q=p->next;while (q!=L){free(p);p=q;q=p->next;}free(p);}int ListEmpty(LinkList *L){return(L->next==L);}int ListLength(LinkList *L){LinkList *p=L;int i=0;while (p->next!=L){i++;p=p->next;}return(i);}void DispList(LinkList *L){LinkList *p=L->next;while (p!=L){printf("%c",p->data);p=p->next;}printf("\n");}int GetElem(LinkList *L,int i,ElemType &e) {int j=0;LinkList *p;if (L->next!=L) /*单链表不为空表时*/ {if (i==1){e=L->next->data;return 1;}else /*i不为1时*/{p=L->next;while (j<i-1 && p!=L){j++;p=p->next;}if (p==L)return 0;else{e=p->data;return 1;}}}else /*单链表为空表时*/return 0;}int LocateElem(LinkList *L,ElemType e){LinkList *p=L->next;int n=1;while (p!=L && p->data!=e){p=p->next;n++;}if (p==L)return(0);elsereturn(n);}int ListInsert(LinkList *&L,int i,ElemType e){int j=0;LinkList *p=L,*s;if (p->next==L || i==1) /*原单链表为空表或i==1时*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}else{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{s=(LinkList *)malloc(sizeof(LinkList)); /*创建新结点*s*/s->data=e;s->next=p->next; /*将*s插入到*p之后*/p->next=s;return 1;}}}int ListDelete(LinkList *&L,int i,ElemType &e){int j=0;LinkList *p=L,*q;if (p->next!=L) /*原单链表不为空表时*/{if (i==1) /*i==1时*/{q=L->next; /*删除第1个结点*/L->next=q->next;free(q);return 1;}else /*i不为1时*/{p=L->next;while (j<i-2 && p!=L){j++;p=p->next;}if (p==L) /*未找到第i-1个结点*/return 0;else /*找到第i-1个结点*p*/{q=p->next; /*q指向要删除的结点*/p->next=q->next; /*从单链表中删除*q结点*/free(q); /*释放*q结点*/return 1;}}}else return 0;extern void InitList(LinkList *&L); /*以下均为外部函数*/extern void DestroyList(LinkList *&L);extern int ListEmpty(LinkList *L);extern int ListLength(LinkList *L);extern void DispList(LinkList *L);extern int GetElem(LinkList *L,int i,ElemType &e);extern int LocateElem(LinkList *L,ElemType e);extern int ListInsert(LinkList *&L,int i,ElemType e); extern int ListDelete(LinkList *&L,int i,ElemType &e);}void main(){LinkList *h;ElemType e;printf("(1)初始化循环单链表h\n");InitList(h);printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(h,1,'a');ListInsert(h,2,'b');ListInsert(h,3,'c');ListInsert(h,4,'d');ListInsert(h,5,'e');printf("(3)输出循环单链表h:");DispList(h);printf("(4)循环单链表h长度=%d\n",ListLength(h));printf("(5)在第3个元素位置上插入f元素\n");ListInsert(h,3,'f');printf("(6)输出循环单链表h:");DispList(h);printf("(7)删除h的第2个元素\n");ListDelete(h,2,e);printf("(8)输出循环单链表h:");DispList(h);}}结果：实验题3-2 实现顺序栈的各种基本运算，完成以下功能：（1）初始化顺序栈S。

数据结构实验报告三

数据结构实验报告三数据结构实验报告三引言：数据结构作为计算机科学的重要基础，对于计算机程序的设计和性能优化起着至关重要的作用。

在本次实验中，我们将深入研究和实践数据结构的应用，通过实验来验证和巩固我们在课堂上所学到的知识。

一、实验目的本次实验的主要目的是通过实践操作，进一步掌握和理解数据结构的基本概念和操作。

具体来说，我们将学习并实现以下几个数据结构：栈、队列、链表和二叉树。

通过对这些数据结构的实现和应用，我们将更好地理解它们的特点和优势，并能够灵活运用于实际问题的解决中。

二、实验内容1. 栈的实现与应用栈是一种后进先出（LIFO）的数据结构，我们将学习如何使用数组和链表两种方式来实现栈，并通过实例来演示栈的应用场景，如括号匹配、表达式求值等。

2. 队列的实现与应用队列是一种先进先出（FIFO）的数据结构，我们将学习如何使用数组和链表两种方式来实现队列，并通过实例来演示队列的应用场景，如任务调度、消息传递等。

3. 链表的实现与应用链表是一种动态数据结构，相比数组具有更好的灵活性和扩展性。

我们将学习如何使用指针来实现链表，并通过实例来演示链表的应用场景，如链表的插入、删除、反转等操作。

4. 二叉树的实现与应用二叉树是一种常见的树形结构，我们将学习如何使用指针来实现二叉树，并通过实例来演示二叉树的应用场景，如二叉树的遍历、搜索等操作。

三、实验过程1. 栈的实现与应用我们首先使用数组来实现栈，并编写相关的入栈、出栈、判空、获取栈顶元素等操作。

然后，我们通过括号匹配和表达式求值两个实例来验证栈的正确性和应用性。

2. 队列的实现与应用我们使用数组来实现队列，并编写相关的入队、出队、判空、获取队头元素等操作。

然后，我们通过任务调度和消息传递两个实例来验证队列的正确性和应用性。

3. 链表的实现与应用我们使用指针来实现链表，并编写相关的插入、删除、反转等操作。

然后，我们通过链表的插入和删除操作来验证链表的正确性和应用性。