数据结构-实验8-图的基本操作

合集下载

数据结构实验报告八-快速排序

实验8 快速排序1．需求分析（1）输入的形式和输入值的范围：第一行是一个整数n，代表任务的件数。

接下来一行，有n个正整数，代表每件任务所用的时间。

中间用空格或者回车隔开。

不对非法输入做处理，及假设用户输入都是合法的。

（2）输出的形式：输出有n行，每行一个正整数，从第一行到最后一行依次代表着操作系统要处理的任务所用的时间。

按此顺序进行，则使得所有任务等待时间最小。

（3）程序所能达到的功能：在操作系统中，当有n 件任务同时来临时，每件任务需要用时ni，输出所有任务等待的时间和最小的任务处理顺序。

（4）测试数据：输入请输入任务个数：9请输入任务用时：5 3 4 2 6 1 5 7 3输出任务执行的顺序：1 2 3 3 4 5 5 6 72．概要设计（1）抽象数据类型的定义：为实现上述程序的功能，应以整数存储用户的第一个输入。

并将随后输入的一组数据储存在整数数组中。

（2）算法的基本思想：如果将任务按完成时间从小到大排序，则在完成前一项任务时后面任务等待的时间总和最小，即得到最小的任务处理顺序。

采取对输入的任务时间进行快速排序的方法可以在相对较小的时间复杂度下得到从小到大的顺序序列。

3．详细设计（1）实现概要设计中定义的所有数据类型：第一次输入的正整数要求大于零，为了能够存储，采用int型定义变量。

接下来输入的一组整数，数据范围大于零，为了排序需要，采用线性结构存储，即int类型的数组。

（2）实现程序的具体步骤：一.程序主要采取快速排序的方法处理无序数列：1．在序列中根据随机数确定轴值，根据轴值将序列划分为比轴值小和比轴值大的两个子序列。

2．对每个子序列采取从左右两边向中间搜索的方式，不断将值与轴值比较，如果左边的值大于轴值而右边的小于轴值则将二者交换，直到左右交叉。

3．分别对处理完毕的两个子序列递归地采取1，2步的操作，直到子序列中只有一个元素。

二.程序各模块的伪代码：1、主函数int main(){int n;cout<<"请输入任务个数：";cin>>n;int a[n];cout<<"请输入任务用时：";for(int i=0;i<n;i++) cin>>a[i];qsort(a,0,n-1); //调用“快排函数”cout<<"任务执行的顺序：";for(int i=0;i<n;i++) cout<<a[i]<<" "; //输出排序结果}2、快速排序算法：void qsort(int a[],int i,int j){if(j<=i)return; //只有一个元素int pivotindex=findpivot(a,i,j); //调用“轴值寻找函数”确定轴值swap(a,pivotindex,j); //调用“交换函数”将轴值置末int k=partition(a,i-1,j,a[j]); //调用“分割函数”根据轴值分割序列swap(a,k,j);qsort(a,i,k-1); //递归调用，实现子序列的调序qsort(a,k+1,j);}3、轴值寻找算法：//为了保证轴值的“随机性”，采用时间初始化种子。

数据结构实验报告图的遍历

数据结构实验报告图的遍历一、实验目的本实验旨在通过实践的方式学习图的遍历算法，掌握图的深度优先搜索（DFS）和广度优先搜索（BFS）的实现方法，加深对数据结构中图的理解。

二、实验步骤1. 创建图的数据结构首先，我们需要创建一个图的数据结构，以方便后续的操作。

图可以使用邻接矩阵或邻接表来表示，这里我们选择使用邻接矩阵。

class Graph:def__init__(self, num_vertices):self.num_vertices = num_verticesself.adj_matrix = [[0] * num_vertices for _ in range(num_vertic es)]def add_edge(self, v1, v2):self.adj_matrix[v1][v2] =1self.adj_matrix[v2][v1] =1def get_adjacent_vertices(self, v):adjacent_vertices = []for i in range(self.num_vertices):if self.adj_matrix[v][i] ==1:adjacent_vertices.append(i)return adjacent_vertices2. 深度优先搜索（DFS）DFS是一种遍历图的算法，其基本思想是从图的某一顶点开始，沿着一条路径一直走到最后，然后返回尚未访问过的顶点继续遍历，直到所有顶点都被访问过为止。

def dfs(graph, start_vertex):visited = [False] * graph.num_verticesstack = [start_vertex]while stack:vertex = stack.pop()if not visited[vertex]:print(vertex)visited[vertex] =Truefor neighbor in graph.get_adjacent_vertices(vertex):if not visited[neighbor]:stack.append(neighbor)3. 广度优先搜索（BFS）BFS同样是一种遍历图的算法，其基本思想是从图的某一顶点开始，首先访问其所有邻接点，然后再依次访问邻接点的邻接点，直到所有顶点都被访问过为止。

数据结构实验8 查找与排序

注意事项：在磁盘上创建一个目录，专门用于存储数据结构实验的程序。

因为机房机器有还原卡，请同学们将文件夹建立在最后一个盘中，以学号为文件夹名。

实验八查找和排序一、实验目的掌握运用数据结构两种基本运算查找和排序,并能通过其能解决应用问题。

二、实验要求1．掌握本实验的算法。

2．上机将本算法实现。

三、实验内容为宿舍管理人员编写一个宿舍管理查询软件, 程序采用交互工作方式,其流程如下:建立数据文件，数据结构采用线性表，存储方式任选（建议用顺序存储结构），数据元素是结构类型（学号，姓名，性别，房号），元素的值可从键盘上输入，可以在程序中直接初始化。

数据文件按关键字（学号、姓名、房号）进行排序（排序方法任选一种），打印排序结果。

（注意字符串的比较应该用strcmp(str1,str2)函数）查询菜单: (查找方法任选一种)1. 按学号查询2. 按姓名查询3. 按房号查询打印任一查询结果（可以连续操作）。

参考：typedef struct {char sno[10];char sname[2];int sex; //以0表示女，1表示男int roomno;}ElemType;struct SqList{ElemType *elem;int length;};void init(SqList &L){L.elem=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));L.length=0;}void printlist(SqList L){ int i;cout<<" sno name sex roomno\n";for(i=0;i<L.length;i++)cout<<setw(7)<<L.elem[i].sno<<setw(10)<<L.elem[i].sname<<setw(3)<<L.elem[i].sex<<setw(6) <<L.elem[i].roomno<<endl;}。

数据结构图的实验报告

数据结构图的实验报告数据结构图的实验报告引言：数据结构图是计算机科学中重要的概念之一。

它是一种用图形表示数据元素之间关系的数据结构，广泛应用于算法设计、程序开发和系统优化等领域。

本实验报告旨在介绍数据结构图的基本原理、实验过程和结果分析。

一、实验目的本次实验的主要目的是掌握数据结构图的基本概念和操作方法，以及通过实验验证其在解决实际问题中的有效性。

具体而言，我们将通过构建一个社交网络关系图，实现对用户关系的管理和分析。

二、实验方法1. 确定数据结构在本次实验中，我们选择了无向图作为数据结构图的基础。

无向图由顶点集和边集组成，每条边连接两个顶点，且没有方向性。

2. 数据输入为了模拟真实的社交网络，我们首先需要输入一组用户的基本信息，如姓名、年龄、性别等。

然后，根据用户之间的关系建立边，表示用户之间的交流和联系。

3. 数据操作基于构建好的数据结构图，我们可以进行多种操作，如添加用户、删除用户、查询用户关系等。

这些操作将通过图的遍历、搜索和排序等算法实现。

三、实验过程1. 数据输入我们首先创建一个空的无向图，并通过用户输入的方式逐步添加用户和用户关系。

例如，我们可以输入用户A和用户B的姓名、年龄和性别，并建立一条边连接这两个用户。

2. 数据操作在构建好数据结构图后，我们可以进行多种操作。

例如，我们可以通过深度优先搜索算法遍历整个图，查找与某个用户具有特定关系的用户。

我们也可以通过广度优先搜索算法计算某个用户的社交网络影响力，即与该用户直接或间接相连的其他用户数量。

3. 结果分析通过实验，我们可以观察到数据结构图在管理和分析用户关系方面的优势。

它能够快速地找到用户之间的关系，帮助我们了解用户的社交网络结构和影响力。

同时，数据结构图也为我们提供了一种可视化的方式来展示用户之间的关系，使得分析更加直观和易于理解。

四、实验结果通过实验，我们成功构建了一个社交网络关系图，并实现了多种数据操作。

我们可以根据用户的姓名、年龄和性别等信息进行查询，也可以根据用户之间的关系进行遍历和排序。

数据结构试验报告-图的基本操作

中原工学院《数据结构》实验报告学院：计算机学院专业：计算机科学与技术班级：计科112姓名：康岩岩学号：201100814220 指导老师：高艳霞2012-11-22实验五图的基本操作一、实验目的1、使学生可以巩固所学的有关图的基本知识。

2、熟练掌握图的存储结构。

3、熟练掌握图的两种遍历算法。

二、实验内容[问题描述]对给定图，实现图的深度优先遍历和广度优先遍历。

[基本要求]以邻接表为存储结构，实现连通无向图的深度优先和广度优先遍历。

以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。

【测试数据】由学生依据软件工程的测试技术自己确定。

三、实验前的准备工作1、掌握图的相关概念。

2、掌握图的逻辑结构和存储结构。

3、掌握图的两种遍历算法的实现。

四、实验报告要求1、实验报告要按照实验报告格式规范书写。

2、实验上要写出多批测试数据的运行结果。

3、结合运行结果，对程序进行分析。

【设计思路】【代码整理】#include "stdafx.h"#include <iostream>#include <malloc.h>using namespace std;typedef int Status;#define OK 1#define ERROR 0#define OVERFLOW -1#define MAX_SIZE 20typedef enum{DG,DN,UDG,UDN}Kind;typedef struct ArcNode{int adjvex; //顶点位置struct ArcNode *nextarc; //下一条弧int *info; //弧信息};typedef struct{char info[10]; //顶点信息ArcNode *fistarc; //指向第一条弧}VNode,AdjList[MAX_SIZE];typedef struct{AdjList vertices;int vexnum,arcnum; //顶点数，弧数int kind; //图的种类，此为无向图}ALGraph;//这是队列的节点，仅用于广度优先搜索typedef struct Node{int num;struct Node* next;};//队列的头和尾typedef struct{Node * front;Node *rear;}PreBit;int LocateV ex(ALGraph G,char info[]);//定位顶点的位置Status addArcNode(ALGraph &G,int adjvex); //图中加入弧Status CreatGraph(ALGraph&G);//创建图的邻接表Status DFSTraverse(ALGraph G);//深度优先搜索Status BFSTraverse(ALGraph G);//广度优先搜索Status DFS(ALGraph G,int v);//深度优先搜索中的数据读取函数，用于递归bool visited[MAX_SIZE]; // 访问标志数组//初始化队列Status init_q(PreBit&P_B){P_B.front=P_B.rear=(Node*)malloc(sizeof(Node));if(!P_B.front){exit(OVERFLOW);}P_B.front->next=NULL;}//将数据入队Status en_q(PreBit & P_B,int num){Node *p=(Node*)malloc(sizeof(Node));if(!p){exit(OVERFLOW);}p->num=num;p->next=NULL;P_B.rear->next=p;P_B.rear=p;return OK;}//出队Status de_q(PreBit & P_B){if(P_B.front==P_B.rear){return ERROR;}Node* p=P_B.front->next;P_B.front->next=p->next;if(P_B.rear==p){P_B.rear=P_B.front;}free(p);return OK;}Status CreatGraph(ALGraph&G){cout<<"请输入顶点数目和弧数目"<<endl;cin>>G.vexnum>>G.arcnum;//依次输入顶点信息for(int i=0;i<G.vexnum;i++){cout<<"请输入顶点名称"<<endl;cin>>G.vertices[i].info;G.vertices[i].fistarc=NULL;}//依次输入弧信息for(int k=1;k<=G.arcnum;k++){char v1[10],v2[10]; //用于表示顶点名称的字符数组int i,j; //表示两个顶点的位置BACK: //返回点cout<<"请输入第"<<k<<"条弧的两个顶点"<<endl;cin>>v1>>v2;i=LocateV ex(G,v1); //得到顶点v1的位置j=LocateV ex(G,v2); //得到顶点v2的位置if(i==-1||j==-1){ //头信息不存在则返回重输cout<<"不存在该节点!"<<endl;goto BACK; //跳到BACK 返回点}addArcNode(G,i); //将弧的顶点信息插入表中addArcNode(G,j);}return OK;}//倒序插入弧的顶点信息Status addArcNode(ALGraph &G,int adjvex){ArcNode *p; //弧节点指针p=(ArcNode*)malloc(sizeof(ArcNode));p->adjvex=adjvex;p->nextarc=G.vertices[adjvex].fistarc;//指向头结点的第一条弧G.vertices[adjvex].fistarc=p; //头结点的第一条弧指向p，即将p作为头结点的第一条弧return OK;}//定位顶点的位置int LocateV ex(ALGraph G,char info[]){for(int i=0;i<G.vexnum;i++){if(strcmp(G.vertices[i].info,info)==0){ //头结点名称与传入的信息相等，证明该头节点存在return i; //此时返回位置}}return -1;}//深度优先搜索Status DFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int i;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;i=LocateV ex(G,v1);if(i==-1){cout<<"不存在该节点!"<<endl;goto BACK;}DFS(G,i);return OK;}//深度优先搜索递归访问图Status DFS(ALGraph G,int v){visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息ArcNode *p;p=G.vertices[v].fistarc; //向头节点第一条while(p) //当弧存在{if(!visited[p->adjvex]){DFS(G,p->adjvex); //递归读取}p=p->nextarc;}return OK;}//广度优先搜索Status BFSTraverse(ALGraph G){for(int v=0;v<G.vexnum;v++){visited[v]=false;}char v1[10];int v;BACK:cout<<"请输入首先访问的顶点"<<endl;cin>>v1;v=LocateV ex(G,v1);if(v==-1){cout<<"不存在该节点!"<<endl;goto BACK;}PreBit P_B;init_q(P_B);ArcNode *p;visited[v]=true;cout<<G.vertices[v].info<<" ";//输出信息en_q(P_B,v); //将头位置v入队while(P_B.front!=P_B.rear){//当队列不为空时，对其进行访问int w=P_B.front->next->num;//读出顶点位置de_q(P_B);//顶点已经访问过，将其出队列p=G.vertices[w].fistarc;//得到与顶点相关的第一条弧while(p){if(!visited[p->adjvex]){en_q(P_B,p->adjvex);//将弧入队，但不读取，只是将其放在队尾}p=p->nextarc;}}return OK;}int _tmain(int argc, _TCHAR* argv[]){ALGraph G;CreatGraph(G);cout<<"深度优先搜索图:"<<endl;DFSTraverse(G);cout<<endl;cout<<"广度优先搜索图:"<<endl;BFSTraverse(G);cout<<endl;system("pause");return 0;}。

C语言数据结构线性表的基本操作实验报告

实验一线性表的基本操作一、实验目的与基本要求1．掌握数据结构中的一些基本概念。

数据、数据项、数据元素、数据类型和数据结构，以及它们之间的关系。

2．了解数据的逻辑结构和数据的存储结构之间的区别与联系；数据的运算与数据的逻辑结构的关系。

3．掌握顺序表和链表的基本操作：插入、删除、查找以及表的合并等运算。

4．掌握运用C语言上机调试线性表的基本方法。

二、实验条件1．硬件：一台微机2．软件：操作系统和C语言系统三、实验方法确定存储结构后，上机调试实现线性表的基本运算。

四、实验内容1．建立顺序表，基本操作包括：初始化，建立一个顺序存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。

2．建立单链表，基本操作包括：初始化，建立一个链式存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。

3．假设有两个按数据元素值非递减有序排列的线性表A和B，均以顺序表作为存储结构。

编写算法将A表和B表归并成一个按元素值非递增有序（允许值相同）排列的线性表C。

（可以利用将B中元素插入A中，或新建C表）4．假设有两个按数据元素值非递减有序排列的线性表A和B，均以单链表作为存储结构。

编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许值相同）排列的线性表C。

五、附源程序及算法程序流程图1.源程序（1）源程序(实验要求1和3)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct arr{int * elem;int length;int listsize;}Sqlist;void menu(); //菜单void InitList(Sqlist *p); // 创建线性表void ShowList(Sqlist *p); // 输出顺序线性表void ListDelete(Sqlist *p,int i,int &e); // 在顺序线性表中删除第i个元素，并用e返回其值void ListInsert(Sqlist *p); // 在顺序线性表中第i个元素前插入新元素evoid ListEmpty(Sqlist *p); // 判断L是否为空表void GetList(Sqlist *p,int i,int &e); // 用e返回L中第i个数据元素的值void ListInsert(Sqlist *p,int i,int e);bool compare(int a,int b);void LocateElem(Sqlist *L,int e); // 在顺序线性表L中查找第1个值与e满足compare()d元素的位序void MergeList_L(Sqlist *La,Sqlist *Lb); // 归并void main(){Sqlist La;Sqlist Lb;int n,m,x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:InitList(&La);break;case 2:ListEmpty(&La);break;case 3:printf("请输入插入的位序:\n");scanf("%d",&m);printf("请出入要插入的数:\n");scanf("%d",&x);ListInsert(&La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(&La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(&La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(&La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(&La);break;case 8:InitList(&Lb);break;case 9:MergeList_L(&La,&Lb);printf("归并成功!");break;}menu();scanf("%d",&n);}}/*菜单*/void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断La是否为空表\n\n");printf(" 3.插入元素(La)\n\n");printf(" 4.删除元素(La)\n\n");printf(" 5.定位元素(La)\n\n");printf(" 6.取元素(La)\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并为一个线性表La\n\n");printf("********************\n\n");}/*创建顺序线性表L*/void InitList(Sqlist *L){int n;int i=0;L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(NULL==L->elem)printf("储存分配失败!\n");else{L->length=0;L->listsize=LIST_INIT_SIZE;printf("输入顺序表a:\n");scanf("%d",&n);while(n){L->elem[i]=n;i++;L->length++;L->listsize=L->listsize-4;scanf("%d",&n);}}}/*输出顺序线性表*/void ShowList(Sqlist *p){int i;if(0==p->length)printf("数组为空!\n");elsefor(i=0;i<p->length;i++)printf("%d ",p->elem[i]);printf("\n");}/*判断L是否为空表*/void ListEmpty(Sqlist *p)if(0==p->length)printf("L是空表!\n");elseprintf("L不是空表!\n");}/*在顺序线性表中第i个元素前插入新元素e */void ListInsert(Sqlist *p,int i,int e){int *newbase;int *q1;int *q2;while(i<1||i>p->length+1){printf("您输入的i超出范围!\n请重新输入要插入的位置\n:");scanf("%d",&i);}if(p->length>=p->listsize){newbase=(int *)realloc(p->elem,(p->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);else{p->elem=newbase;p->listsize+=LISTINCREMENT;}}q1=&(p->elem[i-1]);for(q2=&(p->elem[p->length-1]);q2>=q1;--q2)*(q2+1)=*q2;*q1=e;++p->length;}/*/在顺序线性表中删除第i个元素，并用e返回其值*/void ListDelete(Sqlist *p,int i,int &e){int *q1,*q2;while(i<1||i>p->length){printf("您输入的i超出范围!请重新输入:");scanf("%d",&i);}q1=&(p->elem[i-1]);e=*q1;q2=p->elem+p->length-1;for(++q1;q1<=q2;++q1)*(q1-1)=*q1;--p->length;}/*对比a与b相等*/bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}/*在顺序线性表L中查找第1个值与e满足compare()d元素的位序*/ void LocateElem(Sqlist *L,int e){int i=1;int *p;p=L->elem;while(i<=L->length && !compare(*p++,e))++i;if(i<=L->length)printf("第1个与e相等的元素的位序为%d\n",i);elseprintf("没有该元素!\n");}/*用e返回L中第i个数据元素的值*/void GetList(Sqlist *p,int i,int &e){Sqlist *p1;p1=p;e=p1->elem[i-1];}/* 已知顺序线性表La和Lb是元素按值非递减排列*//* 把La和Lb归并到La上,La的元素也是按值非递减*/void MergeList_L(Sqlist *La,Sqlist *Lb){int i=0,j=0,k,t;int *newbase;Sqlist *pa,*pb;pa=La;pb=Lb;while(i<pa->length && j<pb->length){if(pa->elem[i] >= pb->elem[j]){if(pa->listsize==0){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(k=pa->length-1; k>=i; k--)pa->elem[k+1]=pa->elem[k];pa->length++;pa->elem[i]=pb->elem[j];i++;j++;}elsei++;}while(j<pb->length){if( pa->listsize < pb->length-j ){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(j;j<pb->length;j++,i++){pa->elem[i]=pb->elem[j];pa->length++;}}for(i=0;i<pa->length/2;i++){t=pa->elem[i];pa->elem[i]=pa->elem[pa->length-i-1];pa->elem[pa->length-i-1]=t;}}（2）源程序(实验要求2和4)#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;void menu();LinkList InitList();void ShowList(LinkList L);void ListDelete(LinkList L,int i,int &e);void ListEmpty(LinkList L);void GetList(LinkList L,int i,int &e);void ListInsert(LinkList L,int i,int e);bool compare(int a,int b);void LocateElem(LinkList L,int e);LinkList MergeList_L(LinkList La,LinkList Lb);int total=0;void main(){LinkList La;LinkList Lb;La=(LinkList)malloc(sizeof(struct LNode));La->next=NULL;Lb=(LinkList)malloc(sizeof(struct LNode));Lb->next=NULL;int n;int m;int x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:La->next=InitList();break;case 2:ListEmpty(La);break;case 3:printf("请输入要插入到第几个节点前:\n");scanf("%d",&m);printf("请输入插入的数据:\n");scanf("%d",&x);ListInsert(La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(La);break;case 8:Lb->next=InitList();break;case 9:La=MergeList_L(La,Lb);printf("归并成功\n");break;}menu();scanf("%d",&n);}}void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断是否为空表\n\n");printf(" 3.插入元素\n\n");printf(" 4.删除元素\n\n");printf(" 5.定位元素\n\n");printf(" 6.取元素\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并两线性表\n\n");printf("********************\n\n");}// 创建链式线性表LLinkList InitList(){int count=0;LinkList pHead=NULL;LinkList pEnd,pNew;pEnd=pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);while(pNew->data){count++;if(count==1){pNew->next=pHead;pEnd=pNew;pHead=pNew;}else{pNew->next=NULL;pEnd->next=pNew;pEnd=pNew;}pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);}free(pNew);total=total+count;return pHead;}// 判断L是否为空表void ListEmpty(LinkList L){if(NULL==L->next)printf("此表为空表!\n");elseprintf("此表不为空表!\n");}// 在链式线性表中第i个元素前插入新元素e void ListInsert(LinkList L,int i,int e){LinkList p;LinkList s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("不存在您要找的节点!\n");else{s=(LinkList)malloc(sizeof(int));s->data=e;s->next=p->next;p->next=s;printf("插入节点成功!\n");}}// 输出链式线性表void ShowList(LinkList L){LinkList p;p=L->next;if(p==NULL)printf("此表为空表!\n");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");}// 在链式线性表中删除第i个元素，并用e返回其值void ListDelete(LinkList L,int i,int &e){LinkList p;LinkList q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)printf("没有找到要删除的位置!");else{q=p->next;p->next=q->next;e=q->data;free(q);}}// 用e返回L中第i个数据元素的值void GetList(LinkList L,int i,int &e){LinkList p;p=L->next;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p)||j>i-1)printf("没有找到要查找的位置!");elsee=p->data;}// 对比a与b相等bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}// 在链式线性表L中查找第1个值与e满足compare()d元素的位序void LocateElem(LinkList L,int e){int i=0;LinkList p;p=L;while(p->next && !compare(p->data,e)){p=p->next;i++;}if(NULL==p->next){if(0==compare(p->data,e))printf("没有该元素!\n");elseprintf("第1个与e相等的元素的位序为%d\n",i);}elseif(compare(p->data,e))printf("没有该元素!\n");}LinkList MergeList_L(LinkList La,LinkList Lb){int i,j,k;LinkList pa_1,pb_1,pa_2,pb_2,pc,pd;pa_1=La->next;pc=pa_2=La;pb_1=pb_2=Lb->next;if(pa_1->data > pb_1->data){pc=pa_2=Lb;pa_1=Lb->next;pb_1=pb_2=La->next;}while(pa_1 && pb_1){if(pa_1->data >= pb_1->data){pa_2->next=pb_1;pb_2=pb_1->next;pb_1->next=pa_1;pb_1=pb_2;pa_2=pa_2->next;}else{pa_1=pa_1->next;pa_2=pa_2->next;}}if(pb_1)pa_2->next=pb_1;pd=(LinkList)malloc(sizeof(struct LNode));pd->next=NULL;pa_2=pd;k=total;for(i=0;i<total;i++){pa_1=pc->next;for(j=1;j<k;j++)pa_1=pa_1->next;pb_1=(LinkList)malloc(sizeof(struct LNode));pa_2->next=pb_1;pa_2=pa_2->next;pa_2->data=pa_1->data;k--;}pa_2->next=NULL;return pd;}2.流程图(实验要求1和3)图1 主函数流程图图2创建线性表La流程图图3判断La是否为空表流程图图4 插入元素(La)流程图图5删除元素(La)流程图图6定位元素(La)流程图图7取元素(La)流程图图8输出线性表流程图图9输出线性表流程图流程图(实验要求2和4)图10主函数流程图图11创建线性表La流程图图12判断是否为空表流程图图13插入元素流程图图14删除元素流程图图15定位元素流程图图图16取元素流程图图17创建Lb流程图图18归并两表流程图六、运行结果1. (实验要求1和3)点击运行，首先出现的是菜单界面，选择菜单选项进行操作，如图所示。

数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程，通过本次实验，旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。

具体目的包括：1、熟练掌握线性表（如顺序表、链表）的基本操作，如插入、删除、查找等。

2、理解栈和队列的特性，并能够实现其基本操作。

3、掌握树（二叉树、二叉搜索树）的遍历算法和基本操作。

4、学会使用图的数据结构，并实现图的遍历和相关算法。

二、实验环境本次实验使用的编程环境为具体编程环境名称，编程语言为具体编程语言名称。

三、实验内容及步骤（一）线性表的实现与操作1、顺序表的实现定义顺序表的数据结构，包括数组和表的长度等。

实现顺序表的初始化、插入、删除和查找操作。

2、链表的实现定义链表的节点结构，包含数据域和指针域。

实现链表的创建、插入、删除和查找操作。

（二）栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。

实现栈的入栈、出栈和栈顶元素获取操作。

2、队列的实现采用循环队列的方式实现队列的数据结构。

完成队列的入队、出队和队头队尾元素获取操作。

（三）树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。

2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。

3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。

（四）图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。

2、图的遍历实现深度优先遍历和广度优先遍历算法。

四、实验结果与分析（一）线性表1、顺序表插入操作在表尾进行时效率较高，在表头或中间位置插入时需要移动大量元素，时间复杂度较高。

删除操作同理，在表尾删除效率高，在表头或中间删除需要移动元素。

2、链表插入和删除操作只需修改指针，时间复杂度较低，但查找操作需要遍历链表，效率相对较低。

（二）栈和队列1、栈栈的特点是先进后出，适用于函数调用、表达式求值等场景。

入栈和出栈操作的时间复杂度均为 O(1)。

2、队列队列的特点是先进先出，常用于排队、任务调度等场景。

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作数据结构--实验报告线性表的基本操作一、引言本实验报告旨在通过实际操作，掌握线性表的基本操作，包括初始化、插入、删除、查找等。

线性表是最基本的数据结构之一，对于理解和应用其他数据结构具有重要的作用。

二、实验目的1·了解线性表的定义和基本特性。

2·掌握线性表的初始化操作。

3·掌握线性表的插入和删除操作。

4·掌握线性表的查找操作。

5·通过实验巩固和加深对线性表的理解。

三、线性表的基本操作1·初始化线性表线性表的初始化是将一个线性表变量设置为空表的过程。

具体步骤如下：（1）创建一个线性表的数据结构，包括表头指针和数据元素的存储空间。

（2）将表头指针指向一个空的数据元素。

2·插入元素插入元素是向线性表中指定位置插入一个元素的操作。

具体步骤如下：（1）判断线性表是否已满，如果已满则无法插入元素。

（2）判断插入位置是否合法，如果不合法则无法插入元素。

（3）将插入位置及其后面的元素都向后移动一个位置。

（4）将待插入的元素放入插入位置。

3·删除元素删除元素是从线性表中删除指定位置的元素的操作。

具体步骤如下：（1）判断线性表是否为空，如果为空则无法删除元素。

（2）判断删除位置是否合法，如果不合法则无法删除元素。

（3）将删除位置后面的元素都向前移动一个位置。

（4）删除最后一个元素。

4·查找元素查找元素是在线性表中查找指定元素值的操作。

具体步骤如下：（1）从线性表的第一个元素开始，逐个比较每个元素的值，直到找到目标元素或遍历完整个线性表。

（2）如果找到目标元素，则返回该元素的位置。

（3）如果未找到目标元素，则返回找不到的信息。

四、实验步骤1·初始化线性表（1）定义线性表的数据结构，包括表头指针和数据元素的存储空间。

（2）将表头指针指向一个空的数据元素。

2·插入元素（1）判断线性表是否已满。

实验8 队列(循环队列)的表示和实现

浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验八队列（循环队列）的表示和实现实验成绩指导老师（签名）日期一.实验目的和要求1、掌握队列的存储结构及基本操作。

2、掌握循环队列的设置及循环队列的各种基本操作的实现。

3、通过具体的应用实例，进一步熟悉和掌握队列的实际应用。

二.实验内容1、建立头文件test8.h，定义顺序存储的循环队列存储结构，并编写循环队列的各种基本操作实现函数。

同时建立一个验证操作实现的主函数文件test8.cpp，编译并调试程序，直到正确运行。

说明：队列的基本操作可包括：①void InitQueue (Queue &Q); //构造一个空队列Q②int EmptyQueue (Queue Q);//判断队列Q是否为空，若空返回1，否则返回0③void EnQueue (Queue &Q, ElemType item); //元素item 进队列Q④ElemType OutQueue (Queue &Q); //队头元素出队列Q，并返回其值⑤ElemType PeekQueue (Queue Q); //返回队头元素值⑥void ClearQueue (Queue &Q); //清空队列2、应用（选做部分）：编写程序，实现舞伴问题：假设在周末舞会上，男士们和女士们进入舞厅时，各自排成一队，跳舞开始时，依次从男队和女队的队头上各出一人配成舞伴，若两队初始人数不相同，则较长的那一队中未配对者等待下一轮舞曲。

现要求设计一个函数void partner()，模拟上述舞伴配对问题。

基本要求:1)由键盘输入数据，每对数据包括姓名和性别；2)输出结果包括配成舞伴的女士和男士的姓名，以及未配对者的队伍名称和队头者的姓名；3)要求利用test8.h中已实现的顺序循环队列的基本操作函数来实现。

函数void partner()添加到文件test8.cpp中，在主函数中进行调用测试。

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作线性表的基本操作实验报告1.引言线性表是最基本的数据结构之一，它可以用来存储一系列具有相同数据类型的元素。

本实验旨在通过实践掌握线性表的基本操作，包括插入、删除、查找和修改元素等。

本文档将详细介绍实验所需的步骤和操作方法。

2.实验目的1.掌握线性表的插入和删除操作。

2.理解线性表的查找和修改元素的方法。

3.熟悉线性表的基本操作在算法中的应用。

3.实验环境本实验使用编程语言/软件名称作为开发环境，具体要求如下：________●操作系统：________操作系统名称和版本●编程语言：________编程语言名称和版本4.实验步骤4.1 初始化线性表在程序中创建一个空的线性表，用于存储元素。

实现方法：________具体的初始化方法和代码示例 4.2 插入元素在线性表中指定位置插入一个新元素。

实现方法：________具体的插入元素方法和代码示例 4.3 删除元素删除线性表中指定位置的元素。

实现方法：________具体的删除元素方法和代码示例 4.4 查找元素在线性表中查找指定元素的位置。

实现方法：________具体的查找元素方法和代码示例 4.5 修改元素修改线性表中指定位置的元素值。

实现方法：________具体的修改元素方法和代码示例5.实验结果在完成上述步骤后，我们得到了一个可以进行插入、删除、查找和修改元素的线性表。

具体操作结果如下：________●插入元素操作结果：________插入元素的具体操作结果●删除元素操作结果：________删除元素的具体操作结果●查找元素操作结果：________查找元素的具体操作结果●修改元素操作结果：________修改元素的具体操作结果6.实验总结通过本次实验，我们深入理解了线性表的基本操作，并且掌握了这些操作的实现方法。

线性表在实际应用中十分常见，熟练掌握线性表的操作对于开发高效的算法和数据结构具有重要意义。

数据结构--实验报告线性表的基本操作

一、实验目的二、实验内容和要求三、源代码1)顺序表的代码2)单链表的代码四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的1、帮助读者复习C++语言程序设计中的知识。

2、熟悉线性表的逻辑结构。

3、熟悉线性表的基本运算在两种存储结构上的实现。

4、掌握顺序表的存储结构形式及其描述和基本运算的实现。

5、熟练掌握动态链表结构及有关算法的设计二、实验内容题目一：顺序表的基本操作[问题描述]实现顺序表的建立、求长度，取元素、修改元素、插入、删除等顺序表的基本操作。

[基本要求]（1）依次从键盘读入数据，建立带头结点的顺序表；（2）输出顺序表中的数据元素（3）求顺序表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。

（6）根据算法，将两个有序的顺序表合并成一个有序顺序表。

[测试数据] 由学生任意指定。

题目二：单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。

[基本要求]（1）依次从键盘读入数据，建立带头结点的单链表；（2）输出单链表中的数据元素（3）求单链表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。

（6）根据算法，将两个有序的单链表合并成一个有序单链表。

[测试数据]由学生任意指定。

三、源代码(一)顺序表的基本操作#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for (p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}Status Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++)L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(SqList &L,int i,ElemType &e) //删除{ ElemType *p, *q;if(i<1 || i>L.length) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p) *(p-1)=*p;--L.length;return OK;}Status Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度：";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void chaxun(SqList &L1) //取第i个位置的元素{ int j;ElemType e1;cout<<"请选择所要取出元素的位置:";while(j<0||j>Listlength(L1)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>j; }GetElem(L1,j,e1);cout<<"取出的元素为:"<<e1<<endl; }void xiugai(SqList &L1) //修改第i个位置的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要修改元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要修改元素的位置:";cin>>j; }cout<<"要修改成的元素:";cin>>e1;Listxiugei(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度："; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度："; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下："; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<" 顺序表的基本操作"<<endl;cout<<" 1.顺序表的创建"<<endl;cout<<" 2.顺序表的显示"<<endl;cout<<" 3.顺序表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到顺序表里"<<endl;cout<<" 7.删除顺序表里的元素"<<endl;cout<<" 8.合并两个顺序表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择：";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break; case 4: chaxun(Lx);break;case 5: xiugai(Lx);break;case 6: charu(Lx);break;case 7: shanchu(Lx);break;case 8: hebing(Lx);break;case 9: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误，请重新选择"<<endl;break; }}}(二)单链表的基本操作#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在 e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点 if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点，并令p指向其前驱p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) { //合并两个顺序链表LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共（"<<a<<"个）："<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共（"<<b<<"个）："<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下："<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";while(x<0||x>Length(list,s)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误，请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);default : cout<<"输入有误，请重新输入"<<endl;break;}}}四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时，我有点惊讶，才学了不到一个月，就要写实验报告。

数据结构实验顺序表的基本操作

数据结构实验-顺序表的基本操作顺序表是一种线性数据结构，它的元素在内存中是连续存储的。

顺序表具有随机访问的特点，可以通过下标直接访问元素，因此在访问元素时具有较高的效率。

顺序表的基本操作包括插入、删除、查找等，下面将对这些基本操作进行详细介绍。

1. 初始化：初始化顺序表需要为其分配一定的内存空间，以存储元素。

可以使用静态分配或动态分配两种方式来初始化顺序表。

静态分配是在编译时为顺序表分配固定大小的内存空间，而动态分配是在运行时根据需要动态地为顺序表分配内存空间。

2. 插入操作：插入操作是将一个元素插入到顺序表的指定位置上。

在插入元素之前，需要判断顺序表是否已满，如果已满则需要进行扩容操作。

插入元素时，需要将插入位置以及其后的元素向后移动一位，为插入元素腾出位置。

插入操作的时间复杂度为O(n)，其中n为顺序表的长度。

3. 删除操作：删除操作是将顺序表中的一个元素删除。

在删除元素之前，需要判断顺序表是否为空，如果为空则无法进行删除操作。

删除元素时，需要将删除位置后面的元素向前移动一位，覆盖删除位置上的元素。

删除操作的时间复杂度为O(n)，其中n为顺序表的长度。

4. 查找操作：查找操作是根据给定的关键字，在顺序表中查找满足条件的元素。

可以使用顺序查找或二分查找两种方式进行查找。

顺序查找是从顺序表的第一个元素开始，逐个比较关键字，直到找到满足条件的元素或遍历完整个顺序表。

二分查找是在有序顺序表中进行查找，每次将待查找区间缩小一半，直到找到满足条件的元素或待查找区间为空。

查找操作的时间复杂度为O(n)，其中n为顺序表的长度。

5. 修改操作：修改操作是将顺序表中的一个元素修改为新的值。

修改操作需要先进行查找操作，找到待修改的元素，然后将其值修改为新的值。

修改操作的时间复杂度为O(n)，其中n为顺序表的长度。

6. 遍历操作：遍历操作是依次访问顺序表中的每个元素。

可以使用for循环或while循环进行遍历，从第一个元素开始，依次访问每个元素，直到遍历完整个顺序表。

南邮数据结构实验报告

南邮数据结构实验报告实验目的，通过本次实验，我们旨在加深对数据结构的理解，掌握数据结构的基本操作和算法设计能力，提高对数据结构的应用能力和实际问题的解决能力。

一、实验内容。

1. 实验一，线性表的基本操作。

本次实验中，我们首先学习了线性表的基本概念和操作，包括插入、删除、查找等操作，并通过实际编程操作来加深对线性表的理解。

2. 实验二，栈和队列的应用。

在实验二中，我们通过实际编程操作来学习栈和队列的应用，包括中缀表达式转换为后缀表达式、栈的应用、队列的应用等内容。

3. 实验三，树和二叉树的基本操作。

实验三中，我们学习了树和二叉树的基本概念和操作，包括树的遍历、二叉树的建立和遍历等内容，并通过实际编程操作来加深对树和二叉树的理解。

4. 实验四，图的基本操作。

最后，我们学习了图的基本概念和操作，包括图的存储结构、图的遍历等内容，并通过实际编程操作来加深对图的理解。

二、实验过程。

在实验过程中，我们首先对实验内容进行了深入的学习和理解，掌握了数据结构的基本概念和操作方法。

然后，我们通过实际编程操作来加深对数据结构的理解，并通过调试和修改程序来提高对数据结构的应用能力和实际问题的解决能力。

在实验过程中，我们遇到了一些问题，但通过不懈的努力和团队合作，最终顺利完成了实验任务。

三、实验结果与分析。

通过本次实验，我们深入理解了数据结构的基本概念和操作方法，掌握了线性表、栈、队列、树、二叉树和图的基本操作，并通过实际编程操作加深了对数据结构的理解。

同时，我们也提高了对数据结构的应用能力和实际问题的解决能力，为今后的学习和工作打下了坚实的基础。

四、实验总结。

通过本次实验，我们不仅加深了对数据结构的理解，还提高了对数据结构的应用能力和实际问题的解决能力。

在今后的学习和工作中，我们将继续努力，不断提升自己的专业能力，为将来的发展打下坚实的基础。

以上就是本次实验的报告内容，谢谢！。

《数据结构》教学大纲

《数据结构》教学大纲数据结构教学大纲一、课程介绍1.1课程名称：数据结构1.2学分：3学分1.3先修课程：计算机基础1.4课程性质：必修课程1.5学习方式：课堂讲授、实践操作、实验、课程作业二、教学目标2.1知识目标通过本课程的学习，学生应该掌握以下知识：-基本数据结构的概念和特性，包括数组、链表、栈、队列、树和图等；-常用的数据结构算法，如查找、排序、插入和删除等；-理解数据结构的时间复杂度和空间复杂度，并能进行分析和评估；-能够选择合适的数据结构和算法来解决实际问题。

2.2能力目标-能够运用所学的数据结构和算法解决实际问题；-能够分析和评估不同数据结构和算法的优劣；-具备良好的编程能力，能够实现数据结构的基本操作；-能够进行抽象思维和问题建模，将实际问题转化为数据结构的操作。

2.3态度目标-具备良好的团队合作和沟通能力，能够与他人合作解决问题；-具备批判性思维和创新精神，能够提出新的数据结构和算法。

三、教学内容3.1数据结构概述-数据结构的定义和分类；-数据结构与算法的关系；-数据结构的应用领域。

3.2线性表-线性表的定义和基本操作；-顺序表和链表的实现；-线性表的应用。

3.3栈和队列-栈和队列的定义和基本操作；-栈和队列的实现；-栈和队列的应用。

3.4树和二叉树-树和二叉树的定义和基本操作；-二叉树的遍历和线索化；-树和二叉树的应用。

3.5图-图的定义和基本操作；-图的存储结构和遍历算法；-图的应用。

3.6查找和排序-查找算法的分类和基本思想；-顺序查找和二分查找；-排序算法的分类和基本思想；-冒泡排序、插入排序和快速排序。

四、教学方法4.1讲授法：通过课堂讲授，向学生介绍数据结构的概念、特性和应用，讲解基本操作和算法的原理和实现方法。

4.2实践操作：通过编程实践和课程作业，让学生运用所学的数据结构和算法解决实际问题，加深对知识的理解和运用能力。

4.3实验：通过实验，让学生亲自操作和实验不同的数据结构，加深对数据结构和算法的理解。

数据结构实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中的重要基础课程，通过实验可以更深入地理解和掌握数据结构的概念、原理和应用。

本次实验的主要目的包括：1、熟悉常见的数据结构，如链表、栈、队列、树和图等。

2、掌握数据结构的基本操作，如创建、插入、删除、遍历等。

3、提高编程能力和解决实际问题的能力，能够运用合适的数据结构解决具体的问题。

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

三、实验内容1、链表的实现与操作单向链表的创建、插入和删除节点。

双向链表的实现和基本操作。

循环链表的特点和应用。

2、栈和队列的实现栈的后进先出特性，实现入栈和出栈操作。

队列的先进先出原则，完成入队和出队功能。

3、树的操作二叉树的创建、遍历（前序、中序、后序）。

二叉搜索树的插入、查找和删除操作。

4、图的表示与遍历邻接矩阵和邻接表表示图。

深度优先搜索和广度优先搜索算法的实现。

四、实验步骤及结果1、链表的实现与操作单向链表：首先，定义了链表节点的结构体，包含数据域和指向下一个节点的指针域。

通过创建链表头节点，并使用循环依次插入新节点，实现了链表的创建。

插入节点时，根据指定位置找到插入点的前一个节点，然后修改指针完成插入操作。

删除节点时，同样找到要删除节点的前一个节点，修改指针完成删除。

实验结果：成功创建、插入和删除了单向链表的节点，并正确输出了链表的内容。

双向链表：双向链表节点结构体增加了指向前一个节点的指针。

创建、插入和删除操作需要同时维护前后两个方向的指针。

实验结果：双向链表的各项操作均正常，能够双向遍历链表。

循环链表：使链表的尾节点指向头节点，形成循环。

在操作时需要特别注意循环的边界条件。

实验结果：成功实现了循环链表的创建和遍历。

2、栈和队列的实现栈：使用数组或链表来实现栈。

入栈操作将元素添加到栈顶，出栈操作取出栈顶元素。

实验结果：能够正确进行入栈和出栈操作，验证了栈的后进先出特性。

《数据结构》课程实验实训报告--堆栈和队列的基本操作。

}
if(StackTop(myStack,&x)==0)
{
printf("error!\n");
return;
}
else
printf("The element of local top is :%d\n",x);
printf("The sequence of outing elements is:\n");
(*head)->next = NULL;
}/*判非空操作：*/
int StackNotEmpty(LSNode *head) /*判堆栈是否非空，非空返回1；空返回0*/
{
if(head->next == NULL) return 0; else return 1;
}/*入栈操作：*/
int StackPush(LSNode *head, DataType x) /*把数据元素x插入链式堆栈head的栈顶作为新的栈顶*/ { LSNode *p; if((p = (LSNode *)malloc(sizeof(LSNode))) == NULL) { printf("内存空间不足无法插入! \n"); return 0; } p->data = x; p->next = head->next; /*新结点链入栈顶*/ head->next = p; /*新结点成为新的栈顶*/ return 1; } /*出栈操作：*/
依次把5个元素入栈然后出栈并在屏幕上显示出栈的数据元对顺序循环队列常规的方法是使用队尾指针和队头指针队尾指针用于指示当前的队尾位置下标队头指针用于指示当前的队头位置下标
《数据结构》课程实验实训报告

数据结构实验图的邻接表和邻接矩阵操作

5
p->weight=weight; p->nextarc=G.vertices[vv].firstarc; G.vertices[vv].firstarc=p; strcmp(G.vertices[vv].data,v);
q=(ArcNode *)malloc(sizeof(ArcNode)); q->adjvex=vv; q->weight=weight; q->nextarc=G.vertices[ww].firstarc; G.vertices[ww].firstarc=q; strcmp(G.vertices[ww].data,w);
实验报告 6
课程数据结构实验名称图的建立及遍历
第页
专业
班级_ __ 学号_ ___ 姓名
实验日期： 2010 年 11 月 23 日
评分
一、实验目的
1．学会用邻接矩阵和邻接表实现图结构和对图的基本操作。 2．掌握对图操作的具体实现； 3. 掌握图的两种遍历算法（深度优先、广度优先）； 4、掌握求图的最小生成树和顶点间最短路径的算法；
int adjvex;//该弧指向的顶点的位置 ArcType weight; struct ArcNode *nextarc;//指向下一条弧指针 //InfoType *info;该弧相关信息的指针 }ArcNode; typedef struct VNode { VertexType data;//顶点信息 ArcNode *firstarc;//指向第一条依附该顶点的弧的指针 }VNode,AdjList[MAX_VEX_NUM]; typedef struct { AdjList vertices; int vexnum,arcnum; GraphKind kind; }ALGraph; ALGraph G; struct MiniSpanTree_Flag { VertexType adjvex; ArcType lowcost; }closedge[MAX_VEX_NUM]; typedef bool PathMatrix[MAX_VEX_NUM][MAX_VEX_NUM];

数据结构实验C语言版

数据结构实验C语言版数据结构实验C语言版文档一、实验目的本实验旨在通过实践操作，加深对C语言中数据结构的理解，掌握常用数据结构的实现方法，提高编程能力。

二、实验内容本实验共包含以下几个章节：1.线性表1.1 顺序表的实现1.2 链表的实现1.3 环形链表的实现2.栈与队列2.1 栈的实现2.2 队列的实现3.树与图3.1 二叉树的实现与遍历3.2 图的实现与遍历4.排序与查找4.1 冒泡排序4.2 快速排序4.3 二分查找5.其他常用数据结构5.1 哈希表5.2 AVL树5.3 并查集三、实验步骤1.线性表1.1 顺序表的实现- 定义顺序表结构体 - 初始化顺序表- 插入元素- 删除元素- 查找元素1.2 链表的实现- 定义链表结构体- 初始化链表- 插入节点- 删除节点- 查找节点1.3 环形链表的实现- 定义环形链表结构体 - 初始化环形链表- 插入节点- 删除节点- 查找节点2.栈与队列2.1 栈的实现- 定义栈结构体- 初始化栈- 入栈操作- 出栈操作- 获取栈顶元素2.2 队列的实现- 定义队列结构体- 初始化队列- 入队操作- 出队操作- 获取队首元素3.树与图3.1 二叉树的实现与遍历 - 定义二叉树结构体 - 创建二叉树- 先序遍历- 中序遍历- 后序遍历3.2 图的实现与遍历- 定义图结构体- 创建图- 广度优先搜索- 深度优先搜索4.排序与查找4.1 冒泡排序- 实现冒泡排序算法- 对数组进行排序4.2 快速排序- 实现快速排序算法- 对数组进行排序4.3 二分查找- 实现二分查找算法- 在有序数组中查找指定元素5.其他常用数据结构5.1 哈希表- 定义哈希表结构体- 初始化哈希表- 插入元素- 删除元素- 查找元素5.2 AVL树- 定义AVL树结构体- 插入节点- 删除节点- 查找节点5.3 并查集- 定义并查集结构体- 初始化并查集- 合并集合- 查找根节点四、附件本文档未涉及附件。

《数据结构》实验书

目录实验一线性表基本操作的编程实现 (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个位置。

数据结构实验任务书(8个)

目录实验1 线性表顺序存储的应用 (2)实验2 线性表链式存储的应用 (5)实验3 栈及其应用 (6)实验4 队列及其应用 (7)实验5 树及其应用 (8)实验6 图的遍历和连通性应用 (9)实验7 图的最短路径应用 (11)实验8 查找和排序应用 (12)实验1 线性表顺序存储的应用实验目的1．熟悉C语言的上机环境，掌握C语言的基本结构。

2．会定义线性表的顺序存储结构。

3．熟悉对顺序表的一些基本操作和具体的函数定义。

4．掌握在线性表的顺序存储结构上的一些其它操作。

实验要求1．独立完成；2．程序调试正确，有执行结果。

实验内容1、基础题：编写应用程序（填空），实现可以在顺序表中插入任意给定数据类型（定义为抽象数据类型）数据的功能。

要求在主函数中定义顺序表并对该顺序表插入若干个整数类型的数据（正整数），对它们求和并输出。

请使用动态内存分配的方式申请数组空间，并把主函数设计为一个文件SeqList.cpp，其余函数设计为另一个文件SeqList.h。

请填空完成以下给出的源代码并调试通过。

（1）文件SeqList.h:typedef struct List{ElemType *elem;int length;int listsize;}SeqList;void InitList(SeqList &L){ //初始化线性表…………}void ClearList(SeqList &L){ //清除线性表………………}int LengthList(SeqList L){ //求线性表长度………..}bool InsertList(SeqList &L, ElemType item, int pos){ //按给定条件pos向线性表插入一个元素…….}ElemType GetList(SeqList L, int pos){ //在线性表L中求序号为pos的元素，该元素作为函数值返回…………..}（2）文件SeqList.cpp：#include <stdio.h>#include <stdlib.h>typedef ElemType;#define MAXSize 10#include "SeqList.h"void main(void){SeqList myList;int i=1, x, sum=0, n;InitList ( );scanf(“%d”, &x);while ( x!= -1 ){if ( InsertList (myList, , i )==0) {printf("错误!\n");return ;}i++;scanf(“%d”, &x);}n = LengthList (myList);for (i=1; i<=n; i++){x=GetList(myList, i);sum = + x;}printf("%d\n ", sum);ClearList(myList);}2、提高部分：编写函数bool DeleteElem(SeqList &L, int min, int max)实现从顺序表中删除其值在给定值min和max之间（min < max）的所有元素，要求把该函数添加到文件SeqList.h中，并在主函数文件SeqList.cpp中添加相应语句进行测试。

数据结构-实验8-图的基本操作

数据结构实验报告八-快速排序

数据结构实验报告图的遍历

数据结构实验8 查找与排序

数据结构图的实验报告

数据结构试验报告-图的基本操作

C语言数据结构线性表的基本操作实验报告

数据结构实验报告

数据结构--实验报告 线性表的基本操作

实验8 队列(循环队列)的表示和实现

数据结构--实验报告 线性表的基本操作

数据结构--实验报告 线性表的基本操作

数据结构实验顺序表的基本操作

南邮数据结构实验报告

《数据结构》教学大纲

数据结构实验报告

《数据结构》课程实验实训报告--堆栈和队列的基本操作。

数据结构实验 图的邻接表和邻接矩阵操作

数据结构实验C语言版

《数据结构》实验书

数据结构实验任务书(8个)

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作

数据结构实验图的邻接表和邻接矩阵操作