数据结构实验四五六

合集下载

数据结构实验四报告

数据结构实验四报告

实验日期:_______________ 实验指导老师:
实验4 无向图的深度优先搜索
一、实验目的和实验环境
【实验目的】
1、了解图的定义、特点,区分无向图和有向图的概念;
2、了解图的数据结构和搜索方法;
3、掌握无向图的邻接矩阵、邻接表的表示方法;
4、写出无向图的深度优先搜索程序。

【实验环境】VC++6.0
二、理论依据
邻接多重表是无向图的一种很有效链式存储结构,在邻接表中容易求得顶点和边的各种信息。

除了在边结点中增加一个标志域外,邻接多重表所需的存储量和邻接表相同。

三、实验内容
设无向图G有n个点e条边,写一算法建立G的邻接多表,并按照深度优先搜索输出顶点,要求该算法时间复杂性为O(n+e),且除邻接多表本身所占空间之外只用O(1)辅助空间。

四、实验步骤
1、了解图的定义、特点,区分无向图和有向图的概念;
2、了解图的数据结构和搜索方法;
3、掌握无向图的邻接矩阵、邻接表的表示方法;
4、写出无向图的深度优先搜索程序
五、实验结果
1.源代码如下:
实验日期:_______________ 实验指导老师:
2.运行界面截图如下:
六、小结
1、在创建邻接多重表时,由于邻接多重表的数据类型为字符型,键盘输入总是很难控制。

这时可以通过人为设置函数过滤去键盘输入中的空格。

2、在邻接多重表上,各种基本操作的实现和邻接表相似。

3、在邻接多重表中,所有依附于同一顶点的边串联在同一链表中。

《数据结构》实验报告

《数据结构》实验报告

《数据结构》实验报告目录一、实验概述 (2)二、实验原理 (2)2.1 数据结构基本概念 (3)2.2 选择的数据结构类型 (4)2.3 实验原理说明 (5)三、实验步骤 (6)3.1 实验准备 (7)3.2 数据结构选择与实现 (7)3.2.1 数据结构类型选择 (9)3.2.2 数据结构实现细节 (9)3.3 实验功能实现 (10)3.3.1 功能一 (11)3.3.2 功能二 (12)四、实验结果与分析 (13)4.1 实验数据 (15)4.2 结果展示 (16)4.2.1 结果一展示 (17)4.2.2 结果二展示 (17)4.3 结果分析 (18)4.3.1 结果一分析 (19)4.3.2 结果二分析 (20)五、实验总结与讨论 (22)5.1 实验总结 (23)5.2 实验中遇到的问题及解决方法 (24)5.3 对数据结构的认识与体会 (25)5.4 对实验教学的建议 (27)一、实验概述本次实验旨在通过实际操作,加深对《数据结构》课程中所学理论知识的理解和掌握。

实验内容围绕数据结构的基本概念、常用算法以及在实际应用中的实现进行设计。

通过本次实验,学生将能够:理解并掌握线性表、栈、队列、链表、树、图等基本数据结构的特点和适用场景。

掌握常用的数据结构操作算法,如插入、删除、查找等,并能够运用这些算法解决实际问题。

学习使用C++、或其他编程语言实现数据结构的操作,提高编程能力和算法设计能力。

本次实验报告将对实验的目的、内容、步骤、结果及分析等方面进行详细阐述,旨在通过实验过程的学习,提高学生对数据结构理论知识的理解和应用能力。

二、实验原理数据结构的基本概念:介绍数据结构的基本定义,包括数据元素、数据集合、数据关系等基本概念,以及数据结构的三要素:逻辑结构、存储结构和运算。

栈和队列:介绍栈和队列的定义、特点、基本运算及其在算法设计中的重要性。

树和二叉树:讲解树的基本概念、二叉树的结构特点、遍历方法、二叉搜索树及其在数据检索中的应用。

数据结构实验报告_实验报告_

数据结构实验报告_实验报告_

数据结构实验报告想必学计算机专业的同学都知道数据结构是一门比较重要的课程,那么,下面是小编给大家整理收集的数据结构实验报告,供大家阅读参考。

数据结构实验报告1一、实验目的及要求1)掌握栈和队列这两种特殊的线性表,熟悉它们的特性,在实际问题背景下灵活运用它们。

本实验训练的要点是“栈”和“队列”的观点;二、实验内容1) 利用栈,实现数制转换。

2) 利用栈,实现任一个表达式中的语法检查(选做)。

3) 编程实现队列在两种存储结构中的基本操作(队列的初始化、判队列空、入队列、出队列);三、实验流程、操作步骤或核心代码、算法片段顺序栈:Status InitStack(SqStack &S){S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status DestoryStack(SqStack &S){free(S.base);return OK;}Status ClearStack(SqStack &S){S.top=S.base;return OK;}Status StackEmpty(SqStack S){if(S.base==S.top)return OK;return ERROR;}int StackLength(SqStack S){return S.top-S.base;}Status GetTop(SqStack S,ElemType &e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;Status Push(SqStack &S,ElemType e){if(S.top-S.base>=S.stacksize){S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemTyp e));if(!S.base)return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){if(S.top==S.base)return ERROR;e=*--S.top;return OK;}Status StackTraverse(SqStack S){ElemType *p;p=(ElemType *)malloc(sizeof(ElemType));if(!p) return ERROR;p=S.top;while(p!=S.base)//S.top上面一个...p--;printf("%d ",*p);}return OK;}Status Compare(SqStack &S){int flag,TURE=OK,FALSE=ERROR; ElemType e,x;InitStack(S);flag=OK;printf("请输入要进栈或出栈的元素:"); while((x= getchar)!='#'&&flag) {switch (x){case '(':case '[':case '{':if(Push(S,x)==OK)printf("括号匹配成功!\n\n"); break;case ')':if(Pop(S,e)==ERROR || e!='('){printf("没有满足条件\n");flag=FALSE;}break;case ']':if ( Pop(S,e)==ERROR || e!='[')flag=FALSE;break;case '}':if ( Pop(S,e)==ERROR || e!='{')flag=FALSE;break;}}if (flag && x=='#' && StackEmpty(S)) return OK;elsereturn ERROR;}链队列:Status InitQueue(LinkQueue &Q) {Q.front =Q.rear=(QueuePtr)malloc(sizeof(QNode));if (!Q.front) return ERROR;Q.front->next = NULL;return OK;}Status DestoryQueue(LinkQueue &Q) {while(Q.front){Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;}return OK;}Status QueueEmpty(LinkQueue &Q){if(Q.front->next==NULL)return OK;return ERROR;}Status QueueLength(LinkQueue Q){int i=0;QueuePtr p,q;p=Q.front;while(p->next){i++;p=Q.front;q=p->next;p=q;}return i;}Status GetHead(LinkQueue Q,ElemType &e) {QueuePtr p;p=Q.front->next;if(!p)return ERROR;e=p->data;return e;}Status ClearQueue(LinkQueue &Q){QueuePtr p;while(Q.front->next ){p=Q.front->next;free(Q.front);Q.front=p;}Q.front->next=NULL;Q.rear->next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e) {QueuePtr p;p=(QueuePtr)malloc(sizeof (QNode));if(!p)return ERROR;p->data=e;p->next=NULL;Q.rear->next = p;Q.rear=p; //p->next 为空return OK;}Status DeQueue(LinkQueue &Q,ElemType &e) {QueuePtr p;if (Q.front == Q.rear)return ERROR;p = Q.front->next;e = p->data;Q.front->next = p->next;if (Q.rear == p)Q.rear = Q.front; //只有一个元素时(不存在指向尾指针) free (p);return OK;}Status QueueTraverse(LinkQueue Q){QueuePtr p,q;if( QueueEmpty(Q)==OK){printf("这是一个空队列!\n");return ERROR;}p=Q.front->next;while(p){q=p;printf("%d<-\n",q->data);q=p->next;p=q;}return OK;}循环队列:Status InitQueue(SqQueue &Q){Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base)exit(OWERFLOW);Q.front=Q.rear=0;return OK;}Status EnQueue(SqQueue &Q,QElemType e){if((Q.rear+1)%MAXQSIZE==Q.front)return ERROR;Q.base[Q.rear]=e;Q.rear=(Q.rear+1)%MAXQSIZE;return OK;}Status DeQueue(SqQueue &Q,QElemType &e){if(Q.front==Q.rear)return ERROR;e=Q.base[Q.front];Q.front=(Q.front+1)%MAXQSIZE;return OK;}int QueueLength(SqQueue Q){return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;}Status DestoryQueue(SqQueue &Q){free(Q.base);return OK;}Status QueueEmpty(SqQueue Q) //判空{if(Q.front ==Q.rear)return OK;return ERROR;}Status QueueTraverse(SqQueue Q){if(Q.front==Q.rear)printf("这是一个空队列!");while(Q.front%MAXQSIZE!=Q.rear){printf("%d<- ",Q.base[Q.front]);Q.front++;}return OK;}数据结构实验报告2一.实验内容:实现哈夫曼编码的生成算法。

数据结构实验报告实验5

数据结构实验报告实验5

数据结构实验报告实验5一、实验目的本次实验的主要目的是深入理解和掌握常见的数据结构,如链表、栈、队列、树和图等,并通过实际编程实现,提高对数据结构的操作和应用能力。

同时,培养解决实际问题的思维和编程能力,提高代码的可读性、可维护性和效率。

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

三、实验内容1、链表的基本操作创建链表插入节点删除节点遍历链表2、栈的实现与应用用数组实现栈用链表实现栈栈的应用:括号匹配3、队列的实现与应用用数组实现队列用链表实现队列队列的应用:排队模拟4、二叉树的遍历前序遍历中序遍历后序遍历5、图的表示与遍历邻接矩阵表示法邻接表表示法深度优先遍历广度优先遍历四、实验步骤1、链表的基本操作创建链表:首先定义一个链表节点结构体,包含数据域和指向下一个节点的指针域。

然后通过动态内存分配创建链表节点,并将节点逐个连接起来,形成链表。

插入节点:根据插入位置的不同,分为在表头插入、在表尾插入和在指定位置插入。

在指定位置插入时,需要先找到插入位置的前一个节点,然后进行节点的连接操作。

删除节点:同样需要根据删除位置的不同进行处理。

删除表头节点时,直接将头指针指向下一个节点;删除表尾节点时,找到倒数第二个节点,将其指针置为空;删除指定位置节点时,找到要删除节点的前一个节点,然后调整指针。

遍历链表:通过从链表头开始,依次访问每个节点,输出节点的数据。

2、栈的实现与应用用数组实现栈:定义一个固定大小的数组作为栈的存储空间,同时用一个变量记录栈顶位置。

入栈操作时,先判断栈是否已满,如果未满则将元素放入栈顶位置,并更新栈顶位置;出栈操作时,先判断栈是否为空,如果不空则取出栈顶元素,并更新栈顶位置。

用链表实现栈:与链表的操作类似,将新元素添加在链表头部作为栈顶。

括号匹配:输入一个包含括号的字符串,使用栈来判断括号是否匹配。

遇到左括号入栈,遇到右括号时与栈顶的左括号进行匹配,如果匹配成功则出栈,否则括号不匹配。

数据结构实验四五六

数据结构实验四五六

数据结构实验实验四、图遍历的演示。

【实验学时】 5 学时【实验目的】(1)掌握图的基本存储方法。

(2)熟练掌握图的两种搜索路径的遍历方法。

【问题描述】很多涉及图上操作的算法都是以图的遍历操作为基础的。

试写一个程序,演示连通的无向图上,遍历全部结点的操作。

【基本要求】以邻接多重表为存储结构,实现连通无向图的深度优先和广度优先遍历。

以用户指定的结点为起点,分别输出每种遍历下的结点访问序列和相应生成树的边集。

【测试数据】教科书图7.33 。

暂时忽略里程,起点为北京。

【实现提示】设图的结点不超过30个,每个结点用一个编号表示(如果一个图有n 个结点,则它们的编号分别为1, 2,…,n)。

通过输入图的全部边输入一个图,每个边为一个数对,可以对边的输入顺序作出某种限制。

注意,生成树的边是有向边,端点顺序不能颠倒。

【选作内容】(1)借助于栈类型(自己定义和实现),用非递归算法实现深度优先遍历。

(2)以邻接表为存储结构,建立深度优先生成树和广度优先生成树,再按凹入表或树形打印生成树。

(3)正如习题7。

8 提示中分析的那样,图的路径遍历要比结点遍历具有更为广泛的应用。

再写一个路径遍历算法,求出从北京到广州中途不过郑州的所有简单路径及其里程。

【源程序】#include<iostream.h>#include <stdio.h>#include <stdlib.h>#define MAX_VERTEX_NUM 20#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define TRUE 1#define OK 1#define FALSE 0#define ERROR 0#define OVERFLOW -2typedef enum{DG,DN,UDG,UDN}GraphKind;//{ 有向图, 有向网, 无向图,无向网} bool visited[MAX_VERTEX_NUM];typedef struct ArcNode{int adjvex;// 该弧所指向的顶点在数组中的下标struct ArcNode *nextarc;int *info;// 该弧相关信息的指针}ArcNode;typedef struct VNode{int data;// 顶点信息ArcNode *firstarc;// 指向第一条依附该顶点的弧的指针}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int vexnum,arcnum;// 图的当前顶点数和弧数int kind;// 图的种类标志}ALGraph;typedef struct{int *base;int *top;int stacksize;}SqStack;typedef struct QNode{int data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;int LocateVex(ALGraph G,int v){// 返回数组下标值int i;for(i=0;i<MAX_VERTEX_NUM;++i) if(G.vertices[i].data==v) return i; return -1;}void CreateDN(ALGraph &G){// 采用邻接表存储表示, 构造有向图G(G.kind=DN) int i,j,k;ArcNode *p;int v1,v2; G.kind=DN; printf(" 输入顶点数:"); scanf("%d",&G.vexnum); printf(" 输入弧数:"); scanf("%d",&G.arcnum); printf(" 输入顶点:\n");for(i=0;i<G.vexnum;++i) {// 构造表头向量scanf("%d",&G.vertices[i].data);G.vertices[i].firstarc=NULL;// 初始化指针} for(k=0;k<G.arcnum;++k){ printf(" 第%d条弧:",k+1);scanf("%d",&v1); scanf("%d",&v2);// 输入一条弧的始点和终点i=LocateVex(G,v1);j=LocateVex(G,v2);〃确定v1 和v2 在G 中位置p=(ArcNode*)malloc(sizeof(ArcNode));// 假定有足够空间p->adjvex=j;p->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p; scanf("%d",&p->info);}//for }int Push(SqStack &S,int e){// 插入元素e 为新的栈顶元素if(S.top-S.base>=S.stacksize) {// 栈满,追加存储空间S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int))Jif(!S.base)exit(OVERFLOW); // 存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}int InitStack(SqStack &S) // 栈的初始化{S.base=(int*)malloc(STACK_INIT_SIZE*sizeof(int));if(!S.base)exit(OVERFLOW); // 存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}int Pop(SqStack &S,int &e) // 删除栈顶元素{//若栈不空,则删除S的栈顶元素,用e返回其值if(S.top==S.base)return ERROR;e=*--S.top;return OK;}int GetTop(SqStack S,int &e) // 取栈顶元素{//若栈不空,则用e返回S的栈顶元素if(S.top==S.base)return ERROR;e=*(S.top-1);return OK;}int StackEmpty(SqStack S) // 栈空{if(S.top==S.base)return TRUE;elsereturn FALSE;}int InitQueue(LinkQueue &Q) // 队列初始化{Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode)); if(!Q.front)exit(OVERFLOW); Q.front->next=NULL;return OK;int EnQueue(LinkQueue &Q,int e) // 插入{//插入元素e为Q的新的队尾元素QueuePtr p=(QueuePtr)malloc(sizeof(QNode)); if(!p)exit(OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}int DeQueue(LinkQueue &Q,int &e){//若队列不空,则删除Q的队头元素,用e返回其值if(Q.front==Q.rear) return ERROR;QueuePtr p=Q.front->next;e=p->data;Q.front->next=p->next; if(Q.rear==p)Q.rear=Q.front; free(p);return OK;}int QueueEmpty(LinkQueue Q) // 队列空{if(Q.front==Q.rear) return TRUE;elsereturn FALSE;}int FirstAdjVex(ALGraph G,int u){if(!G.vertices[u].firstarc)return -1;return LocateVex(G,G.vertices[u].firstarc->adjvex); }int NextAdjVex(ALGraph G,int u,int w){ArcNode *p=G.vertices[u].firstarc; while(p&&LocateVex(G,p->adjvex)!=w)p=p->nextarc;if(!p)return FirstAdjVex(G,u); p=p->nextarc;if(!p)return -1;return LocateVex(G,p->adjvex);}void Visit(ALGraph G,int v){ printf("%2d",G.vertices[v].data);}void DFSTraverse(ALGraph G){//按深度优先非递归遍历图G,使用辅助栈S和访问标志数组visited int v,w;SqStack S;for(v=0;v<G.vexnum;v++) visited[v]=FALSE;InitStack(S); for(v=0;v<G.vexnum;++v)if(!visited[v]){//v 尚未被访问visited[v]=TRUE;Visit(G,v);Push(S,v);//v 进栈while(!StackEmpty(S)){ for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w)){ if(!visited[w]){Visit(G,w); visited[w]=TRUE;Push(S,w);GetTop(S,v);}//if}//forPop(S,v);GetTop(S,v);}//while}//ifprintf("\n");}void BFSTraverse(ALGraph G){//按广度优先非递归遍历图G,使用辅助队列Q和访问标志数组visited int v,u,w;LinkQueue Q;for(v=0;v<G.vexnum;++v) visited[v]=FALSE;InitQueue(Q); for(v=0;v<G.vexnum;++v)if(!visited[v]){//v 尚未被访问visited[v]=TRUE;Visit(G,v);EnQueue(Q,v);//v 入队列while(!QueueEmpty(Q)){DeQueue(Q,u);// 队头元素出队并置为ufor(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w)) if(!visited[w]){//w 为u 的尚未访问的邻接顶点visited[w]=TRUE;Visit(G,w);EnQueue(Q,w);}//if}//while}//ifprintf("\n");}void PrintDN(ALGraph G) // 图的显示{int i;ArcNode *p; printf(" 顶点:\n");for(i=0;i<G.vexnum;++i) printf("%2d",G.vertices[i].data);prin tf("\n 弧:\n");for(i=0;i<G.vexnum;++i){ p=G.vertices[i].firstarc;if(p){ while(p){prin tf("%d —%d(%d)\t",i,p->adjvex,p->i nfo);p=p->nextarc;}printf("\n");}//if}//for }void main(){ALGraph G;printf(" f************ 题目:图的遍历***************\n\n");CreateDN(G);PrintDN(G);printf(" 深度优先遍历:");DFSTraverse(G);printf("\n 广度优先遍历:");BFSTraverse(G);}【运行结果】实验五查找算法实现【实验学时】 5 学时【实验目的】熟练掌握顺序查找、折半查找及二叉排序树、平衡二叉树上的查找、插入和删除的方法,比较它们的平均查找长度。

数据结构实报告实验四

数据结构实报告实验四

数据结构实验报告专业:信科10-4姓名:纵兆丹学号:08103575一、实验目的1 熟练掌握顺序搜索、折半搜索和索引搜索等基本搜索算法,熟悉这些算法适合在何种存储结构下实现;2 熟练掌握二叉排序树的特性、建立方法以及动态搜索算法;3 熟练掌握散列表的特点及构造方法。

二、实验内容基本题1、实现基于有序顺序表的折半搜索。

2、设单链表的结点是按关键字的值从小到大排列的,试写出对此表的搜索程序并调试。

三、实验过程和方法1、程序代码基础题1#include <iostream.h>#include <conio.h>int Search_Bin(int *a,int key,int n){//在有序表a中折半查找其关键字等于key的数据数据元素,若找到,则函数值为//该元素在表中的位置,否则为0int low=1;int high=n;int mid;while(low<=high){mid = (low+high)/2;if(key==a[mid])return mid;else if(key<a[mid])high=mid-1;elselow=mid+1;}return 0;}//Search_Binvoid main(){int a[11];int x;for(int i=1;i<=10;i++){a[i]=i;}cout<<"请输入您想查找的元素值(请在1—10中选择):"<<endl;cin>>x;cout<<"您输入的元素的位置为:"<<endl;cout<<Search_Bin(a,x,10)<<endl;getch();}基础题2#include <iostream>#include <conio.h>#include <list>using namespace std;void disp(list<int> List){list<int>::iterator a;for(a=List.begin(); a != List.end(); a++)cout<<*a<<" ";cout<<endl;}//dispint Search(list<int> List,int key){list<int>::iterator b;int i=1;for(b=List.begin(); b!= List.end(); b++){if(key==*b){return i;}i++;}return 0;}//Searchvoid main(){list<int> L;int m[100];int i=0;cout<<"请输入您要建立的链表的各个节点的关键字,以0为结束!"<<endl; do{cin>>m[i++];}while(m[i-1]!=0);for(int j=0;j<i-1;j++){L.push_back(m[j]);cout<<"插入成功!"<<endl;}L.sort();cout<<"单链表节点顺序为:"<<endl;disp(L);int n,x;do{cout<<"1,查找;2,退出。

北邮数据结构实验报告实验四

北邮数据结构实验报告实验四

2009级数据结构实验报告实验名称:实验四——排序学生姓名:班级:班内序号:学号:日期:2010/12/171.实验要求实验目的:通过选择下面两个题目之一,学习、实现、对比各种排序算法,掌握各种排序算法的优劣,以及各种算法使用的情况。

实验内容:使用简单数组实现下面各种排序算法,并进行比较。

排序算法:1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序7、归并排序8、基数排序(选作)9、其他要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。

3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)4、对2和3的结果进行分析,验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。

2. 程序分析2.1 存储结构使用最简单的一维数组存储待排序的数据。

共使用两个数组,一个用来存储原始数据,一个用来存储待排序数据。

每次排序完毕,用原始数据更新一次待排序数据,保证每一次都对同一组数据排序。

(图略)2.2 关键算法分析1.直接插入的改进:在一般的直接插入中,关键码每移动一次就需要比较一次。

在移动的方面,优化是比较困难的,因为对静态线性表的插入必然要带来大量的移动。

但是,我们可以在比较上进行一些优化。

在查找技术一张曾学过的“折半查找法”,在这里就可以照葫芦画瓢地运用。

一趟排序的伪代码如下:1.如果该元素大于处于其左侧相邻的元素则跳过该元素;2.low=0,high=i;3.循环直至low==high3.1 mid=(low+high)/2;3.2如果当前元素大于中值high=mid;3.3否则low=mid+1;4.当前元素赋值给临时变量;5.将有序区中处于low位置及其右侧的元素右移;6.临时变量置于low位置简单说一下这里的折半查找与一般查找算法的区别。

这里的查找,尤其是对无重复数据和大量数据的处理中,更多的时候是找不到完全相等的项的。

数据结构-实验4

数据结构-实验4

《数据结构》实验报告年级_2012级__ 学号_ 姓名 __ 成绩______专业_计算机科学与技术实验地点___指导教师__实验项目实验四串实验性质设计性实验日期:一、实验目的:1、掌握串的定义及其基本操作的实现。

2、掌握链表及其基本操作的实现。

3、通过上机实践进一步加深对串的顺序存储方式及链式存储方式的理解。

4、通过上机实践加强利用数据结构解决实际应用应用问题的能力。

二、实验内容与要求:1、实验题目一:顺序串的定义及其操作算法的实现要求:编程实现串的类型定义及串的初始化操作、插入操作、删除操作、取元素操作、输出操作等,并对其进行验证。

2、实验题目二:文本加密和解密要求:掌握每一种串操作的一般函数的实现及其应用。

三、实验问题描述一个文本串可用事先给定的字母映射表进行加密。

例如,设字母映射表为:abcdefghijklmnopqrstuvwxyzngzqtcobmuhelkpdawxfyivrsj则字符串“encrypt”被加密为“tkzwsdf”。

设计一个程序将输入的文本串进行加密后输出,然后进行解密输出。

四、实验步骤1.实验问题分析这里用到了c语言里的while 语句、for语句、if语句以及指针2.功能(函数)设计void Encrypt(char *pszSrc, char *pszEncrypt){char *p1;char *p2;int i=0;int j=0;p1=(char *)CharArray1;p2=(char *)CharArray2;cout<<"请输入要加密的字符串\n";fflush(stdin);cin.getline(pszSrc, 100);}五、实验结果(程序)及分析#include<iostream>using namespace std;const char CharArray1[26]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};const char CharArray2[26]={'n','g','z','q','t','c','o','b','m','u','h','e','l','k','p','d','a','w','x','f','y','i','v','r','s','j'};void Encrypt(char*pszSrc,char*pszEncrypt){char*p1;char*p2;int i=0;int j=0;p1=(char*)CharArray1;p2=(char*)CharArray2;cout<<"请输入要加密的字符串\n";fflush(stdin);cin.getline(pszSrc,100);i=0;j=0;while(*(pszSrc+i)!='\0'){for(j=0;j<26;j++){if(*(pszSrc+i)==*(p1+j)){*(pszEncrypt+i)=*(p2+j);break;}else{;}}i++;}*(pszEncrypt+i)='\0';}void Decrypt(char*pszSrc,char*pszDecrypt) {char*p1;char*p2;int i=0;int j=0;p1=(char*)CharArray1;p2=(char*)CharArray2;cout<<"请输入一行已加密的字符串:\n"; fflush(stdin);cin.getline(pszSrc,100);i=0;j=0;while(*(pszSrc+i)!='\0'){for(j=0;j<26;j++){if(*(pszSrc+i)==*(p2+j)){*(pszDecrypt+i)=*(p1+j);break;}else{;}}i++;}*(pszDecrypt+i)='\0';}int main(){char*pszSrc;char*pszDest;int select;int i=0;int j=0;if((pszSrc=new char[100])==NULL){cout<<"申请内存空间失败,程序退出!\n";exit(1);}if((pszDest=new char[100])==NULL){cout<<"申请内存空间失败,程序退出!\n";exit(1);}while(1){cout<<"请选择加密或解密(1.加密2.解密0.退出):";cin>>select;if(1==select){Encrypt(pszSrc,pszDest);cout<<"加密后的字符串\n";i=0;while(*(pszDest+i)!='\0'){cout<<*(pszDest+i);i++;}cout<<endl;}else if(2==select){Decrypt(pszSrc,pszDest);cout<<"解密后的字符串\n";i=0;while(*(pszDest+i)!='\0'){cout<<*(pszDest+i);i++;}cout<<endl;}else if(0==select){break;}else{cout<<"你没有输入正确的选择,请重新选择:";}}delete[]pszSrc;delete[]pszDest;return0;}六、结论与分析在本次实验中掌握了串的各种操作,以及其实际作用,掌握串的定义及其基本操作的实现和掌握链表及其基本操作的实现。

数据结构实验6报告

数据结构实验6报告

数据结构实验报告第 6 次实验一、实验目的1.理解栈是操作受限(插入push, 删除pop)的线性表, 受限的是插入删除的位置。

2.在链式存储结构下实现:StackEmpty, Push,Pop, 几个基本操作。

3.通过调用基本操作实现括号匹配算法。

二、实验内容(问题)写一个算法, 识别依次读入的一个字符序列是否为形如‘序列1&序列2’模式的字符序列。

其中序列1和序列2中都不含字符‘&’, 且序列2是序列1的逆序列。

例如, ‘a+b&b+a’是属该模式的字符序列, 而’1+3&3-1’则不是。

测试数据: ’1+3&3-1’; ’a+b+c&c+b+a’; ’a+b+c&c+b’; ’b+c&c+b+a’;提示:利用栈 , 利用已实现的基本操作三、算法描述(给出自然语言描述的算法)1.向后依次扫描字符序列, 如果考察的字符不等于‘&’则入栈, 遇到‘&’则停止。

2.从‘&’后继续扫描, 考察字符的时候, 栈顶元素出栈, 若二者相等, 继续扫描;不等, 模式不成立。

3.扫描结束后, 栈空则模式成立四、详细设计(画流程图)五、程序代码#include<stdio.h>#include<stdlib.h>#define True 1#define False 0#define OK 1#define ERROR 0typedef int status;typedef char ElemType;typedef struct SNode{ElemType data;struct SNode *next;}SNode, *LinkStack;status InitStack(LinkStack &S);int StackEmpty(LinkStack S);status Push(LinkStack &S, ElemType e);status Pop(LinkStack &S, ElemType &e);status Is_Match(ElemType f[20]);main(){ElemType formula[20];int i;for(i=0;i<=3;i++){printf("\n请输入一个字符序列表达式: ");scanf("%s",formula);if(Is_Match(formula)==1) printf(" \n这个表达式符合‘序列1&序列2’模式!\n"); else printf("\n 这个表达式不符合‘序列1&序列2’模式!\n");}return(1);}status InitStack(LinkStack &S){S=NULL;return(OK);}int StackEmpty(LinkStack S){if(S==NULL) return(True);else return(False);}status Push(LinkStack &S, ElemType e){LinkStack p;p=(LinkStack)malloc(sizeof(SNode));if(!p) return(ERROR);p->data=e;p->next=S;S=p;return(OK);}status Pop(LinkStack &S, ElemType &e){LinkStack p;if(!S) return(ERROR);e=S->data;p=S;S=S->next;free(p);return(OK);}status Is_Match(ElemType f[20]){LinkStack St; ElemType *p,c;InitStack(St);p=f;for(;*p!='&';p++){ Push(St,*p);if(!Push(St, *p)) return(ERROR);}p++;for(;*p!='\0';p++){Pop(St,c);if(!Pop(St,c)) return(ERROR);else if(c!=*p) return(ERROR);}if(StackEmpty(St)) return(OK);else return(ERROR);}七、用户手册(教用户怎么用这个程序)用途: 判断字符串是否是“序列1&序列2’模式”用法:启动此程序, 屏幕会提示你输入数据, 输入数据并按下回车键即可。

数据结构的实验报告

数据结构的实验报告

一、实验目的本次实验旨在让学生掌握数据结构的基本概念、逻辑结构、存储结构以及各种基本操作,并通过实际编程操作,加深对数据结构理论知识的理解,提高编程能力和算法设计能力。

二、实验内容1. 线性表(1)顺序表1)初始化顺序表2)向顺序表插入元素3)从顺序表删除元素4)查找顺序表中的元素5)顺序表的逆序操作(2)链表1)创建链表2)在链表中插入元素3)在链表中删除元素4)查找链表中的元素5)链表的逆序操作2. 栈与队列(1)栈1)栈的初始化2)入栈操作3)出栈操作4)获取栈顶元素5)判断栈是否为空(2)队列1)队列的初始化2)入队操作3)出队操作4)获取队首元素5)判断队列是否为空3. 树与图(1)二叉树1)创建二叉树2)遍历二叉树(前序、中序、后序)3)求二叉树的深度4)求二叉树的宽度5)二叉树的镜像(2)图1)创建图2)图的深度优先遍历3)图的广度优先遍历4)最小生成树5)最短路径三、实验过程1. 线性表(1)顺序表1)初始化顺序表:创建一个长度为10的顺序表,初始化为空。

2)向顺序表插入元素:在顺序表的第i个位置插入元素x。

3)从顺序表删除元素:从顺序表中删除第i个位置的元素。

4)查找顺序表中的元素:在顺序表中查找元素x。

5)顺序表的逆序操作:将顺序表中的元素逆序排列。

(2)链表1)创建链表:创建一个带头结点的循环链表。

2)在链表中插入元素:在链表的第i个位置插入元素x。

3)在链表中删除元素:从链表中删除第i个位置的元素。

4)查找链表中的元素:在链表中查找元素x。

5)链表的逆序操作:将链表中的元素逆序排列。

2. 栈与队列(1)栈1)栈的初始化:创建一个栈,初始化为空。

2)入栈操作:将元素x压入栈中。

3)出栈操作:从栈中弹出元素。

4)获取栈顶元素:获取栈顶元素。

5)判断栈是否为空:判断栈是否为空。

(2)队列1)队列的初始化:创建一个队列,初始化为空。

2)入队操作:将元素x入队。

3)出队操作:从队列中出队元素。

《数据结构》实验报告查找

《数据结构》实验报告查找

实验四——查找一、实验目的1.掌握顺序表的查找方法,尤其是折半查找方法;2.掌握二叉排序树的查找算法。

二、实验内容1.建立一个顺序表,用顺序查找的方法对其实施查找;2.建立一个有序表,用折半查找的方法对其实施查找;3.建立一个二叉排序树,根据给定值对其实施查找;4.对同一组数据,试用三种方法查找某一相同数据,并尝试进行性能分析。

三、实验预习内容实验一包括的函数有:typedef struct ,创建函数void create(seqlist & L),输出函数void print(seqlist L),顺序查找int find(seqlist L,int number),折半查找int halffind(seqlist L,int number)主函数main().实验二包括的函数有:结构体typedef struct,插入函数void insert(bnode * & T,bnode * S),void insert1(bnode * & T),创建函数void create(bnode * & T),查找函数bnode * search(bnode * T,int number),主函数main().四、上机实验实验一:1.实验源程序。

#include<>#define N 80typedef struct{int number; umber;for(i=1;[i].number!=0;){cin>>[i].name>>[i].sex>>[i].age;++;cout<<endl;cin>>[++i].number;}}umber<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;}umber==number)return i;}umber)return mid;elseif(number<[mid].number)high=mid-1;elselow=mid+1;}return 0;}void main(){int i,number;seqlist L;create(L);print(L);cout<<"折半查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=halffind(L,number))!=0)cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;elsecout<<"失败!"<<endl;cout<<"顺序查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=find(L,number))!=0)cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;elsecout<<"失败!"<<endl;}实验二:#include<>typedef struct{int number; 立二叉排序树"<<"\n\t2.插入学生信息"<<"\n\t3.查找学生信息"<<endl;cout<<"选择:";cin>>choice;switch(choice){case 1:{create(T);cout<<"成功建立!"<<endl;};break;case 2:{insert1(T);cout<<"插入成功!"<<endl;};break;case 3:{cout<<"输入待查学生的学号:";cin>>number;p=search(T,number);if(p)cout<<p-><<"\t"<<p-><<"\t"<<p-><<"\t"<<p-><<endl;elsecout<<"查找失败!"<<endl;};break;}cout<<"Continue(Y/N):";cin>>ctinue;if(ctinue=='y'||ctinue=='y')flag=1;elseflag=0;}}2.实验结果(截图)。

数据结构 实验报告

数据结构 实验报告

数据结构实验报告数据结构实验报告一、引言数据结构是计算机科学中非常重要的一门课程,它涉及到数据的存储、组织和管理等方面。

通过实验学习,我们可以更好地理解和掌握不同的数据结构,提升我们在编程中解决实际问题的能力。

二、实验目的本次实验的主要目的是通过实际操作,加深对数据结构的理解,学习并掌握不同数据结构的特点和应用场景,提高编程能力。

三、实验内容1. 实验环境的搭建在开始实验之前,我们需要搭建相应的实验环境。

首先,我们选择合适的集成开发环境(IDE),如Eclipse或IntelliJ IDEA,并安装好Java Development Kit(JDK)。

然后,根据实验要求,下载并安装相应的数据结构库或框架。

2. 实验一:线性表线性表是最基本且最常用的数据结构之一,它可以用于存储一系列具有相同数据类型的元素。

实验中,我们需要实现一个线性表的基本操作,包括插入、删除、查找、修改等。

3. 实验二:栈和队列栈和队列是两种常用的数据结构,它们都是线性表的衍生结构,但在操作上有一些特殊的限制。

实验中,我们需要实现栈和队列的基本操作,并比较它们在不同场景下的优劣。

4. 实验三:树和二叉树树是一种非线性的数据结构,它以分层的方式存储数据。

二叉树是树的一种特殊情况,其中每个节点最多只有两个子节点。

实验中,我们需要实现树和二叉树的构建和遍历算法,并掌握它们在实际问题中的应用。

5. 实验四:图图是一种非线性的数据结构,由节点和边组成。

实验中,我们需要实现图的构建和遍历算法,并应用它们解决实际的图相关问题。

四、实验结果与分析通过实验,我们得到了以下结果和分析:1. 在线性表实验中,我们成功实现了插入、删除、查找和修改等基本操作,并验证了其正确性和效率。

2. 在栈和队列实验中,我们对比了它们在不同场景下的应用,发现栈适用于后进先出(LIFO)的情况,而队列适用于先进先出(FIFO)的情况。

3. 在树和二叉树实验中,我们掌握了树和二叉树的构建和遍历算法,并应用它们解决了一些实际问题,如树形结构的存储和搜索。

数据结构实验报告(实验)

数据结构实验报告(实验)

数据结构实验报告(实验)数据结构实验报告(实验)1. 实验目的1.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统:Windows 102.2 编程语言:C++2.3 开发工具:Visual Studio3. 实验内容3.1 实验一:线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二:栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三:树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法(前序、中序、后序遍历)3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一:实验源代码附件二:实验数据7. 法律名词及注释7.1 版权:著作权法规定的对原创作品享有的权利7.2 专利:国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标:作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议:指允许他人在一定条件下使用自己的知识产权的协议。

武汉纺织大学《数据结构》实验报告4

武汉纺织大学《数据结构》实验报告4

武汉纺织大学《数据结构》实验报告班级:级管工类专业班姓名:序号: 1实验时间: 2014 年 5 月 30 日指导教师:实验四:查找基本操作与应用一、实验目的:1、掌握顺序查找、折半查找、哈希查找的基本方法和操作过程2、掌握查找效率的分析方法二、实验内容:1、编写程序,实现顺序查找操作,可参考书本P260示例程序。

实验步骤:①、在Java语言编辑环境中新建程序,建立一个顺序表(表长10),依次输入10个数据元素(对元素存放的先后顺序没有要求),并按照存储顺序输出所有元素;②、输入带查找关键字,在顺序表中进行顺序查找;③、输出查找结果。

2、编写程序,实现有序表折半查找操作,可参考书本P263示例程序。

实验步骤:①、在Java语言编辑环境中新建程序,建立一个顺序表(表长10),依次输入10个数据元素(要求所有元素按照递增顺序排列),并按照存储顺序输出所有元素;②、输入带查找关键字,在有序表中进行折半查找;③、输出查找结果。

3、编写程序,实现哈希表查找操作。

实验步骤:①、在Java语言编辑环境中新建程序,建立一个顺序表(表长12),依次输入10个数据元素,并按照存储顺序输出所有元素;②、输入带查找关键字,在哈希表中进行查找;③、输出查找结果。

已知:哈希函数为H(key)=key MOD 11,采用开放地址法、线性探测再散列解决冲突,输入元素为{ 55,19,31,23,68,20,27,9,10,79}。

三、操作步骤:Test1代码:T1.Javapackage First;import java.util.Scanner;public class T1 {public static void main(String[] args) {int i;int n;Scanner sc=new Scanner(System.in);SeqList<Integer> sl=new SeqList<Integer>(10);sl.insert(0, 3);sl.insert(6, 1);sl.insert(6, 0);sl.insert(8, 6);sl.insert(7, 2);sl.insert(2,9);sl.insert(4, 1);sl.insert(5, 4);sl.insert(6,8);sl.insert(1, 7);System.out.print("顺序表中各元素:");System.out.println(sl.toString());System.out.println("<查找元素>");System.out.print("输入元素:");i=sc.nextInt();n=sl.indexOf(i);if(n!=-1)System.out.println("元素" +i+"位于第"+n+"位");}}LList.javapackage First;public interface LList<T> {boolean isEmpty();int length();T get(int i);void set(int i, T x);void insert(int i, T x);T remove(int i);void removeAll();}SeqList .javapackage First;public class SeqList<T> implements LList<T> { private Object[] element;private int len;public SeqList(int size) {this.element = new Object[size];this.len = 0;}public SeqList() {this(64);}public boolean isEmpty() {return this.len == 0;}public int length() {return this.len;}public T get(int i) {if (i >= 0 && i < this.len)return (T) this.element[i];return null;}public void set(int i, T x) {if (x == null)return;if (i >= 0 && i < this.len)this.element[i] = x;elsethrow new IndexOutOfBoundsException(i + "");}public String toString() {String str = "(";if (this.len > 0)str += this.element[0].toString();for (int i = 1; i < this.len; i++)str += "," + this.element[i].toString();return str + ")";}public void insert(int i, T x){if(x==null)return;if(this.len==element.length){Object[]temp = this.element;this.element = new Object[temp.length*2];for(int j=0;j<temp.length;j++)this.element[j]=temp[j];}if(i<0)i=0;if(i>this.len)i=this.len;for(int j=this.len-1;j>=i;j--)this.element[j+1]=this.element[j];this.element[i]=x;this.len++;}public void append(T x){ insert(this.len,x); } public T remove(int i){if(this.len==0||i<0||i>=this.len)return null;T old = (T)this.element[i];for(int j=i;j<this.len-1;j++)this.element[j]=this.element[j+1];this.element[this.len-1]=null;this.len--;return old;}public void removeAll(){ this.len=0; } public int indexOf(T key){if(key!=null)for(int i=0;i<this.len;i++)if(this.element[i].equals(key))return i;return -1;}public T search(T key){int find=this.indexOf(key);return find==-1?null:(T)this.element[find]; }public boolean contain(T key){return this.indexOf(key)>=0;}}运行结果:Test2代码:T2.javapackage Second;public class T2 {public static void main(String[] args) {int a[]={5,11,23,15,17,38,90,121,132,164}; int search=38;int lower=0;int temp=a.length-1 ;int index=-1;while(lower<=temp){index = (lower+temp)/2;int currentValue=a[index];if(currentValue==search){break;}else if(currentValue<search){lower=index+1;}else{temp = index-1;}}for(int i = 0;i < 10; i++){System.out.print(a[i]);System.out.println(" ");}if(lower<=temp){System.out.println("查找元数"+search);System.out.println("位于数组中第"+(index+1)+"位");}else{System.out.println("里面没有这个元素"); }}}运行结果:Test3代码:T3.javapackage Three;import java.util.Scanner;public class T3 {static HashTable T=null;public static void createHashtable() throws Exception { T=new HashTable(20);Scanner sc=new Scanner(System.in);System.out.print("请输入待查找的关键字的个数:");int n=sc.nextInt();System.out.print("请输入查找表中的关键字序列:");for (int i = 0; i < n; i++) {T.hashInsert(sc.nextInt());}}public static void main(String[]args)throws Exception{System.out.println("<创建哈希表>");createHashtable();System.out.println("创建的哈希表为:");T.Hashdisplay();System.out.print("输入待查找的关键字:");Scanner sc=new Scanner(System.in);int key=sc.nextInt();RecordNode p=T.hashSearch(key);if ((p.getKey()).compareTo(key)==0)System.out.println(" 查找成功!");elseSystem.out.println(" 查找失败!");}}KeyType.javapackage Three;public class KeyType implements Comparable<KeyType> {private int key;public KeyType() {}public KeyType(int key) {this.key = key;}public int getKey() {return key;}public void setKey(int key) {this.key = key;}public String toString() {return key + "";}public int compareTo(KeyType another) {int thisVal = this.key;int anotherVal = another.key;return (thisVal < anotherVal ? -1 : (thisVal == anotherVal ? 0 : 1));}}class HashTable {private RecordNode[] table;public HashTable(int size) {this.table = new RecordNode[size];for (int i = 0; i < table.length; i++) {table[i] = new RecordNode(0);}}public int hash(int key) {return key % 11;}public RecordNode hashSearch(int key) {int i = hash(key);int j = 0;while ((table[i].getKey().compareTo(0) != 0)&& (table[i].getKey().compareTo(key) != 0)&& (j < table.length)) {j++;i = (i + j) % 11;}if (j >= table.length) {System.out.println("哈希表已满");return null;} elsereturn table[i];}public void hashInsert(int key) {RecordNode p = hashSearch(key);if (p.getKey().compareTo(0) == 0)p.setKey(key);elseSystem.out.println(" 此关键字记录已存在或哈希表已满");}void Hashdisplay() {for (int i = 0; i < table.length; i++)System.out.print(table[i].getKey().toString() + " ");System.out.println();}}RecordNode.javapackage Three;public class RecordNode {private Comparable key;private Object element;public Object getElement() {return element;}public void setElement(Object element) {this.element = element;}public Comparable getKey() {return key;}public void setKey(Comparable key) {this.key = key;}public RecordNode() {this.key = null;}public RecordNode(Comparable key) {this.key = key;}}运行结果:四、实验收获和建议这次实验我掌握了顺序查找、折半查找、哈希查找的基本方法和操作过程,掌握查找效率的分析方法,对查找方法有了更进一步的认识。

数据结构 实验报告

数据结构 实验报告

数据结构实验报告数据结构实验报告背景介绍:数据结构是计算机科学中的重要概念,它涉及到如何组织和存储数据,以及如何在数据中进行操作和检索。

在本次实验中,我们将学习并实践几种常见的数据结构,包括数组、链表、栈和队列。

实验目的:通过本次实验,我们的目标是深入了解数据结构的基本概念和操作,并通过编写代码来实现和应用这些数据结构。

通过实践,我们将能够更好地理解数据结构在实际问题中的应用和效果。

实验过程:1. 数组:数组是一种线性数据结构,它由一系列相同类型的元素组成,这些元素在内存中是连续存储的。

我们首先学习了如何创建和初始化数组,并实现了一些常见的数组操作,如插入、删除和查找元素。

通过编写代码,我们能够更好地理解数组的特点和使用方法。

2. 链表:链表是另一种常见的线性数据结构,与数组不同,链表中的元素在内存中并不连续存储,而是通过指针相互连接。

我们学习了单向链表和双向链表的实现,并实现了插入、删除和查找元素的操作。

链表的灵活性使其在某些情况下比数组更加适用。

3. 栈:栈是一种后进先出(LIFO)的数据结构,类似于弹夹中的子弹。

我们学习了如何使用数组和链表来实现栈,并实现了入栈和出栈的操作。

栈在计算机科学中有广泛的应用,例如函数调用、表达式求值等。

4. 队列:队列是一种先进先出(FIFO)的数据结构,类似于排队等候的人群。

我们学习了如何使用数组和链表来实现队列,并实现了入队和出队的操作。

队列在操作系统、网络通信等领域中有着重要的应用。

实验结果与讨论:通过本次实验,我们成功地实现了数组、链表、栈和队列这几种常见的数据结构,并能够熟练地进行插入、删除和查找等操作。

我们还通过编写一些实际问题的代码,验证了这些数据结构在解决实际问题中的有效性和效率。

结论:数据结构是计算机科学中的重要基础概念,通过本次实验,我们深入了解了几种常见的数据结构,并通过编写代码实现了这些数据结构的基本操作。

这将为我们今后在算法设计和程序开发中提供坚实的基础,并帮助我们更好地理解和解决实际问题。

国家开放大学《数据结构》课程实验报告(实验6——查找)参考答案

国家开放大学《数据结构》课程实验报告(实验6——查找)参考答案
}
/*按平均成绩进行折半查找并插入新记录,使表仍按平均成绩降序排列*/
int BinSort(Student *a,int n,Student x)
{
int low,high,mid;
int i,j;
/*折半查找*/
low=0;
high=n-1;
while(low<=high)
{
mid=(low+high)/2;
void main()
{
Student a[N]={{"Zhao",95},{"Qian",90},{"Sun",86},{"Li",75}},x;
int n=4; /*学生人数,即表长*/
printf("初始%d位学生的信息表如下:\n",n);
Display(a,n);
printf("\n\n");
《数据结构》课程实验报告
(实验6——查找)
学生姓名
学 号
班 级
指导老师
实验名称
实验成绩
实验报告




实验目的:
某班学生成绩信息表中,每个学生的记录已按平均成绩由高到低排好序,后来发现某个学生的成绩没有登记到信息表中,使用折半查找法把该同学的记录插入到信息表中,使信息表中的记录仍按平均成绩有序。
实验要求:
(1)建立现有学生信息表,平均成绩已有序。
(2)输入插入学生的记录信息。
(3)用折半查找找到插入位置,并插入记录。
设计思路:
(1)用结构数组存储成绩信息表。
(2)对记录中的平均成绩进行折半查找并插入。
实验内容源自程序代码:/*实验5.1折半查找*/

《数据结构》实验书

《数据结构》实验书

目录实验一线性表基本操作的编程实现 (201)实验二堆栈或队列基本操作的编程实现 (49)实验四二维数组基本操作的编程实现 (18)实验五二叉树基操作的编程实现 (20)实验六图基本操作的编程实现 (45)(特别提示:程序设计包含两个方面的错误。

其一是错误,其二是能错误。

为了提高学生的编程和能力,本指导书给出的程序代码并的两种错误。

并且也不保证程序的完整性,有一些语句已经故意删除,就是要求学生自己编制完成,这样才能达到我们的要求。

希望大家以自己所学高级语言的基本功和点为基础,不要过于依赖给出的参考代码,这样才能有所进步。

如果学生能够根据要求完全自己编制,那就不好了。

)实验一线性表基本操作的编程实现【实验目的】线性表基本操作的编程实现要求:线性表基本操作的编程实现(2学时,验证型),掌握线性表的建立、遍历、插入、删除等基本操作的编程实现,也可以进一步编程实现查找、逆序、排序等操作,存储结构可以在顺序结构或链表结分主要功能,也可以用菜单进行管理完成大部分功能。

还鼓励学生利用基本操作进行一些更实际的应用型程序设计。

【实验性质】【实验内容】把线性表的顺序存储和链表存储的数据插入、删除运算其中某项进行程序实现。

建议实现键盘输入数据以实现程序的通据的函数。

【注意事项】【思考问题】1.线性表的顺序存储和链表存储的差异?优缺点分析?2.那些操作引发了数据的移动?3.算法的时间效率是如何体现的?4.链表的指针是如何后移的?如何加强程序的健壮性?【参考代码】(一)利用顺序表完成一个班级学生课程成绩的简单管理1、预定义以及顺序表结构类型的定义(1)#define ListSize //根据需要自己设定一个班级能够容纳的最大学生数(2)typedef struct Stu{int num; //学生的学号char name[10]; //学生的姓名float wuli; //物理成绩float shuxue; //数学成绩float yingyu; //英语成绩}STUDENT; //存放单个学生信息的结构体类型typedef struct List{stu[ListSize]; //存放学生的数组定义,静态分配空间int length; //记录班级实际学生个数}LIST; //存放班级学生信息的顺序表类型2、建立班级的学生信息void listcreate(LIST *Li,int m) //m为该班级的实际人数{int i;Li->length=0;for(i=0;i<m;i++) //输入m个学生的所有信息{printf("please input the %dth student's information:\n",i+1);printf("num=");scanf("%d", ); //输入第i个学生的学号printf("name=");scanf("%s", ); //输入第i个学生的姓名printf("wuli=");scanf("%f", ); //输入第i个学生的物理成绩printf("shuxue=");scanf("%f", ); //输入第i个学生的数学成绩printf("yingyu=");scanf("%f", ); //输入第i个学生的英语成绩Li->length++; //学生人数加1}}3、插入一个学生信息int listinsert(LIST *Li,int i) //将学生插入到班级Li的第i个位置。

国家开放大学《数据结构》课程实验报告(实验4——二叉树)参考答案

国家开放大学《数据结构》课程实验报告(实验4——二叉树)参考答案
《数据结构》课程实验报告
(实验4二叉树)
学生姓名
学 号
班 级
指导老师
实验名称
实验成绩
实验报告
实ቤተ መጻሕፍቲ ባይዱ



实验目的:
(1)根据数组tree,建立与该二叉树对应的链式存储结构。
(2)对该二叉树采用中序遍历法显示遍历结果。
实验要求:
(1)在主函数中,通过键盘输入建立设定的完全二叉树的顺序存储结构。
(2)设计子函数,其功能为将顺序结构的二叉树转化为链式结构。
(2)中序遍历采用递归算法,即中序遍历左子树、访问根结点、中序遍历右子树。




程序代码:
/*实验3.1二叉树的顺序存储结构和链式存储结构*/
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 20
/*二叉树链式存储结构结点定义*/
typedef struct BTreeNode






指导教师 日期
(3)设计子函数,其功能为对给定二叉树进行中序遍历,显示遍历结果。
(4)通过实例判断算法和相应程序的正确性。
实验基本原理:
(1)顺序存储的二叉树转化为链式存储结构,采用递归算法,递归函数的形式为Creab(tree,n,i,b),其中形参:tree为顺序存储二叉树的数组,n为二叉树的结点数,i是二叉树某结点在数组tree中的下标(初始值为1),b为要建立的链式存储二叉树结点指针。转化时,首先建立*b结点,将tree[i]的值赋给*b的数据域,再调用递归函数分别构造左子树和右子树。

希尔排序实验报告

希尔排序实验报告

数据结构实验报告(实验五)实验人:颜建学班级:4101090703实验时间: 6.8实验学时: 2实验地点:260实验题目:排序实验目的:1.掌握常规的几种排序方法:插入排序,选择排序,交换排序2.了解各种排序方法的优劣适应数据,稳定性。

实验内容:1.用希尔排序算法对用户输入的一组数据按关键字进行排序输出2.(选作题)使用快速排序算法对用户输入的一组数据按关键字进行排序并输出3.(选作题)使用堆排序方法用户输入的一组数据按关键字进行排序并输出实验用到数据结构:逻辑结构:数组存储结构:顺序存储结构结构定义,功能函数声明如下:#include <stdlib.h>#include <stdio.h>#define MAXSIZE 20 //一个用作示例的小顺序表的最大长度typedef int Keytype ; //定义关键字类型为整数类型typedef struct{Keytype key; //关键字项}RedType; //记录类型typedef struct{int length; //顺序表长度}SqList; //顺序表类型typedef SqList HeapType;void ShellInsert(SqList &L, int dk);void ShellSort(SqList &L, int dlta[],int t);int Partition(SqList &L, int low,int high);void QSort(SqList &L, int low,int high);void QuickSort(SqList &L);void prin(SqList &L,int lenth);typedef SqList HeadType ;void HeadAdjust(HeadType &H,int s,int m);void HeapSort(HeadType &H);具体实现:#include <stdlib.h>#include <stdio.h>#define MAXSIZE 20 //一个用作示例的小顺序表的最大长度typedef int Keytype ; //定义关键字类型为整数类型typedef struct{Keytype key; //关键字项}RedType; //记录类型typedef struct{int length; //顺序表长度}SqList; //顺序表类型typedef SqList HeapType;void ShellInsert(SqList &L, int dk);void ShellSort(SqList &L, int dlta[],int t); int Partition(SqList &L, int low,int high); void QSort(SqList &L, int low,int high);void QuickSort(SqList &L);void prin(SqList &L,int lenth);typedef SqList HeadType ;void HeadAdjust(HeadType &H,int s,int m);void HeapSort(HeadType &H);void ShellInsert(SqList &L, int dk){int i,j;for(i =dk + 1;i <=L.length ;i ++){if(L.r [i].key < L.r [i - dk].key ){L.r [0] = L.r [i];for(j = i - dk;j > 0 && L.r[0].key < L.r[j].key; j -= dk){L.r[j +dk] = L.r[j];}L.r[j+dk] = L.r[0];}}}void ShellSort(SqList &L, int dlta[],int t){int i;for(i = 0;i <t;i ++){ShellInsert(L,dlta[i]);}}int Partition(SqList &L, int low,int high){int p;L.r [0].key = L.r [low].key ;p = L.r [low].key ;while(low<high){while(low<high && L.r [high].key >= p ) high --;L.r [low].key = L.r [high].key ;while(low<high && L.r [low].key <= p ) low ++;L.r [high].key = L.r [low].key ;}L.r [low].key = L.r[0].key ;return low;}void QSort(SqList &L, int low,int high){int p;if(low < high){p = Partition(L,low,high);QSort(L,low,p - 1);QSort(L,p + 1,high);}}void HeapAdjust (HeapType &H,int s, int m) //m为表长{int rc = H.r [s].key ;int j;for(j = 2*s;j <= m;j *= 2){if(j < m && H.r [j].key < H.r [j +1].key )++j;if(rc >= H.r [j].key )break;H.r [s].key = H.r [j].key ;s = j;}H.r [s].key = rc;}void HeapSort(HeapType &H){int i;int temp;for(i = H.length /2; i>=1; --i){HeapAdjust(H,i,H.length );for(i = H.length ;i > 1; --i){temp = H.r [1].key ;H.r [1].key = H.r [i].key ;H.r [i].key = temp;HeapAdjust(H,1,i -1);}}void prin(SqList &L,int lenth) {int i;for(i = 1;i <= lenth; i ++){printf("%d\t",L.r [i].key );}printf("\n");}void QuickSort(SqList &L){QSort(L,1,L.length );int main(){SqList L;int i,k;L.length = 20;int a[21] = {0,23,45,6,89, 7,36,26,13,18,76,98,78,68,53,36,72,79,65,46,25};int dlta[4] = {7, 5,3,1};for(i = 0;i <21;i ++){L.r[i].key = a[i];}prin(L,20);printf("请输入k的值,1,希尔排序;2,快速排序;3堆排序,其他不排序");switch(scanf("%d",&k)){case 1:ShellSort(L,dlta,4);prin(L,20);break;case 2:QuickSort(L);prin(L,20);break;case 3:HeapSort(L);prin(L,20);break;default:break;}return 0;}实验结果:石家庄经济学院信息工程学院希尔排序实验报告数实验心得:通过这次实验让我懂得了理论与实际相结合是很重要的,只有理论知识是远远不够的,只有把理论知识与实际结合起来才能提高自己的运用能力和独立思考的能力。

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

数据结构实验实验四、图遍历的演示。

【实验学时】5学时【实验目的】(1)掌握图的基本存储方法。

(2)熟练掌握图的两种搜索路径的遍历方法。

【问题描述】很多涉及图上操作的算法都是以图的遍历操作为基础的。

试写一个程序,演示连通的无向图上,遍历全部结点的操作。

【基本要求】以邻接多重表为存储结构,实现连通无向图的深度优先和广度优先遍历。

以用户指定的结点为起点,分别输出每种遍历下的结点访问序列和相应生成树的边集。

【测试数据】教科书图7.33。

暂时忽略里程,起点为北京。

【实现提示】设图的结点不超过30个,每个结点用一个编号表示(如果一个图有n个结点,则它们的编号分别为1,2,…,n)。

通过输入图的全部边输入一个图,每个边为一个数对,可以对边的输入顺序作出某种限制。

注意,生成树的边是有向边,端点顺序不能颠倒。

【选作内容】(1)借助于栈类型(自己定义和实现),用非递归算法实现深度优先遍历。

(2)以邻接表为存储结构,建立深度优先生成树和广度优先生成树,再按凹入表或树形打印生成树。

(3)正如习题7。

8提示中分析的那样,图的路径遍历要比结点遍历具有更为广泛的应用。

再写一个路径遍历算法,求出从北京到广州中途不过郑州的所有简单路径及其里程。

【源程序】#include<iostream.h>#include <stdio.h>#include <stdlib.h>#define MAX_VERTEX_NUM 20#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define TRUE 1#define OK 1#define FALSE 0#define ERROR 0#define OVERFLOW -2typedef enum{DG,DN,UDG,UDN}GraphKind;//{有向图,有向网,无向图,无向网} bool visited[MAX_VERTEX_NUM];typedef struct ArcNode{int adjvex;//该弧所指向的顶点在数组中的下标struct ArcNode *nextarc;int *info;//该弧相关信息的指针}ArcNode;typedef struct VNode{int data;//顶点信息ArcNode *firstarc;//指向第一条依附该顶点的弧的指针}VNode,AdjList[MAX_VERTEX_NUM];typedef struct{AdjList vertices;int vexnum,arcnum;//图的当前顶点数和弧数int kind;//图的种类标志}ALGraph;typedef struct{int *base;int *top;int stacksize;}SqStack;typedef struct QNode{int data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;int LocateVex(ALGraph G,int v){//返回数组下标值int i;for(i=0;i<MAX_VERTEX_NUM;++i)if(G.vertices[i].data==v) return i;return -1;}void CreateDN(ALGraph &G){//采用邻接表存储表示,构造有向图G(G.kind=DN)int i,j,k;ArcNode *p;int v1,v2;G.kind=DN;printf(" 输入顶点数:");scanf("%d",&G.vexnum);printf(" 输入弧数:");scanf("%d",&G.arcnum);printf(" 输入顶点:\n");for(i=0;i<G.vexnum;++i){//构造表头向量scanf("%d",&G.vertices[i].data);G.vertices[i].firstarc=NULL;//初始化指针}for(k=0;k<G.arcnum;++k){printf("第%d条弧: ",k+1);scanf("%d",&v1);scanf("%d",&v2);//输入一条弧的始点和终点i=LocateVex(G,v1);j=LocateVex(G,v2);//确定v1和v2在G中位置p=(ArcNode*)malloc(sizeof(ArcNode));//假定有足够空间p->adjvex=j;p->nextarc=G.vertices[i].firstarc;G.vertices[i].firstarc=p;scanf("%d",&p->info);}//for}int Push(SqStack &S,int e){//插入元素e为新的栈顶元素if(S.top-S.base>=S.stacksize){//栈满,追加存储空间S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int)) ;if(!S.base)exit(OVERFLOW); //存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}int InitStack(SqStack &S) //栈的初始化{S.base=(int*)malloc(STACK_INIT_SIZE*sizeof(int)); if(!S.base)exit(OVERFLOW); //存储分配失败S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}int Pop(SqStack &S,int &e) //删除栈顶元素{//若栈不空,则删除S的栈顶元素,用e返回其值if(S.top==S.base)return ERROR;e=*--S.top;return OK;}int GetTop(SqStack S,int &e) //取栈顶元素{//若栈不空,则用e返回S的栈顶元素if(S.top==S.base)return ERROR;e=*(S.top-1);return OK;}int StackEmpty(SqStack S) //栈空{if(S.top==S.base)return TRUE;elsereturn FALSE;}int InitQueue(LinkQueue &Q) //队列初始化{Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(OVERFLOW);Q.front->next=NULL;return OK;}int EnQueue(LinkQueue &Q,int e) //插入{//插入元素e为Q的新的队尾元素QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p)exit(OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return OK;}int DeQueue(LinkQueue &Q,int &e){//若队列不空,则删除Q的队头元素,用e返回其值if(Q.front==Q.rear)return ERROR;QueuePtr p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);return OK;}int QueueEmpty(LinkQueue Q) //队列空{if(Q.front==Q.rear)return TRUE;elsereturn FALSE;}int FirstAdjVex(ALGraph G,int u){if(!G.vertices[u].firstarc)return -1;return LocateVex(G,G.vertices[u].firstarc->adjvex); }int NextAdjVex(ALGraph G,int u,int w){ArcNode *p=G.vertices[u].firstarc;while(p&&LocateVex(G,p->adjvex)!=w)p=p->nextarc;if(!p)return FirstAdjVex(G,u);p=p->nextarc;if(!p)return -1;return LocateVex(G,p->adjvex);}void Visit(ALGraph G,int v){printf("%2d",G.vertices[v].data);}void DFSTraverse(ALGraph G){//按深度优先非递归遍历图G,使用辅助栈S和访问标志数组visited int v,w;SqStack S;for(v=0;v<G.vexnum;v++)visited[v]=FALSE;InitStack(S);for(v=0;v<G.vexnum;++v)if(!visited[v]){//v尚未被访问visited[v]=TRUE;Visit(G,v);Push(S,v);//v进栈while(!StackEmpty(S)){for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w)) {if(!visited[w]){Visit(G,w);visited[w]=TRUE;Push(S,w);GetTop(S,v);}//if}//forPop(S,v);GetTop(S,v);}//while}//ifprintf("\n");}void BFSTraverse(ALGraph G){//按广度优先非递归遍历图G,使用辅助队列Q和访问标志数组visited int v,u,w;LinkQueue Q;for(v=0;v<G.vexnum;++v)visited[v]=FALSE;InitQueue(Q);for(v=0;v<G.vexnum;++v)if(!visited[v]){//v尚未被访问visited[v]=TRUE;Visit(G,v);EnQueue(Q,v);//v入队列while(!QueueEmpty(Q)){DeQueue(Q,u);//队头元素出队并置为ufor(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))if(!visited[w]){//w为u的尚未访问的邻接顶点visited[w]=TRUE;Visit(G,w);EnQueue(Q,w);}//if}//while}//ifprintf("\n");}void PrintDN(ALGraph G) //图的显示{int i;ArcNode *p;printf("顶点:\n");for(i=0;i<G.vexnum;++i)printf("%2d",G.vertices[i].data);printf("\n弧:\n");for(i=0;i<G.vexnum;++i){p=G.vertices[i].firstarc;if(p){while(p){printf("%d→%d(%d)\t",i,p->adjvex,p->info);p=p->nextarc;}printf("\n");}//if}//for}void main(){ALGraph G;printf("************题目:图的遍历***************\n\n"); CreateDN(G);PrintDN(G);printf(" 深度优先遍历:");DFSTraverse(G);printf("\n 广度优先遍历:");BFSTraverse(G);}【运行结果】实验五查找算法实现【实验学时】5学时【实验目的】熟练掌握顺序查找、折半查找及二叉排序树、平衡二叉树上的查找、插入和删除的方法,比较它们的平均查找长度。

相关文档
最新文档