数据结构实验五
数据结构实验五矩阵的压缩存储与运算学习资料
数据结构实验五矩阵的压缩存储与运算第五章矩阵的压缩存储与运算【实验目的】1. 熟练掌握稀疏矩阵的两种存储结构(三元组表和十字链表)的实现；2. 掌握稀疏矩阵的加法、转置、乘法等基本运算；3. 加深对线性表的顺序存储和链式结构的理解。
第一节知识准备矩阵是由两个关系（行关系和列关系）组成的二维数组，因此对每一个关系上都可以用线性表进行处理；考虑到两个关系的先后，在存储上就有按行优先和按列优先两种存储方式，所谓按行优先，是指将矩阵的每一行看成一个元素进行存储；所谓按列优先，是指将矩阵的每一列看成一个元素进行存储；这是矩阵在计算机中用一个连续存储区域存放的一般情形，对特殊矩阵还有特殊的存储方式。
一、特殊矩阵的压缩存储1. 对称矩阵和上、下三角阵若n阶矩阵A中的元素满足= （0≤i，j≤n-1 ）则称为n阶对称矩阵。
对n阶对称矩阵，我们只需要存储下三角元素就可以了。
事实上对上三角矩阵（下三角部分为零）和下三角矩阵（上三角部分为零），都可以用一维数组ma[0.. ]来存储A的下三角元素（对上三角矩阵做转置存储），称ma为矩阵A的压缩存储结构，现在我们来分析以下，A和ma之间的元素对应放置关系。
问题已经转化为：已知二维矩阵A[i，j]，如图5-1，我们将A用一个一维数组ma[k]来存储，它们之间存在着如图5-2所示的一一对应关系。
任意一组下标(i,j)都可在ma中的位置k中找到元素m[k]= ；这里：k=i(i+1)/2+j (i≥j)图5-1 下三角矩阵a00 a10 a11 a20 … an-1,0 … an-1,n-1k= 0 1 2 3 …n(n-1)/2 …n(n+1)/2-1图5-2下三角矩阵的压缩存储反之，对所有的k=0,1，2,…,n(n+1)/2-1，都能确定ma[k]中的元素在矩阵A中的位置（i,j）。
这里，i=d-1，（d是使sum= > k的最小整数），j= 。
2. 三对角矩阵在三对角矩阵中，所有的非零元素集中在以主对角线为中心的带内状区域中，除了主对角线上和直接在对角线上、下方对角线上的元素之外，所有其它的元素皆为零，见图5-3。
《数据结构》实验报告
苏州科技学院数据结构（C语言版）实验报告专业班级测绘1011学号10201151姓名XX实习地点C1 机房指导教师史守正目录封面 (1)目录 (2)实验一线性表 (3)一、程序设计的基本思想，原理和算法描述 (3)二、源程序及注释（打包上传） (3)三、运行输出结果 (4)四、调试和运行程序过程中产生的问题及采取的措施 (6)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (6)实验二栈和队列 (7)一、程序设计的基本思想，原理和算法描述 (8)二、源程序及注释（打包上传） (8)三、运行输出结果 (8)四、调试和运行程序过程中产生的问题及采取的措施 (10)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (10)实验三树和二叉树 (11)一、程序设计的基本思想，原理和算法描述 (11)二、源程序及注释（打包上传） (12)三、运行输出结果 (12)四、调试和运行程序过程中产生的问题及采取的措施 (12)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (12)实验四图 (13)一、程序设计的基本思想，原理和算法描述 (13)二、源程序及注释（打包上传） (14)三、运行输出结果 (14)四、调试和运行程序过程中产生的问题及采取的措施 (15)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (16)实验五查找 (17)一、程序设计的基本思想，原理和算法描述 (17)二、源程序及注释（打包上传） (18)三、运行输出结果 (18)四、调试和运行程序过程中产生的问题及采取的措施 (19)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (19)实验六排序 (20)一、程序设计的基本思想，原理和算法描述 (20)二、源程序及注释（打包上传） (21)三、运行输出结果 (21)四、调试和运行程序过程中产生的问题及采取的措施 (24)五、对算法的程序的讨论、分析，改进设想，其它经验教训 (24)实验一线性表一、程序设计的基本思想，原理和算法描述：程序的主要分为自定义函数、主函数。
数据结构实验五(二叉树的建立及遍历)题目和源程序
实验5：二叉树的建立及遍历（第十三周星期三7、8节）一、实验目的1．学会实现二叉树结点结构和对二叉树的基本操作。
2．掌握对二叉树每种操作的具体实现，学会利用递归方法编写对二叉树这种递归数据结构进行处理的算法。
二、实验要求1．认真阅读和掌握和本实验相关的教材内容。
2．编写完整程序完成下面的实验内容并上机运行。
3．整理并上交实验报告。
三、实验内容1．编写程序任意输入二叉树的结点个数和结点值，构造一棵二叉树，采用三种递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历并计算出二叉树的高度。
2 .编写程序生成下面所示的二叉树，并采用中序遍历的非递归算法对此二叉树进行遍历。
四、思考与提高1．如何计算二叉链表存储的二叉树中度数为1的结点数？2．已知有—棵以二叉链表存储的二叉树，root指向根结点，p指向二叉树中任一结点，如何求从根结点到p所指结点之间的路径?/*----------------------------------------* 05-1_递归遍历二叉树.cpp -- 递归遍历二叉树的相关操作* 对递归遍历二叉树的每个基本操作都用单独的函数来实现* 水上飘2009年写----------------------------------------*/// ds05.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <iostream>typedef char ElemType;using namespace std;typedef struct BiTNode {ElemType data;//左右孩子指针BiTNode *lchild, *rchild;}BiTNode, *BiTree;//动态输入字符按先序创建二叉树void CreateBiTree(BiTree &T) {char ch;ch = cin.get();if(ch == ' ') {T = NULL;}else {if(ch == '\n') {cout << "输入未结束前不要输入回车，""要结束分支请输入空格！" << endl;}else {//生成根结点T = (BiTNode * )malloc(sizeof(BiTNode));if(!T)cout << "内存分配失败！" << endl;T->data = ch;//构造左子树CreateBiTree(T->lchild);//构造右子树CreateBiTree(T->rchild);}}}//输出e的值ElemType PrintElement(ElemType e) { cout << e << " ";return e;}//先序遍历void PreOrderTraverse(BiTree T) { if (T != NULL) {//打印结点的值PrintElement(T->data);//遍历左孩子PreOrderTraverse(T->lchild);//遍历右孩子PreOrderTraverse(T->rchild);}}//中序遍历void InOrderTraverse(BiTree T) {if (T != NULL) {//遍历左孩子InOrderTraverse(T->lchild);//打印结点的值PrintElement(T->data);//遍历右孩子InOrderTraverse(T->rchild);}}//后序遍历void PostOrderTraverse(BiTree T) { if (T != NULL) {//遍历左孩子PostOrderTraverse(T->lchild);//遍历右孩子PostOrderTraverse(T->rchild);//打印结点的值PrintElement(T->data);}}//按任一种遍历次序输出二叉树中的所有结点void TraverseBiTree(BiTree T, int mark) {if(mark == 1) {//先序遍历PreOrderTraverse(T);cout << endl;}else if(mark == 2) {//中序遍历InOrderTraverse(T);cout << endl;}else if(mark == 3) {//后序遍历PostOrderTraverse(T);cout << endl;}else cout << "选择遍历结束！" << endl;}//输入值并执行选择遍历函数void ChoiceMark(BiTree T) {int mark = 1;cout << "请输入，先序遍历为1，中序为2，后序为3，跳过此操作为0：";cin >> mark;if(mark > 0 && mark < 4) {TraverseBiTree(T, mark);ChoiceMark(T);}else cout << "此操作已跳过！" << endl;}//求二叉树的深度int BiTreeDepth(BiTNode *T) {if (T == NULL) {//对于空树，返回0并结束递归return 0;}else {//计算左子树的深度int dep1 = BiTreeDepth(T->lchild);//计算右子树的深度int dep2 = BiTreeDepth(T->rchild);//返回树的深度if(dep1 > dep2)return dep1 + 1;elsereturn dep2 + 1;}}int _tmain(int argc, _TCHAR* argv[]){BiTNode *bt;bt = NULL; //将树根指针置空cout << "输入规则：" << endl<< "要生成新结点，输入一个字符，""不要生成新结点的左孩子，输入一个空格，""左右孩子都不要，输入两个空格，""要结束，输入多个空格（越多越好）,再回车！"<< endl << "按先序输入：";CreateBiTree(bt);cout << "树的深度为：" << BiTreeDepth(bt) << endl;ChoiceMark(bt);return 0;}/*----------------------------------------* 05-2_构造二叉树.cpp -- 构造二叉树的相关操作* 对构造二叉树的每个基本操作都用单独的函数来实现* 水上飘2009年写----------------------------------------*/// ds05-2.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include <iostream>#define STACK_INIT_SIZE 100 //栈的存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量typedef char ElemType; //元素类型using namespace std;typedef struct BiTNode {ElemType data; //结点值BiTNode *lchild, *rchild; //左右孩子指针}BiTNode, *BiTree;typedef struct {BiTree *base; //在栈构造之前和销毁之后，base的值为空BiTree *top; //栈顶指针int stacksize; //当前已分配的存储空间，以元素为单位}SqStack;//构造一个空栈void InitStack(SqStack &s) {s.base = (BiTree *)malloc(STACK_INIT_SIZE * sizeof(BiTree));if(!s.base)cout << "存储分配失败！" << endl;s.top = s.base;s.stacksize = STACK_INIT_SIZE;}//插入元素e为新的栈顶元素void Push(SqStack &s, BiTree e) {//栈满，追加存储空间if ((s.top - s.base) >= s.stacksize) {s.base = (BiTree *)malloc((STACK_INIT_SIZE+STACKINCREMENT) * sizeof(BiTree));if(!s.base)cout << "存储分配失败！" << endl;s.top = s.base + s.stacksize;s.stacksize += STACK_INIT_SIZE;}*s.top++ = e;}//若栈不空，则删除s的栈顶元素，并返回其值BiTree Pop(SqStack &s) {if(s.top == s.base)cout << "栈为空，无法删除栈顶元素！" << endl;s.top--;return *s.top;}//按先序输入字符创建二叉树void CreateBiTree(BiTree &T) {char ch;//接受输入的字符ch = cin.get();if(ch == ' ') {//分支结束T = NULL;} //if' 'endelse if(ch == '\n') {cout << "输入未结束前不要输入回车，""要结束分支请输入空格！（接着输入）" << endl;} //if'\n'endelse {//生成根结点T = (BiTNode * )malloc(sizeof(BiTree));if(!T)cout << "内存分配失败！" << endl;T->data = ch;//构造左子树CreateBiTree(T->lchild);//构造右子树CreateBiTree(T->rchild);} //Create end}//输出e的值，并返回ElemType PrintElement(ElemType e) {cout << e << " ";return e;}//中序遍历二叉树的非递归函数void InOrderTraverse(BiTree p, SqStack &S) {cout << "中序遍历结果：";while(S.top != S.base || p != NULL) {if(p != NULL) {Push(S,p);p = p->lchild;} //if NULL endelse {BiTree bi = Pop(S);if(!PrintElement(bi->data))cout << "输出其值未成功！" << endl;p = bi->rchild;} //else end} //while endcout << endl;}int _tmain(int argc, _TCHAR* argv[]){BiTNode *bt;SqStack S;InitStack(S);bt = NULL; //将树根指针置空cout << "老师要求的二叉树序列（‘空’表示空格）：""12空空346空空空5空空，再回车！"<< endl << "请按先序输入一个二叉树序列（可另输入，但要为先序），""无左右孩子则分别输入空格。
《数据结构》实验指导书
1.单链表的类型定义
#include <stdio.h>
typedef int ElemType；//单链表结点类型
typedef struct LNode
{ElemType data;
struct LNode *next;
2.明确栈、队列均是特殊的线性表。
3.栈、队列的算法是后续实验的基础（广义表、树、图、查找、排序等）。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验四 串
一、预备知识
1.字符串的基本概念
2.字符串的模式匹配算法
二、实验目的
1.理解字符串的模式匹配算法（包括KMP算法）
typedef struct
{ElemType *base；
int front,rear；
} SqQueue；
4.单链队列的类型定义
typedef struct QNode
{QElemType data;
typedef struct list
{ElemType elem[MAXSIZE];//静态线性表
int length; //顺序表的实际长度
} SqList;//顺序表的类型名
五、注意问题
1.插入、删除时元素的移动原因、方向及先后顺序。
4.三元组表是线性表的一种应用，通过它可以更好地理解线性表的存储结构。同时矩阵又是图的重要的存储方式，所以这个实验对更好地掌握线性表对将来对图的理解都有极大的帮助。
六、实验报告
根据实验情况和结果撰写并递交实验报告。
实验六 树和二叉树
一、预备知识
1.二叉树的二叉链表存储结构
数据结构实验指导书(新版)
《数据结构和算法》实验指导书实验及学时数分配序号实验名称学时数（小时）1 实验一线性表 42 实验二树和二叉树 23 实验三图 24 实验四查找 25 实验五内部排序 2合计12几点要求：一、上机前：认真预习相关实验内容，提前编写算法程序，上机时检查（未提前编写程序者，扣除平时成绩中实验相关分数）。
二、上机中：在Turbo C或VC6.0环境中，认真调试程序，记录调试过程中的问题、解决方法以及运行结果。
上机时签到；下机时验收签字。
三、下机后：按要求完成实验报告，并及时提交（实验后1周内）。
实验一线性表【实验目的】1、掌握用Turbo c上机调试线性表的基本方法；2、掌握线性表的基本操作，插入、删除、查找以及线性表合并等运算在顺序存储结构和链式存储结构上的运算；3、运用线性表解决线性结构问题。
【实验学时】4 学时【实验类型】设计型【实验内容】1、顺序表的插入、删除操作的实现；2、单链表的插入、删除操作的实现；3、两个线性表合并算法的实现。
(选做)【实验原理】1、当我们在线性表的顺序存储结构上的第i个位置上插入一个元素时，必须先将线性表中第i个元素之后的所有元素依次后移一个位置，以便腾出一个位置，再把新元素插入到该位置。
若是欲删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置；2、当我们在线性表的链式存储结构上的第i个位置上插入一个元素时，只需先确定第i个元素前一个元素位置，然后修改相应指针将新元素插入即可。
若是欲删除第i个元素时，也必须先确定第i个元素前一个元素位置，然后修改相应指针将该元素删除即可；3、详细原理请参考教材。
【实验步骤】一、用C语言编程实现建立一个顺序表，并在此表中插入一个元素和删除一个元素。
1、通过键盘读取元素建立线性表；（从键盘接受元素个数n以及n个整形数；按一定格式显示所建立的线性表）2、指定一个元素，在此元素之前插入一个新元素；（从键盘接受插入位置i，和要插入的元素值；实现插入；显示插入后的线性表）3、指定一个元素，删除此元素。
数据结构实验报告-队列的操作
for(i=0 ; i<10; i++)
{
printf(" %d ",j);
EnQueue(S,j); //元素入队列
j++;
}
printf("\n元素出队列");
for(i=0 ; i<10; i++)
{
DeQueue(S,j); //元素出队列
printf(" %d ",j);
}
}
运行结果截图：
1.
四、分析与讨论
对上机实践结果进行分析，上机的心得体会。
五、教师评语
签名：
日期：
成绩
附源程序清单：
1.#include<iostream>
#include<queue>
using namespace std;
void main()
{
queue<char> cque;
char c;
typedef struct {
QElemType *base; // 动态分配存储空间
int front; // 头指针，若队列不空，指向队列头元素
int rear; // 尾指针，若队列不空， //指向队列尾元素 的下一个位置
}SqQueue;
Status InitQueue (SqQueue &Q) { // 构造一个空队列Q
if ((Q.rear+1) % MAXQSIZE == Q.front)
return ERROR; //队列满
Q.base[Q.rear] = e;
数据结构图的实验报告
数据结构图的实验报告数据结构图的实验报告引言：数据结构图是计算机科学中重要的概念之一。
它是一种用图形表示数据元素之间关系的数据结构，广泛应用于算法设计、程序开发和系统优化等领域。
本实验报告旨在介绍数据结构图的基本原理、实验过程和结果分析。
一、实验目的本次实验的主要目的是掌握数据结构图的基本概念和操作方法，以及通过实验验证其在解决实际问题中的有效性。
具体而言，我们将通过构建一个社交网络关系图，实现对用户关系的管理和分析。
二、实验方法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;}。
实验五__线性表的链式表示和实现
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验五线性表的链式表示和实现学生姓名专业班级学号实验成绩指导老师（签名）日期一.实验目的和要求1、了解线性表的链式存储结构，学会定义线性表的链式存储结构。
2、掌握单链表、循环单链表的一些基本操作实现函数。
二.实验内容1、设线性表采用带表头附加结点的单链表存储结构，请编写线性表抽象数据类型各基本操作的实现函数，并存放在头文件LinkList.h中（注：教材上为不带表头附加结点）。
同时建立一个验证操作实现的主函数文件test5.cpp，编译并调试程序，直到正确运行。
提示：⑴单向链表的存储结构可定义如下：struct LNode { // 定义单链表节点类型ElemType data; // 存放结点中的数据信息LNode *next; // 指示下一个结点地址的指针}⑵线性表基本操作可包括如下一些：①void InitList (LNode *&H) //初始化单链表②void ClearList(LNode *&H) //清除单链表③int LengthList (LNode *H) //求单链表长度④bool EmptyList (LNode *H) //判断单链表是否为空表⑤ElemType GetList (LNode *H, int pos)//取单链表第pos 位置上的元素⑥void TraverseList(LNode *H) //遍历单链表⑦bool InsertList ( LNode *&H, ElemType item, int pos)//向单链表插入一个元素⑧bool DeleteList ( LNode *&H, ElemType &item, int pos)//从单链表中删除一个元素⑶带表头附加结点的单链表初始化操作的实现可参考如下：void InitList(LNode *&H){ //构造一个空的线性链表H，即为链表设置一个头结点，//头结点的data数据域不赋任何值，头结点的指针域next则为空H=(LNode *)malloc(sizeof(LNode)); // 产生头结点Hif (!H) exit(0); // 存储分配失败，退出系统H->next=NULL; // 指针域为空}2、选做部分：编写一个函数void MergeList(LNode *&La, LNode *&Lb, LNode *&Lc)，实现将两个有序单链表La和Lb合并成一个新的有序单链表Lc，同时销毁原有单链表La和Lb。
数据结构实验指导书(新版)
《数据结构与算法》实验指导书实验及学时数分配几点要求：一、上机前：认真预习相关实验内容，提前编写算法程序，上机时检查（未提前编写程序者，扣除平时成绩中实验相关分数）。
二、上机中：在Turbo C或VC6.0环境中，认真调试程序，记录调试过程中的问题、解决方法以及运行结果。
上机时签到；下机时验收签字。
三、下机后：按要求完成实验报告，并及时提交（实验后1周内）。
实验一线性表【实验目的】1、掌握用Turbo c上机调试线性表的基本方法；2、掌握线性表的基本操作，插入、删除、查找以及线性表合并等运算在顺序存储结构和链式存储结构上的运算；3、运用线性表解决线性结构问题。
【实验学时】4 学时【实验类型】设计型【实验内容】1、顺序表的插入、删除操作的实现；2、单链表的插入、删除操作的实现；3、两个线性表合并算法的实现。
(选做)【实验原理】1、当我们在线性表的顺序存储结构上的第i个位置上插入一个元素时，必须先将线性表中第i个元素之后的所有元素依次后移一个位置，以便腾出一个位置，再把新元素插入到该位置。
若是欲删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置；2、当我们在线性表的链式存储结构上的第i个位置上插入一个元素时，只需先确定第i个元素前一个元素位置，然后修改相应指针将新元素插入即可。
若是欲删除第i个元素时，也必须先确定第i个元素前一个元素位置，然后修改相应指针将该元素删除即可；3、详细原理请参考教材。
【实验步骤】一、用C语言编程实现建立一个顺序表，并在此表中插入一个元素和删除一个元素。
1、通过键盘读取元素建立线性表；（从键盘接受元素个数n以及n个整形数；按一定格式显示所建立的线性表）2、指定一个元素，在此元素之前插入一个新元素；（从键盘接受插入位置i，和要插入的元素值；实现插入；显示插入后的线性表）3、指定一个元素，删除此元素。
（从键盘接受删除元素位置i，实现删除；显示删除后的线性表）二、用C语言编程实现建立一个单链表，并在此表中插入一个元素和删除一个元素。
数据结构上机实验报告
数据结构实验报告课程数据结构 _ 院系专业班级实验地点姓名学号实验时间指导老师数据结构上机实验报告1一﹑实验名称：实验一——链表二﹑实验目的：1.了解线性表的逻辑结构特性；2.熟悉链表的基本运算在顺序存储结构上的实现，熟练掌握链式存储结构的描述方法；3.掌握链表的基本操作（建表、插入、删除等）4. 掌握循环链表的概念，加深对链表的本质的理解。
5.掌握运用上机调试链表的基本方法三﹑实验内容：（1）创建一个链表（2）在链表中插入元素（3）在链表中删除一个元素（4）销毁链表四﹑实验步骤与程序#include <iostream.h>#include <malloc.h>typedef struct LNode{int data;struct LNode *next;}Lnode, *LinkList;//假设下面的链表均为带头结点。
void CreatLinkList(LinkList &L,int j){//建立一个链表L,数据为整数，数据由键盘随机输入。
LinkList p,q;L=(LinkList )malloc(sizeof(Lnode));L->next=NULL;q=L;cout<<"请输入一个链表："<<endl;for(int i=0;i<j;i++){ p=(LinkList)malloc(sizeof(Lnode));cin>>p->data;p->next=q->next;q->next=p;q=p;}}int PrintLinkList(LinkList &L){//输出链表L的数据元素LinkList p;p=L->next;if(L->next==NULL){cout<<"链表没有元素!"<<endl;return 0;}cout<<"链表的数据元素为:";while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;return 1;}void LinkListLengh(LinkList &L){//计算链表L的数据元素个数。
数据结构课程实验报告
数据结构课程实验报告一、实验目的本次数据结构课程实验的主要目的是通过实践掌握常见数据结构的基本操作，包括线性结构、树形结构和图形结构。
同时，也要求学生能够熟练运用C++语言编写程序，并且能够正确地使用各种算法和数据结构解决具体问题。
二、实验内容本次实验涉及到以下几个方面：1. 线性表：设计一个线性表类，并且实现线性表中元素的插入、删除、查找等基本操作。
2. 栈和队列：设计一个栈类和队列类，并且分别利用这两种数据结构解决具体问题。
3. 二叉树：设计一个二叉树类，并且实现二叉树的遍历（前序遍历、中序遍历和后序遍历）。
4. 图论：设计一个图类，并且利用图论算法解决具体问题（如最短路径问题）。
三、实验过程1. 线性表首先，我们需要设计一个线性表类。
在这个类中，我们需要定义一些成员变量（如线性表大小、元素类型等），并且定义一些成员函数（如插入元素函数、删除元素函数等）。
在编写代码时，我们需要注意一些细节问题，如边界条件、异常处理等。
2. 栈和队列接下来，我们需要设计一个栈类和队列类。
在这两个类中，我们需要定义一些成员变量（如栈顶指针、队头指针等），并且定义一些成员函数（如入栈函数、出栈函数、入队函数、出队函数等）。
在编写代码时，我们需要注意一些细节问题，如空间不足的情况、空栈或空队列的情况等。
3. 二叉树然后，我们需要设计一个二叉树类，并且实现二叉树的遍历。
在这个类中，我们需要定义一个节点结构体，并且定义一些成员变量（如根节点指针、节点数量等），并且定义一些成员函数（如插入节点函数、删除节点函数、遍历函数等）。
在编写代码时，我们需要注意一些细节问题，如递归调用的情况、空节点的情况等。
4. 图论最后，我们需要设计一个图类，并且利用图论算法解决具体问题。
在这个类中，我们需要定义一个邻接矩阵或邻接表来表示图形结构，并且定义一些成员变量（如顶点数量、边的数量等），并且定义一些成员函数（如添加边函数、删除边函数、最短路径算法等）。
数据结构课程实验报告
数据结构课程实验报告数据结构课程实验报告引言：数据结构是计算机科学中非常重要的一门课程，它研究了数据的组织、存储和管理方法。
在数据结构课程中，我们学习了各种数据结构的原理和应用，并通过实验来加深对这些概念的理解。
本文将对我在数据结构课程中的实验进行总结和分析。
实验一：线性表的实现与应用在这个实验中，我们学习了线性表这种基本的数据结构，并实现了线性表的顺序存储和链式存储两种方式。
通过实验，我深刻理解了线性表的插入、删除和查找等操作的实现原理，并掌握了如何根据具体应用场景选择合适的存储方式。
实验二：栈和队列的实现与应用栈和队列是两种常见的数据结构，它们分别具有后进先出和先进先出的特点。
在这个实验中，我们通过实现栈和队列的操作，加深了对它们的理解。
同时，我们还学习了如何利用栈和队列解决实际问题，比如迷宫求解和中缀表达式转后缀表达式等。
实验三：树的实现与应用树是一种重要的非线性数据结构，它具有层次结构和递归定义的特点。
在这个实验中，我们学习了二叉树和二叉搜索树的实现和应用。
通过实验，我掌握了二叉树的遍历方法，了解了二叉搜索树的特性，并学会了如何利用二叉搜索树实现排序算法。
实验四：图的实现与应用图是一种复杂的非线性数据结构，它由节点和边组成，用于表示事物之间的关系。
在这个实验中，我们学习了图的邻接矩阵和邻接表两种存储方式，并实现了图的深度优先搜索和广度优先搜索算法。
通过实验，我深入理解了图的遍历方法和最短路径算法，并学会了如何利用图解决实际问题，比如社交网络分析和地图导航等。
实验五：排序算法的实现与比较排序算法是数据结构中非常重要的一部分，它用于将一组无序的数据按照某种规则进行排列。
在这个实验中，我们实现了常见的排序算法，比如冒泡排序、插入排序、选择排序和快速排序等，并通过实验比较了它们的性能差异。
通过实验，我深入理解了排序算法的原理和实现细节，并了解了如何根据具体情况选择合适的排序算法。
结论：通过这些实验，我对数据结构的原理和应用有了更深入的理解。
数据结构实验报告(实验)
深 圳 大 学 实 验 报 告课程名称： 数据结构实验与课程设计 实验项目名称： 实验一：顺序表的应用 学院： 计算机与软件学院 专业： 指导教师： **报告人： 文成 学号： ********** 班级： 5 实验时间： 2012-9-17实验报告提交时间： 2012-9-24教务部制一、实验目的与要求：目的：1.掌握线性表的基本原理2.掌握线性表地基本结构3.掌握线性表地创建、插入、删除、查找的实现方法要求：1.熟悉C++语言编程2.熟练使用C++语言实现线性表地创建、插入、删除、查找的实现方法二、实验内容：Problem A: 数据结构——实验1——顺序表例程Description实现顺序表的创建、插入、删除、查找Input第一行输入顺序表的实际长度n第二行输入n个数据第三行输入要插入的新数据和插入位置第四行输入要删除的位置第五行输入要查找的位置Output第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开第二行输出执行插入操作后，顺序表内的所有数据，数据之间用空格隔开第三行输出执行删除操作后，顺序表内的所有数据，数据之间用空格隔开第四行输出指定位置的数据Sample Input611 22 33 44 55 66888 352Sample Output11 22 33 44 55 6611 22 888 33 44 55 6611 22 888 33 55 6622HINT第i个位置是指从首个元素开始数起的第i个位置，对应数组内下标为i-1的位置Problem B: 数据结构——实验1——顺序表的数据交换Description实现顺序表内的元素交换操作Input第一行输入n表示顺序表包含的·n个数据第二行输入n个数据，数据是小于100的正整数第三行输入两个参数，表示要交换的两个位置第四行输入两个参数，表示要交换的两个位置Output第一行输出创建后，顺序表内的所有数据，数据之间用空格隔开第二行输出执行第一次交换操作后，顺序表内的所有数据，数据之间用空格隔开第三行输出执行第二次交换操作后，顺序表内的所有数据，数据之间用空格隔开注意加入交换位置的合法性检查，如果发现位置不合法，输出error。
【实验】数据结构实验指导书及答案
【关键字】实验数据结构课程实验指导书数据结构课程组编西南交通大学电气工程学院一、实验教学的目的与基本要求实验目的：用计算机来解决实际问题时，就要涉及到数据的表示及数据的处理，而数据表示及数据处理正是数据结构课程的主要研究对象，通过这两方面内容的学习，为后续课程，特别是软件方面的课程打下了厚实的知识基础，同时也提供了必要的技能训练。
因此，数据结构课程在计算机应用中具有举足轻重的作用。
通过实验实践内容的训练，突出学生程序思维训练和动手上机调试程序的能力, 使学生掌握数据结构的基本原理和编程方法，提高学生组织数据及编写程序的能力。
实验要求：1、实验前要预习：实验前必须认真预习相关的知识，做好充分准备。
2、学生进入实验室，要保持室内整洁和安静。
按照指定的内容进行实验。
3、学生在实验前做好预习，写好算法；实验完毕由教师验收合格后方可离开，并写好实验报告。
4、报告内容包括实验目的、实验内容、程序清单和实验结果等。
要求书写文字整齐简洁。
5、实验过程中要注意人身和设备安全，遇到事故或出现异常现象，应立即切断电源，保持现场并报告指导教师处理。
二、实验报告要求、实验考核方式、内容及成绩评定标准实验报告要求内容清晰完整，写出实验结果。
实验考核方式依据实验报告完成情况和实验上机情况综合考核。
根据实验报告和实验课出席情况给出实验成绩,满分10分。
三、实验教材及参考书《数据结构》严蔚敏清华大学出版社 2005实验一熟悉开发环境和抽象数据类型一．实验目的1．熟悉VC软件开发环境。
2．熟悉抽象数据类型的定义与应用。
二．实验内容1.在VC下编写程序，实现求出从键盘输入的两个数的最大值。
例如，从键盘输入a=4,b=5。
得出结果c = 52.在VC下编写程序，实现求出两个复数的和。
定义复数的数据类型，复数由实部和虚部构成。
复数的和是两个复数的实部和虚部分别求和得出。
其中的两个复数分别从键盘输入，例如，输入3, 4表示复数Z1：3+4i; 输入1, 2表示复数Z2：1+2i。
数据结构实验报告五—四则运算表达式求值
问题描述：四则运算表达式求值，将四则运算表达式用中缀表达式，然后转换为后缀表达式，并计算结果。
一、需求分析：1、本程序是利用二叉树后序遍历来实现表达式的转换，同时可以使用实验三的结果来求解后缀表达式的值。
2、输入输出格式：输入格式：在字符界面上输入一个中缀表达式，回车表示结束。
请输入表达式：输入一个中缀表达式输出格式：如果该中缀表达式正确，那么在字符界面上输出其后缀表达式，其中后缀表达式中两相邻操作数之间利用空格隔开；如果不正确，在字符界面上输出表达式错误提示。
逆波兰表达式为：输出逆波兰表达式运算结果为：输出运算后的结果3、测试用例输入：21+23*（12-6）输出：21 23 12 6 -*+二、概要设计：抽象数据类型二叉树类BiTree算法的基本思想根据题目要求，利用栈计算，和二叉树存储，来计算表达式该算法的基本思想是：先利用栈进行计算，然后用二叉树进行存储，和实验三算法一样来计算逆波兰表达式的值程序的流程程序由三个模块组成：（1）输入模块：输入一个运算式（2）计算模块：利用栈进行表达式的计算，二叉树来存储。
（3 ）输出模块：屏幕上显示出后缀表达式和运算结果。
三、详细设计物理数据类型程序含有两个类，其中栈不再赘述，另一个类为二叉树class BiTree 包含私有成员struct BiTreeNode，根节点BiTreeNode *T;索引index; int number_of_point 优先级比较函数 compare(char a,char b);生成树的函数void InorderCreate(BiTreeNode *&T,char str[30][10],int start,int end);判断数字函数bool IsNumber(char a);求值函数double Operate(BiTreeNode *T);还有显示后缀表达式的函数void display(BiTreeNode *T) ;而公有成员函数则是对私有函数的重载，为方便使用，因为函数中普遍使用了递归的算法。
数据结构专题实验
上机实验要求及规范《数据结构》课程具有比较强的理论性，同时也具有较强的可应用性和实践性，因此上机实验是一个重要的教学环节。
一般情况下学生能够重视实验环节，对于编写程序上机练习具有一定的积极性，但是容易忽略实验的总结，忽略实验报告的撰写。
对于一名大学生必须严格训练分析总结能力、书面表达能力。
需要逐步培养书写科学实验报告以及科技论文的能力。
拿到一个题目，一般不要急于编程，而是应该按照面向过程的程序设计思路（关于面向对象的训练将在其它后继课程中进行），首先理解问题，明确给定的条件和要求解决的问题，然后按照自顶向下，逐步求精，分而治之的策略，逐一地解决子问题。
具体步骤如下：1.问题分析与系统结构设计充分地分析和理解问题本身，弄清要求做什么（而不是怎么做），限制条件是什么。
按照以数据结构为中心的原则划分模块，搞清数据的逻辑结构（是线性表还是树、图？），确定数据的存储结构（是顺序结构还是链表结构？），然后设计有关操作的函数。
在每个函数模块中，要综合考虑系统功能，使系统结构清晰、合理、简单和易于调试。
最后写出每个模块的算法头和规格说明，列出模块之间的调用关系（可以用图表示），便完成了系统结构设计。
2.详细设计和编码详细设计是对函数（模块）的进一步求精，用伪高级语言（如类C语言）或自然语言写出算法框架，这时不必确定很多结构和变量。
编码，即程序设计，是对详细设计结果的进一步求精，即用某种高级语言（如C/C++语言）表达出来。
尽量多设一些注释语句，清晰易懂。
尽量临时增加一些输出语句，便于差错矫正，在程序成功后再删去它们。
3.上机准备熟悉高级语言用法，如C语言。
熟悉机器（即操作系统），基本的常用命令。
静态检查主要有两条路径，一是用一组测试数据手工执行程序（或分模块进行）；二是通过阅读或给别人讲解自己的程序而深入全面地理解程序逻辑，在这个过程中再加入一些注释和断言。
如果程序中逻辑概念清楚，后者将比前者有效。
4.上机调试程序调试最好分块进行，自底向上，即先调试底层函数，必要时可以另写一个调用驱动程序，表面上的麻烦工作可以大大降低调试时所面临的复杂性，提高工作效率。
(完整版)数据结构实验报告全集
数据结构实验报告全集实验一线性表基本操作和简单程序1．实验目的（1）掌握使用Visual C++ 6.0上机调试程序的基本方法；（2）掌握线性表的基本操作：初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。
2．实验要求（1）认真阅读和掌握和本实验相关的教材内容。
（2）认真阅读和掌握本章相关内容的程序。
（3）上机运行程序。
（4）保存和打印出程序的运行结果，并结合程序进行分析。
（5）按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果实验代码：1）头文件模块#include iostream.h>//头文件#include<malloc.h>//库头文件-----动态分配内存空间typedef int elemtype;//定义数据域的类型typedef struct linknode//定义结点类型{elemtype data;//定义数据域struct linknode *next;//定义结点指针}nodetype;2）创建单链表nodetype *create()//建立单链表，由用户输入各结点data域之值，//以0表示输入结束{elemtype d;//定义数据元素dnodetype *h=NULL,*s,*t;//定义结点指针int i=1;cout<<"建立一个单链表"<<endl;while(1){cout <<" 输入第"<< i <<"结点data域值：";cin >> d;if(d==0) break;//以0表示输入结束if(i==1)//建立第一个结点{h=(nodetype*)malloc(sizeof(nodetype));//表示指针hh->data=d;h->next=NULL;t=h;//h是头指针}else//建立其余结点{s=(nodetype*) malloc(sizeof(nodetype));s->data=d;s->next=NULL;t->next=s;t=s;//t始终指向生成的单链表的最后一个节点}i++;}return h;}3）输出单链表中的元素void disp(nodetype*h)//输出由h指向的单链表的所有data域之值{nodetype *p=h;cout<<"输出一个单链表:"<<endl<<" ";if(p==NULL)cout<<"空表";while(p!=NULL){cout<<p->data<<" ";p=p->next;}cout<<endl;}4）计算单链表的长度int len(nodetype *h)//返回单链表的长度{int i=0;nodetype *p=h;while(p!=NULL){p=p->next;i++;}return i;}5）寻找第i个节点nodetype *find(nodetype *h,int i)//返回第i个节点的指针{nodetype *p=h;int j=1;if(i>len(h)||i<=0)return NULL;//i上溢或下溢celse{while (p!=NULL&&j<1)//查找第i个节点，并由p指向该节点{j++;p=p->next;}return p;} }6）单链表的插入操作nodetype *ins(nodetype *h,int i,elemtype x)//在单链表head中第i个节点//（i>=0）之后插入一个data域为x的节点{nodetype *p,*s;s=(nodetype*)malloc(sizeof(nodetype));//创建节点ss->data=x;s->next=NULL;if(i==0)//i=0:s作为该单链表的第一个节点{s->next=h;h=s;}else{p=find(h,i);//查找第i个节点，并由p指向该节点if(p!=NULL){s->next=p->next;p->next=s;}return h;}}7）单链表的删除操作nodetype *del(nodetype *h,int i)//删除第i个节点{nodetype *p=h, *s;int j=1;if(i==1)//删除第1个节点{h=h->next;free(p);}else{p=find(h,i-1);//查找第i-1个节点，并由p指向该节点 if(p!=NULL&&p->next!=NULL){s=p->next;//s指向要删除的节点p->next=s->next;free(s);}else cout<<"输入i的值不正确"<<endl;}return h;}8）释放节点空间void dispose(nodetype *h)//释放单链表的所有节点占用的空间{nodetype *pa=h,*pb;if(pa!=NULL){pb=pa->next;if(pb==NULL)//只有一个节点的情况free(pa);else{while (pb!=NULL)//有两个及以上节点的情况{free(pa);pa=pb;pb=pb->next;}free(pa);}}}9)主程序模块:#include"slink.h"//包含头文件slinkvoid main(){nodetype *head;//定义节点指针变量head=create();//创建一个单链表disp(head);//输出单链表cout<<"单链表长度:"<<len(head)<<endl;ins(head, 2,0);//在第二个节点之后插入以0为元素的节点 disp(head);//输出新链表del(head,2);//删除第二个节点disp(head);//输出新链表}5．实验结果建立一个单链表：输入第1结点data域值：1输入第2结点data域值：2输入第3结点data域值：3输入第4结点data域值：4输入第5结点data域值：5输入第6结点data域值：6输入第7结点data域值：7输入第8结点data域值：8输入第9结点data域值：9输入第10结点data域值0：输出一个单链表：1 2 3 4 5 6 7 8 9单链表长度：9输出一个单链表：1 02345678 9输出一个单链表：1 2 3 4 5 6 7 8实验二顺序栈的实现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个位置。
数据结构实验任务书(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中添加相应语句进行测试。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.实验步骤：先定义顺序表的结点：typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SqList;然后定义一个随机取数的函数，存到顺序表中：void CreateList(SqList &L,int n)然后定义一个显示顺序表的函数，将顺序表中的数据显示出来：void ListTraverse(SqList L)然后通过排序函数，将所有的数据按照从大到小的顺序排列：void BubbleSort(SqList &L)实验结果：测试数据：38 86 9 88 29 18 58 27排序后：9 18 27 29 38 58 86 88BubbleSort排序方法中数据的比较次数为：27疑难小结：这个程序的难点在于排序函数，总是把从第几个数开始排序以及怎样循环弄错。
源代码：#include<iostream>using namespace std;#include<time.h>typedef int KeyType;typedef char * InfoType;typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SqList;int CmpNum;void CreateList(SqList &L,int n){int i;L.R=new ElemType[n+1];srand(time(0));for(i=1;i<=n;i++){L.R[i].key=rand()%100;}L.length=n;}void ListTraverse(SqList L){int i;for(i=1;i<=L.length;i++)cout<<L.R[i].key<<'\t';cout<<endl;}void BubbleSort(SqList &L){int m,flag,i;m=L.length-1;flag=1;while(m>0&&flag){flag=0;for(i=1;i<=m;i++){CmpNum++;if(L.R[i].key>L.R[i+1].key){flag=1;L.R[0]=L.R[i+1];L.R[i+1]=L.R[i];L.R[i]=L.R[0];}}m--;}}void main(){SqList L;CreateList(L,8);cout<<"测试数据："<<endl;ListTraverse(L);BubbleSort(L);cout<<"排序后："<<endl;ListTraverse(L);cout<<"BubbleSort排序方法中数据的比较次数为："<<CmpNum<<endl; }2实验步骤：先声明一个结点：typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SqList;然后建立一个建表函数：void CreateList(SqList &L)，将十个关键字输入到表中。
建立一个遍历函数void ListTraverse(SqList L)用以显示排序前后的数据。
分别建立四个排序方法：（1）直接插入排序：void InsertSort(SqList &L)（2）折半插入排序void InsertSort(SqList &L)（3）希尔排序：void ShellSort(SqList &L , int dt[] , int t) void ShellInsert(SqList &L , int dk)（4）快速排序：int Partition(SqList &L , int low, int high) void QSort(SqList &L , int low, int high) void QuickSort(SqList &L)实验结果：测试数据：1. 增量为2 ，该算法执行3趟测试数据：12 2 16 30 28 10 16 20 6 18排序后：2 6 10 12 16 16 18 20 28 30该算法比较的次数为：21 次Process returned 0 (0x0) execution time : 0.203 sPress any key to continue.2.测试数据：12 2 16 30 28 10 16 20 6 18排序后：2 6 10 12 16 16 18 20 28 30Process returned 0 (0x0) execution time : 0.016 sPress any key to continue.3.疑难小结，我感觉，希尔排序，和快速排序很难理解。
尤其是快速排序，枢轴换来换去，感觉很乱。
源代码：#include<iostream>using namespace std;int a = 0;typedef int KeyType;typedef char * InfoType;typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SqList;void CreateList(SqList &L){L.R=new ElemType[11];L.R[1].key=12;L.R[2].key=2;L.R[3].key=16;L.R[4].key=30;L.R[5].key=28;L.R[6].key=10;L.R[7].key=16;L.R[8].key=20;L.R[9].key=6;L.R[10].key=18;}void ListTraverse(SqList L){int i;for(i=1;i<=10;i++)cout<<L.R[i].key<<'\t';cout<<endl;}void InsertSort(SqList &L){int i,j;for( i=2;i<10;++i){if(L.R[i].key<L.R[i-1].key){L.R[0] = L.R[i];L.R[i] = L.R[i-1];for(j=i-2;L.R[0].key<L.R[j].key;--j) L.R[j+1] = L.R[j];L.R[j+1] = L.R[0];}a++;}}int main(){SqList L;CreateList(L);cout<<"测试数据："<<endl;ListTraverse(L);InsertSort(L);cout<<"排序后："<<endl;ListTraverse(L);cout<<"该算法比较的次数为："<<a <<" 次"<<endl;return 0;}//============================================ #include<iostream>using namespace std;int a = 0;typedef int KeyType;typedef char * InfoType;typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SqList;void CreateList(SqList &L){L.R=new ElemType[11];L.R[1].key=12;L.R[2].key=2;L.R[3].key=16;L.R[4].key=30;L.R[5].key=28;L.R[6].key=10;L.R[7].key=16;L.R[8].key=20;L.R[9].key=6;L.R[10].key=18;}void ListTraverse(SqList L){int i;for(i=1;i<=10;i++)cout<<L.R[i].key<<'\t';cout<<endl;}void InsertSort(SqList &L){int i , j , high, low , m;for( i =2 ; i<=10 ; i++){L.R[0] = L.R[i];low=1 , high=i-1;while(low<=high){m=(low+high)/2;if(L.R[0].key<L.R[m].key)high = m-1;else low = m+1;}for(j=i-1 ; j>=high+1;j--)L.R[j+1] = L.R[j];L.R[high+1]=L.R[0];a++;}}int main(){SqList L;CreateList(L);cout<<"测试数据："<<endl;ListTraverse(L);InsertSort(L);cout<<"排序后："<<endl;ListTraverse(L);cout<<"该算法比较的次数为："<<a <<" 次"<<endl;return 0;}//==================================================#include<iostream>using namespace std;int a = 0;typedef int KeyType;typedef char * InfoType;typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SqList;void CreateList(SqList &L){L.R=new ElemType[11];L.R[1].key=12;L.R[2].key=2;L.R[3].key=16;L.R[4].key=30;L.R[5].key=28;L.R[6].key=10;L.R[7].key=16;L.R[8].key=20;L.R[9].key=6;L.R[10].key=18;}void ListTraverse(SqList L){int i;for(i=1;i<=10;i++)cout<<L.R[i].key<<'\t';cout<<endl;}void ShellInsert(SqList &L , int dk){int i,j;for(i = dk+1 ; i<=10 ; ++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];}a++;}}void ShellSort(SqList &L , int dt[] , int t){int k;for(k = 0 ; k<t ; ++k){ShellInsert(L,dt[k]);}}int main(){SqList L;int t;int dt[3]={5,3,1};t=3;cout << "增量为2 ，该算法执行3趟"<<endl<<endl;CreateList(L);cout<<"测试数据："<<endl;ListTraverse(L);ShellSort(L,dt,t);cout<<"排序后："<<endl;ListTraverse(L);cout<<"该算法比较的次数为："<<a <<" 次"<<endl;return 0;}//============================================== #include<iostream>using namespace std;int a = 0;typedef int KeyType; typedef char * InfoType; typedef struct{KeyType key;InfoType otherinfo; }ElemType;typedef struct{ElemType *R;int length;}SqList;void CreateList(SqList &L) {L.R=new ElemType[11]; L.R[1].key=12;L.R[2].key=2;L.R[3].key=16;L.R[4].key=30;L.R[5].key=28;L.R[6].key=10;L.R[7].key=16;L.R[8].key=20;L.R[9].key=6;L.R[10].key=18;}void ListTraverse(SqList L){int i;for(i=1;i<=10;i++)cout<<L.R[i].key<<'\t';cout<<endl;}int Partition(SqList &L , int low, int high){KeyType pivotkey;L.R[0] = L.R[low];pivotkey = L.R[low].key;while(low<high){while(low<high && L.R[high].key>pivotkey) --high; L.R[low] = L.R[high];while(low<high && L.R[low].key<=pivotkey) ++low; L.R[high]=L.R[low];}L.R[low] = L.R[0];return low;}void QSort(SqList &L , int low, int high){KeyType pivotloc;if(low<high){pivotloc = Partition(L,low,high);QSort(L, low ,pivotloc-1);QSort(L,pivotloc+1,high);}}void QuickSort(SqList &L){QSort(L,1,L.length);}int main(){SqList L;L.length = 10;CreateList(L);cout<<"²âÊÔÊý¾Ý£º"<<endl;ListTraverse(L);QuickSort(L);cout<<"ÅÅÐòºó£º"<<endl;ListTraverse(L);return 0;}。