北京邮电大学数据结构第二次实验车厢重排实验报告
北邮数据结构实验报告
北邮数据结构实验报告摘要：本报告基于北邮数据结构实验，通过实际操作和实验结果的分析，总结和讨论了各实验的目的、实验过程、实验结果以及相关的问题和解决方法。
本报告旨在帮助读者了解数据结构实验的基本原理和应用，并为今后的学习和研究提供参考。
1. 实验一：线性表的操作1.1 实验目的本实验旨在掌握线性表的基本操作以及对应的算法实现，包括插入、删除、查找、修改等。
1.2 实验过程我们使用C++语言编写了线性表的相关算法，并在实际编程环境下进行了测试。
通过插入元素、删除元素、查找元素和修改元素的操作，验证了算法的正确性和效率。
1.3 实验结果经过测试，我们发现线性表的插入和删除操作的时间复杂度为O(n)，查找操作的时间复杂度为O(n)，修改操作的时间复杂度为O(1)。
这些结果与预期相符，并反映了线性表的基本特性。
1.4 问题与解决方法在实验过程中，我们遇到了一些问题，例如插入操作的边界条件判断、删除操作时的内存释放等。
通过仔细分析问题，我们优化了算法的实现，并解决了这些问题。
2. 实验二：栈和队列的应用2.1 实验目的本实验旨在掌握栈和队列的基本原理、操作和应用，并进行实际编程实现。
2.2 实验过程我们使用C++语言编写了栈和队列的相关算法，并在实际编程环境下进行了测试。
通过栈的应用实现表达式求值和逆波兰表达式的计算，以及队列的应用实现图的广度优先遍历，验证了算法的正确性和效率。
2.3 实验结果经过测试，我们发现栈的应用可以实现表达式的求值和逆波兰表达式的计算，队列的应用可以实现图的广度优先遍历。
这些结果证明了栈和队列在实际应用中的重要性和有效性。
2.4 问题与解决方法在实验过程中，我们遇到了一些问题，例如中缀表达式转后缀表达式的算法设计、表达式求值的优化等。
通过查阅资料和与同学的讨论，我们解决了这些问题，并完善了算法的实现。
3. 实验三：串的模式匹配3.1 实验目的本实验旨在掌握串的基本操作和模式匹配算法，并进行实际编程实现。
实验2用堆栈解决火车车厢重排问题的编程
实验2用堆栈解决火车车厢重排问题的编程一、目的通过对本次实验，我们应：1、加深对线性表、堆栈的认识；2、加深接口、类、索引器的认识；3、掌握堆栈数据结构，并应用堆栈编程解决实际问题。
二、实验准备1、软件准备：C#.net。
2、参考数据（示例）：文件夹“…\实验2\示例”中的数据。
三、实验背景描述1、问题描述一列货运列车共有n节车厢，每节车厢将停放在不同的车站。
假定n个车站的编号分别为1 -n，货运列车按照第n站至第1站的次序经过这些车站。
车厢的编号与它们的目的地相同。
为了便于从列车上卸掉相应的车厢，必须重新排列车厢，使各车厢从前至后按编号1到n的次序排列。
当所有的车厢都按照这种次序排列时，在每个车站只需卸掉最后一节车厢即可。
我们在一个转轨站里完成车厢的重排工作，在转轨站中有一个入轨、一个出轨和k个缓冲铁轨（位于入轨和出轨之间）。
图3.1a 给出了一个转轨站，其中有k= 3个缓冲铁轨H1，H2和H3。
开始时，n节车厢的货车从入轨处进入转轨站，转轨结束时各车厢从右到左按照编号1至编号n的次序离开转轨站（通过出轨处）。
在图3.1a 中，n= 9，车厢从后至前的初始次序为5，8，1，7，4，2，9，6，3。
图3.1b 给出了按所要求的次序重新排列后的结果。
图2.1根据上面的描述，编写程序实现下面的功能：编写一算法实现火车车箱的重排；编写程序模拟图2.1所示的具有9节车厢的火车入轨和出轨的过程。
程序主界面设计如图2.2所示。
图2.22、问题分析为了重排车厢，需从前至后依次检查入轨上的所有车厢。
如果正在检查的车厢就是下一个满足排列要求的车厢，可以直接把它放到出轨上去。
如果不是，则把它移动到缓冲铁轨上，直到按输出次序要求轮到它时才将它放到出轨上。
缓冲铁轨上车厢的进和出只能在缓冲铁轨的尾部进行。
当缓冲铁轨上的车厢编号不是按照从顶到底的递增次序排列时，重排任务将无法完成。
新的车厢u应送入这样的缓冲铁轨：其底部的车厢编号v满足v>u,且v是所有满足这种条件的缓冲铁轨顶部车厢编号中最小的一个编号。
火车车厢重排问题,队列,c语言
3.顺序输这个序列
4.如果输入的车厢数有误的时候（为负数或零）
5.如果输入的序列不是连续自然数
五、实验总结
先后学习了 C/C++,对编程语言基本上有一些了解，但在数据结构试验程序 设计过程中还是学到了很多。
经过两天的设计，在不断翻阅以前资料的情况下，有针对性的复习了 C/C++ 中指针、循环的相关理论知识和的基础知识和应用技巧，最后比较成功的完成 了本次的设计。 这次的实验是完成火车厢重徘问题，依旧采用的检查用户的错误输入机制，充 分考虑了用户的各种错误，比如输入的序列不是连续自然数，如果输入的车厢 数有误的时候（为负数或零）等等的情况，完成了该次实验，主要出现的问题 在于数组的下标问题，老是出现越界访问错误等等，这要在下次的实验当中多 加注意！
return q->data[q->front+1]; }
int getrear(squeue *&q) {
{ return q->data[q->rear];
} }
void reset(squeue *&q,squeue *&w1,squeue *&w2,int k) {
int nowout=1; int n1=0,n2=0; for(int i=0;i<50;i++) {
出轨
H1
1
入轨
H3
出轨
H2 (d) 将 6789 移至出轨
火车车厢重排算法伪代码如下：
1. 分别对k个队列初始化； 2. 初始化下一个要输出的车厢编号nowOut = 1; 3. 依次取入轨中的每一个车厢的编号；
如果入轨中的车厢编号等于nowOut，则 输出该车厢； nowOut++；
北邮计算机系统结构实验报告
高级计算机系统结构实验报告实验二指令流水线相关性分析实验三DLX处理器程序设计实验四代码优化实验五循环展开专业计算机科学与技术班级2015姓名学号2015实验二指令流水线相关性分析1. 实验目的：通过使用WINDLX模拟器，对程序中的三种相关现象进行观察，并对使用专用通路，增加运算部件等技术对性能的影响进行考察，加深对流水线和RISC处理器的特点的理解。
2. 实验设备环境：2.1 WinDLX模拟器可以装入DLX汇编语言程序，然后单步、设置断点或者连续执行该程序；2.2 CPU的寄存器、流水线、I/O和存储器都可以使用图形的方式表示出来；2.3 模拟器还提供了对流水线操作的统计功能；2.4 该模拟器对理解流水线和RISC处理器的特点很有帮助；2.5 所有浮点运算部件的延时都设定为4个周期；3. 实验原理：指令流水线中主要有结构相关、数据相关、控制相关。
相关影响流水线性能。
3.1数据相关定义：原有先后顺序的两条指令（I1，I2)在对共享变量（位置）进行读、写时，指令流水线中实际完成的读、写顺序与原有顺序不一致，导致流水线输出错误。
三类数据相关：写读(WR)相关读写(RW)相关写写(WW)相关解决方法技术：1.使某些流水线指令延迟、停顿一或多个周期。
2.双端口存储器:如果指令和数据放在同一个存储器。
3.设置两个存储器：一个数据存储，一个为指令存储器。
4.软件优化编译：通过指令重新排序，消除数据相关。
5.定向技术：又称旁路技术或专用通路技术，是使后续指令提前得到前指令的运算结果(适合ALU类指令）3.2结构相关定义：如果某指令在流水线重叠执行过程中，硬件资源满足不了指令重叠执行的要求，会产生资源冲突或竞争，称为流水线结构相关解决方法技术：1.延迟技术：使某些指令延迟、停顿一或多个时钟周期2.双端口存储器：允许同时读两个数据或指令3.设置双存储器（哈弗结构）：一个数据存储，一个指令存储。
4软件优化编译：通过指令重新排序消除结构相关。
北邮信通院数据结构实验二--八皇后问题实验报告(内附源代码完整版)
2.1存储结构
存储结构：栈（递归）
2.2关键算法分析
递归调用摆放皇后
1、关键算法伪代码：
（1）.如果输入的row大于皇后的数量，则输出皇后的位置
（2）否则col从0开始递增
(3)检测（row，col）上的点是否符合条件，不符合则col自增，符合则转到下一个皇后的排列
2、代码详细分析：
void SeqStack::PlaceQueen(int row) //摆放皇后
{
for (int col=0;col< n;col++) //遍历0~7，
{
Push(col);
if (Check()) //判断摆放皇后的位置是否合适
{
if (row< n-1) //若还没有放到最后一个，则进行下一个皇后的放置
PlaceQueen(row+1);
else
{
num++; //计数器加1
{
if(top>= m-1) throw "上溢";
top++; //栈顶指针上移
data[top]=x;
}
void SeqStack::Pop() //出栈操作
{
if(Empty()) throw "下溢";
top--; //栈顶指针下移
}
void SeqStack::PlaceQue计放置八皇后，只要修改输入的N，便可显示其他情况的结果。
Print(n); //打印成功的坐标点
}
}
Pop(); //若不符合条件则出栈
}
}
bool SeqStack::Empty()
北邮 数据结构实验报告2
数据结构实验报告实验名称：__ 哈夫曼树________学生姓名：______ 蔡宇豪_________________班级：________ 2 5____________________ 班内序号：__________15__________________学号：_________2012210673___________________ 日期：________2013.11.24____________________2. 程序分析2.1 存储结构哈夫曼树结点的存储结构包括双亲域parent，左子树lchild，右子树rchild，还有字符word，权重weight，编码code对用户输入的信息进行统计，将每个字符作为哈夫曼树的叶子结点。
统计每个字符出现的次数作为叶子的权重，统计次数可以根据每个字符不同的ASCII码，根据叶子结点的权重建立一个哈夫曼树2.2 关键算法分析要实现哈夫曼解/编码器，就必须用二叉树结构建立起哈夫曼树，其中有4个关键算法，首先是初始化函数，统计每个字符的频度，并建立起哈夫曼树；然后是建立编码表，将每个字符的编码输出；再次就是编码算法，根据编码表对输入的字符串进行编码，并将编码后的字符串输出；最后是译码算法，利用已经建好的赫夫曼树对编码后的字符串进行译码，并输出译码结果。
1.初始化函数int i,j;for(i=0;i<MAX;i++)a[i]=0; //先将a[]数组中每个值都赋为，不然程序会运行出错？for(i=0;s[i]!='\0';i++) //'\0'字符串结束标志{for(j=0;j<n;j++){if(s[i]==b[j]) //判断该字符是否已经出现过break;}if(j<n) //该字符出现过，对应计数器加一a[j]++;else//该字符为新字符,上面的循环全部运行完毕，j=n，记录到b[j]中，对应计数器加一{b[j]=s[i];a[j]++;n++; //出现的字符种类数加一}}//cout<<"共有"<<n<<"种字符，分别为:"<<endl;for(i=0;i<n;i++)cout<<b[i]<<"出现次数为:"<<a[i]<<endl;HTree=new HNode[2*n-1] ; //哈夫曼树初始化for(int i=0;i<2*n-1;i++){if(i<n){HTree[i].weight=a[i];}else{HTree[i].weight=0;}HTree[i].LChild=-1;HTree[i].RChild=-1;HTree[i].parent=-1;}int x,y,m1,m2; //x,y用于存放权值最小结点在数组中的下标for(int i=n;i<2*n-1;i++) //开始建哈夫曼树{//找出权值最小的结点m1=m2=MAX; //MAX=1000x=y=0;for(int j=0;j<i;j++){if(HTree[j].weight<m1&&HTree[j].parent==-1){m2=m1;m1=HTree[j].weight;x=j;}else if(HTree[j].weight < m2 && HTree[j].parent==-1){m2=HTree[j].weight;y=j;}}HTree[x].parent=HTree[y].parent=i;HTree[i].weight=HTree[x].weight+HTree[y].weight;HTree[i].LChild=x;HTree[i].RChild=y;HTree[i].parent=-1;2.生成编码表HCodeTable=new HCode[n];for(int i=0;i<n;i++){HCodeTable[i].data=b[i];int child=i;int parent=HTree[i].parent;int k=0;while(parent!=-1){if(child==HTree[parent].LChild)HCodeTable[i].code[k]='0';elseHCodeTable[i].code[k]='1';k++;child=parent;parent=HTree[child].parent;}HCodeTable[i].code[k]='\0';cout<<b[i]<<"的编码:";for(int j=k-1;j>=0;j--)cout<<HCodeTable[i].code[j];cout<<endl;}3.编码cout<<"编码后的字符串为:";while(*d!='\0'){for(int i=0;i<n;i++){if(b[i]==*d) //判断，每当出现一种时，就找到对应编码并输出{int k=strlen(HCodeTable[i].code);for(int j=k-1;j>=0;j--){*s=HCodeTable[i].code[j];cout<<*s;s++;}}}d++;}*s='\0';cout<<endl;【计算关键算法的时间、空间复杂度】关键算法A的时间复杂度为O(n)，关键算法B的时间复杂度为O(n),关键算法C的时间复杂度为O(n)，关键算法D的时间复杂度为O(n).2.3 其他程序完整代码：#include<iostream>using namespace std;const int MAX=1000;struct HNode{int weight;int parent;int LChild;int RChild;};struct HCode{char data;char code[200];};class Huffman{private:HNode *HTree; //哈夫曼树HCode *HCodeTable; //哈夫曼编码表char b[MAX]; //记录出现的字符int a[MAX]; //记录每个字符出现的次数，即权值static int n; //字符的种类数(静态变量)public:void init(char s[]); //初始化void init1(char s[]);void CreateCodeTable(); //创建编码表void Encoding(char *s,char *d); //编码void Decoding(char *s,char *d); //解码int count1() //算编码前长度{int q1=0;for(int i=0;i<n;i++){q1+=8*a[i];}return q1;}int count2() //算编码后长度{int q2=0;for(int i=0;i<n;i++){q2+=strlen(HCodeTable[i].code)*a[i];}return q2;}};int Huffman::n=0;void Huffman::init(char s[]){int i,j;for(i=0;i<MAX;i++)a[i]=0; //先将a[]数组中每个值都赋为，不然程序会运行出错？for(i=0;s[i]!='\0';i++) //'\0'字符串结束标志{for(j=0;j<n;j++){if(s[i]==b[j]) //判断该字符是否已经出现过break;}if(j<n) //该字符出现过，对应计数器加一a[j]++;else//该字符为新字符,上面的循环全部运行完毕，j=n，记录到b[j]中，对应计数器加一{b[j]=s[i];a[j]++;n++; //出现的字符种类数加一}}//cout<<"共有"<<n<<"种字符，分别为:"<<endl;for(i=0;i<n;i++)cout<<b[i]<<"出现次数为:"<<a[i]<<endl;HTree=new HNode[2*n-1] ; //哈夫曼树初始化for(int q=0;q<2*n-1;q++){if(q<n){HTree[q].weight=a[q];}else{HTree[q].weight=0;}HTree[q].LChild=-1;HTree[q].RChild=-1;HTree[q].parent=-1;}int x,y,m1,m2; //x,y用于存放权值最小结点在数组中的下标for(int w=n;w<2*n-1;w++) //开始建哈夫曼树{//找出权值最小的结点m1=m2=MAX; //MAX=1000x=y=0;for(int j=0;j<i;j++){if(HTree[j].weight<m1&&HTree[j].parent==-1){m2=m1;m1=HTree[j].weight;x=j;}else if(HTree[j].weight < m2 && HTree[j].parent==-1){m2=HTree[j].weight;y=j;}}HTree[x].parent=HTree[y].parent=w;HTree[w].weight=HTree[x].weight+HTree[y].weight;HTree[w].LChild=x;HTree[w].RChild=y;HTree[w].parent=-1;}}void Huffman::init1(char s[]){int i,j;for(i=0;i<MAX;i++)a[i]=0; //先将a[]数组中每个值都赋为，不然程序会运行出错？for(i=0;s[i]!='\0';i++) //'\0'字符串结束标志{for(j=0;j<n;j++){if(s[i]==b[j]) //判断该字符是否已经出现过break;}if(j<n) //该字符出现过，对应计数器加一a[j]++;else//该字符为新字符,上面的循环全部运行完毕，j=n，记录到b[j]中，对应计数器加一{b[j]=s[i];a[j]++;n++; //出现的字符种类数加一}}HTree=new HNode[2*n-1] ; //哈夫曼树初始化for(int e=0;e<2*n-1;e++){if(e<n){HTree[e].weight=a[e];}else{HTree[e].weight=0;}HTree[e].LChild=-1;HTree[e].RChild=-1;HTree[e].parent=-1;}int x,y,m1,m2; //x,y用于存放权值最小结点在数组中的下标，m1,m2用于存放两个无父结点且结点权值最小的两个结点for(int r=n;r<2*n-1;r++) //开始建哈夫曼树{//找出权值最小的结点m1=m2=MAX; //MAX=1000x=y=0;for(int j=0;j<r;j++){if(HTree[j].weight<m1&&HTree[j].parent==-1){m2=m1;//y=x;m1=HTree[j].weight;x=j;}else if(HTree[j].weight < m2 && HTree[j].parent==-1){m2=HTree[j].weight;y=j;}}HTree[x].parent=HTree[y].parent=r;HTree[r].weight=HTree[x].weight+HTree[y].weight;HTree[r].LChild=x;HTree[r].RChild=y;HTree[r].parent=-1;}}void Huffman::CreateCodeTable() //生成编码表{HCodeTable=new HCode[n];for(int i=0;i<n;i++){HCodeTable[i].data=b[i];int child=i;int parent=HTree[i].parent;int k=0;while(parent!=-1){if(child==HTree[parent].LChild)HCodeTable[i].code[k]='0';elseHCodeTable[i].code[k]='1';k++;child=parent;parent=HTree[child].parent;}HCodeTable[i].code[k]='\0';cout<<b[i]<<"的编码:";for(int j=k-1;j>=0;j--)cout<<HCodeTable[i].code[j];cout<<endl;}}void Huffman::Encoding(char *s,char *d) // 编码算法 //d为字符串{cout<<"编码后的字符串为:";while(*d!='\0'){for(int i=0;i<n;i++){if(b[i]==*d) //判断，每当出现一种时，就找到对应编码并输出{int k=strlen(HCodeTable[i].code);for(int j=k-1;j>=0;j--){*s=HCodeTable[i].code[j];cout<<*s;s++;}}}d++;}*s='\0';cout<<endl;}void Huffman::Decoding(char *s,char *d) //s为编码串{cout<<"解码后的字符串为:";while(*s!='\0'){int parent=2*n-1-1;while(HTree[parent].LChild!=-1){if(*s=='0')parent=HTree[parent].LChild;elseparent=HTree[parent].RChild;s++;}*d=HCodeTable[parent].data;cout<<*d;d++;}cout<<endl;void main(){int i=0;char d[MAX];char s[MAX];cout<<"请输入字符串:";while((d[i]=getchar())!='\n')i++;d[i]='\0';Huffman h;cout<<"哈夫曼功能："<<endl;cout<<"1.统计字符种类及出现次数"<<endl;cout<<"2.数据的编码解码"<<endl;cout<<"3.分析压缩效果"<<endl;int q;for(;;){cout<<"请输入（1~3）"<<endl;cin>>q;bool x=0;switch (q){case 1:h.init(d);break;case 2:h.init1(d);h.CreateCodeTable();h.Encoding(s,d);h.Decoding(s,d);break;case 3:cout<<"编码前的长度为:"<<h.count1()<<endl;cout<<"编码后的长度为:"<<h.count2()<<endl;cout<<"压缩比为:"<<(h.count2()*1.0/h.count1())<<endl;break;default:cout<<"请输入选择！！！！！"<<endl;break;}}3.}程序运行结果分析输入：I love data Structure, I love Computer。
北邮数据结构实验报告-排序
北邮数据结构实验报告-排序北邮数据结构实验报告-排序一、实验目的本实验旨在掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序等，并通过实际编程实现对数字序列的排序。
二、实验内容1.冒泡排序冒泡排序是一种简单的排序算法，其基本思想是依次比较相邻的两个元素，并按照从小到大或从大到小的顺序交换。
具体步骤如下：- 从待排序序列的第一个元素开始，依次比较相邻的两个元素；- 如果前面的元素大于后面的元素，则交换这两个元素的位置；- 重复上述步骤，直到整个序列有序。
2.插入排序插入排序是一种简单且直观的排序算法，其基本思想是将待排序序列分为已排序和未排序两部分，每次从未排序部分中选择一个元素插入到已排序部分的合适位置。
具体步骤如下：- 从待排序序列中选择一个元素作为已排序部分的第一个元素；- 依次将未排序部分的元素插入到已排序部分的合适位置，使得已排序部分保持有序；- 重复上述步骤，直到整个序列有序。
3.选择排序选择排序是一种简单且直观的排序算法，其基本思想是每次选择未排序部分中的最小（或最大）元素，并将其放在已排序部分的末尾。
具体步骤如下：- 在未排序部分中选择最小（或最大）的元素；- 将选择的最小（或最大）元素与未排序部分的第一个元素交换位置；- 重复上述步骤，直到整个序列有序。
4.快速排序快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排序序列分割成两部分，其中一部分的元素都比另一部分的元素小。
具体步骤如下：- 选择一个枢轴元素（一般选择第一个元素）；- 将待排序序列中小于枢轴元素的元素放在枢轴元素的左侧，大于枢轴元素的元素放在枢轴元素的右侧；- 对枢轴元素左右两侧的子序列分别进行递归快速排序；- 重复上述步骤，直到整个序列有序。
5.归并排序归并排序是一种高效的排序算法，其基本思想是将待排序序列划分成足够小的子序列，然后对这些子序列进行两两合并，最终形成有序的序列。
具体步骤如下：- 将待排序序列递归地划分成足够小的子序列；- 对每个子序列进行归并排序；- 合并相邻的子序列，直到整个序列有序。
北京邮电大学数据结构课程设计报告
《数据结构》课程设计报告设计题目：多级目录文件检索算法设计姓名___________________学号___________________班级___________________同组组员___________________实验报告日期：一.需求分析（详细说明要实现的功能和功能间的关系）程序旨在实现一个在Linux系统下(以Ubuntu 11.10发行版为蓝本)进行多级目录文件检索的功能。
程序支持传统检索和多星号通配符检索，在搜索结果中给出符合条件文件的文件名，最后修改时间和路径，并按照最后修改时间排序。
程序提供窗口形式的图形界面。
程序运行过程中用户只需手动输入待查的关键字，查找的根路径可以简明的图形界面方式选择。
查找的结果在窗口中显示，允许用户对显示窗口的大小进行任意调节，并使用滚动条查看不能完全显示的部分。
二.算法思想（对于实现较为复杂的功能，要写出所使用的算法和算法的思路）1- 文件查找程序递归调用一个子函数Filesearch(ENTRYPTR LIST, char* input, const char *dir_name)来实现对文件的查找，其思想近于树的先根遍历。
每到达一层目录程序均读取文件名（Linux 下文件夹也被看做是一个文件）并调用KMP算法进行匹配（节点访问过程），然后判定当前文件的性质（宏S_ISDIR），若该“文件”确实是一个文件，则停止向下遍历返回上一层；若该“文件”是一个文件夹，那么进入该文件夹递归遍历下一层。
2- 模式匹配程序使用KMP算法进行文件名和模式的匹配。
该算法首先分析模式的特征（重复性）并生成一个next数组，然后根据next数组的指示在主串上滑动模式进行匹配。
这种算法可以避免对不可能匹配的情况进行比对，从而降低模式匹配过程的时间复杂度。
3- 通配符程序中调用了如下函数const* strtok(char* str1, char* str2);这个函数的作用是按照str2对str1进行分割。
北邮数据结构答案
北邮数据结构答案【篇一：北邮数据结构实验报告实验二含源码】验名称：实验二——栈和队列学生姓名：申宇飞班级： 2012211103班内序号： 03学号： 2012210064日期： 2013年11月18日1．实验要求1.1实验目的：通过选择下面五个题目之一进行实现，掌握如下内容：? 进一步掌握指针、模板类、异常处理的使用? 掌握栈的操作的实现方法? 掌握队列的操作的实现方法? 学习使用栈解决实际问题的能力? 学习使用队列解决实际问题的能力1.2实验内容题目1根据栈和队列的抽象数据类型的定义，按要求实现一个栈或一个队列。
要求：1、实现一个共享栈2、实现一个链栈3、实现一个循环队列4、实现一个链队列编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构链栈：栈的链式存储结构,其实现原理类似于单链表，结点结构与单链表相同，但链栈在实现时直接采用栈顶指针指向栈顶元素。
datanexttop栈顶关键算法分析链栈：一、入栈操作算法步骤：自然语言描述：1、建立新结点2、给p结点的数据域赋值3、修改p结点的指针域，将其指向栈顶结点4、栈顶指针指向p结点伪代码描述：1）nodet * s = new nodet;2）p-data = x;3）p-next = top;4）top = p;二、出栈操作算法步骤：自然语言描述：1、判断栈是否为空2、保存栈顶结点的数据域3、定义指针p指向栈顶结点4、栈顶指针指向下一个结点5、释放p结点伪代码描述：1）if(empty())throw下溢;2）t x = top-data;3）nodet * p = top;4）top = top-next;5）elete p;三、链栈的取栈顶元素栈底算法步骤：自然语言描述:1、判断栈是否为空2、定义指针p指向栈顶结点3、返回栈顶元素的值，不删除伪代码描述1)if(empty())throw下溢;2)nodet*p=top;3)coutp-data;四、遍历链栈元素算法步骤：自然语言描述：1、定义指针p指向栈顶结点2、判断栈是否为空3、返回栈元素的值4、把下一个指针的值赋给p伪代码描述：1）nodet*p = top;2）while(p != null)3）cout p-data ;4）p = p-next;五、析构函数算法步骤：自然语言描述：1、判断栈顶指针是否为空2、定义指针p指向栈顶结点3、把下一个指针的值赋给栈顶指针4、释放要释放的指针伪代码描述：1）while(top)2）struct node t * p = top;3）top = top-next;4）delete p;时间复杂的：o(1)。
北邮数据结构实验报告
北邮数据结构实验报告北邮数据结构实验报告一、引言数据结构是计算机科学中的重要基础知识，对于计算机程序的设计和性能优化起着至关重要的作用。
本报告旨在总结北邮数据结构实验的相关内容，包括实验目的、实验设计、实验过程和实验结果等。
二、实验目的本次实验旨在通过实践操作，加深对数据结构的理解和应用能力。
具体目的如下：1. 掌握线性表、栈和队列等基本数据结构的实现方法；2. 熟悉二叉树、图等非线性数据结构的构建和遍历算法；3. 学会使用递归和非递归算法解决实际问题；4. 培养编程实践能力和团队合作意识。
三、实验设计本次实验包括以下几个部分：1. 线性表实验：设计一个线性表类，实现线性表的基本操作，如插入、删除和查找等。
通过实验，了解线性表的顺序存储和链式存储结构的特点和应用场景。
2. 栈和队列实验：设计栈和队列类，实现栈和队列的基本操作，如入栈、出栈、入队和出队等。
通过实验，掌握栈和队列的应用，如括号匹配、迷宫求解等。
3. 二叉树实验：设计二叉树类，实现二叉树的创建、遍历和查找等操作。
通过实验，熟悉二叉树的前序、中序和后序遍历算法，并了解二叉树的应用，如表达式求值等。
4. 图实验：设计图类，实现图的创建、遍历和最短路径等操作。
通过实验，掌握图的邻接矩阵和邻接表表示方法，并了解图的深度优先搜索和广度优先搜索算法。
四、实验过程1. 线性表实验：根据实验要求，首先选择线性表的存储结构，然后设计线性表类，实现插入、删除和查找等基本操作。
在实验过程中，遇到了一些问题，如边界条件的处理和内存管理等，通过团队合作，最终解决了这些问题。
2. 栈和队列实验：根据实验要求，设计栈和队列类，实现入栈、出栈、入队和出队等基本操作。
在实验过程中，我们发现了栈和队列在实际应用中的重要性，如括号匹配和迷宫求解等，通过实验加深了对栈和队列的理解。
3. 二叉树实验：根据实验要求，设计二叉树类，实现二叉树的创建、遍历和查找等操作。
在实验过程中，我们发现了二叉树在表达式求值和排序等方面的应用，通过实验加深了对二叉树的理解。
数据结构车厢调度实习报告
实习报告：2.3题车厢调度实习报告题目：假设停在铁路调度站入口处的车厢序列的编号次序为1，2，3，…，n。
设计一个程序，求出所有可能输出的长度为n的车厢序列。
班级：计算机（2）班姓名：李伟学号：07095216 完成日期：2009.9.9一、需求分析1、用编号依次为1，2，3，……，n表示停在铁路调度站入口处的车厢序列。
2、用一个栈形象地表示为火车的调度站。
3、利用栈先进后出的性质，结合递归和回溯算法，实现编号1…n的车厢的所有可能的序列。
4、本程序用C语言实现，已经在WIN-TC环境下通过。
二、概要设计1、设定栈的抽象数据类型定义：ADT Stack{数据对象：D={ai | ai∈CharSet，i=1，2，……，n，n≥0}数据关系：R1={<ai-1,ai> | ai-1,ai∈D,i=2，……，n}基本操作：InitStack(&S)操作结果：构造一个空栈S。
Push(&S,e);初始条件：栈S已存在。
操作结果：在栈S的栈顶插入新的栈顶元素e。
Pop(&S,e);初始条件：栈S已存在。
操作结果：删除S的栈顶元素，并以e返回其值。
StackEmpty(S)初始条件：栈S已存在。
操作结果：若S为空栈，则返回TRUE，否则返回FALSE。
}ADT Stack2、本程序包括两个模块：（1）初始化数据——输入总数——初始化栈和序列（2）显示所有的序列——递归调用——输出所有结果三、详细设计1、为了使车厢能够调度，需要定义一个栈，利用栈先进后出的性质，改变车厢的顺序；因为输出的序列有很多种，而且序列的产生是用递归产生的，所以定义一个二维数组，用它保存所有的输出序列，供演示时调用。
struct pathss{int paths[MAXSIZE][MAXSIZE];int number;}AllPath;2、栈类型struct SNode{int data[MAXSIZE];int top;}S;栈的基本操作：void InitStack() /*栈的初始化*/{S.top=-1;}void Push(int q) /*进栈*/{S.data[++S.top]=q;}int Pop() /*出栈*/{int temp;temp=S.data[S.top--];return temp;}int StackEmpty() /*判断栈是否为空*/ {if(S.top==-1)return 1;elsereturn 0;}3、求所有序列的伪码算法：void Attemper(int pos,int path[],int cur){if(pos<n) {一个数进栈后,有两种处理方式：要么立刻出栈,要么进行下一个数的进栈}if(栈不空){一个数出栈后,有两种处理方式：要么继续出栈,要么继续下一个数的进栈}if(pos==n && 栈空){一种可能输出序列产生，输出；并将每种序列保存在二维数组里；}}4、演示一种序列的伪码算法：演示时，采用的是向逆推的方法，因为我们已经知道了一种输出序列的结果和它的最初状态，就可以利用栈将中间过程显示出来；void ChooseDisplay(){int k,Output,Input=1;for(Output=0;Output<n;Output++){if(输出序列中当前的数据大于等于入口处的数据时){while(输出序列中当前的数据大于等于入口处的数据时){入口处的数据要一直压栈}显示每一步结果}else （序列中当前的数据小于入口处的数据）{弹出栈顶,重新显示结果}}}5、主函数和其他函数void main() /*主函数*/{功能选择分别调用：1: InputNumber()2: DisplayAll()}void DisplayAll() /*显示所有输出序列*/{调用函数Attemper}void DisplayOnly(int k,int Output,int Input) /*显示操作序列的状态的变化过程*/ {第一步：显示输出序列的状态变化第二步：显示栈的状态变化}6、函数的调用关系图反映了演示程序的层次结构：四、调试分析1、本程序的栈其实也是一个一维数组,然后用一个top作为指针,控制数组的长度。
北邮数据结构实验报告二_栈和队列
2009级数据结构实验报告实验名称：实验二栈和队列学生姓名：班级：班内序号：学号：日期：2010年12月18日实验要求题目四用栈做计算器。
设计一个算术四则运算表达式求值的简单计算器。
表达式求值是程序设计语言编译中最近本的问题，它要求把一个表达式翻译成能够直接求值的序列。
基本要求：输入中缀表达式能够转化成后缀表达式，比如输入中缀表达式“(A+B)*C”，输出“AB+C*”2、操作数使用单字母变量A、B、C等表示，操作符仅为+、-、*、/、（和）；3、能够对变量A、B、C等赋值，得出正确的计算结果2. 程序分析首先，程序要求用户输入一个符号表达式，只能包含字母、+、-、*、/ 以及）和（，之后程序会用一个TurnInfixToPostfix（）函数将表达式转化成后缀表达式存入一个栈中，转化过程借用逆波兰算法，建立一个符号栈，遍历用户输入的表达式，如果是字母，则直接输出，如果是运算符，则压入符号栈中（包括括号），在压栈的时候又需要注意，先要检查压栈前栈顶元素的优先级，如果优先级高于要压入的符号则直接压入该符号，否则要弹栈直到栈顶元素的优先级小于该元素的优先级然后才将该符号压入栈中（在压栈的时候会涉及到栈中有括号的情况，具体细节下面会说到），将转化的后缀表达式存入栈postfix，在输出的时候只要弹栈就行。
然后，要求用户逐个输入表达式中的字母的值，这时候，需要遍历当时在转化后缀表达式的时候过度容器vec_intoposfix，如果是字母则要求用户输入数值，压入用于计算的后缀表达式容器，如果是操作符则直接压入。
最后，在利用栈来计算值的时候，利用一个递归函数，就是一次弹栈，如果是操作符则先保存起来，接着继续弹栈，如果接下来的两个元素都为数字，就将这两个数字做相应的运算，然后压栈，如此反复，最后压入栈的元素就是表达式的值。
至此，程序的功能全部实现。
2.1 存储结构[内容要求]1、存储结构：顺序表、单链表或其他存储结构，需要画示意图，可参考书上P59页图2-92.2 关键算法分析关键算法一：将中缀表达式转化为后缀表达式VoidTurnInfixToPostfix(vector<char>&vec,stack<char>&sta,vector<char>&vecfix,stack< char>&stafix)1、 {2、int priority(-1);3、4、for (vector<char>::iterator itr=vec.begin();itr!=vec.end();itr++)5、{6、if(isLetter(*itr))7、{8、vecfix.push_back(*itr);9、}10、if (isOperator(*itr))11、{12、if(!sta.empty()) priority=getPriority(sta.top());13、else priority=-1;14、if (priority<getPriority(*itr)||priority==3&&sta.top()!=')')15、{16、sta.push(*itr);17、}18、else19、{20、if (sta.top()!=')')21、{22、while(priority>=getPriority(*itr)&&sta.top()!='(')23、{24、vecfix.push_back(sta.top());25、if (!sta.empty())26、{27、sta.pop();28、if(!sta.empty()) priority=getPriority(sta.top());29、else priority=-1;30、}31、else32、break;33、}34、sta.push(*itr);35、}36、else if(sta.top()==')')37、{38、while (sta.top()!='(')39、{40、vecfix.push_back(sta.top());41、if (!sta.empty()&&sta.top()!='(')42、{43、sta.pop();44、}45、else46、break;47、}48、}49、}50、51、52、}53、54、}55、for (vector<char>::iteratoritrfix=vecfix.end();itrfix!=vecfix.begin();--itrfix)56、stafix.push(*itrfix);57、stafix.push(*itrfix);58、}对表达式a + b * c – ( d – e) / f + g其符号栈的变化过程，红色表示未压栈的符号。
北邮数据结构实验报告排序
数据结构实验报告实验名称：实验四——排序学生姓名：班级：班内序号：学号：日期：2014年12月19日1．实验要求实验目的通过实现下述实验内容，学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。
实验内容使用简单数组实现下面各种排序算法，并进行比较。
排序算法：1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序（选作）7、归并排序（选作）8、基数排序（选作）9、其他要求：1、测试数据分成三类：正序、逆序、随机数据2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。
3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。
2. 程序分析首先，题目要求测试不同的数据，所以可以手动输入待排序元素。
其次，由于对一组数据要求用不同的排序算法来处理，所以需要一个复制函数把排序前的无序数组寄存出去，为下一次排序做准备。
再次，由于每次排序后都需要把排序后的结果打印出来，代码是一样的，根据相同的代码可以封装成一个函数的思想，所以还需增加一个打印函数。
2.1 存储结构本程序采用简单数组来储存输入的待排序数组2.2 关键算法分析核心算法思想：1. 利用教材讲述的基本算法思想，实现七种排序算法，统计其运行相关数据。
2. 将七种排序函数入口地址作为函数指针数组，实现快速调用和统计。
使得程序代码可读性增、结构更加优化。
关键算法思想描述和实现：关键算法1：实现七种算法的基本排序功能。
1、插入排序：依次将待排序的序列中的每一个记录插入到先前排序好的序列中，直到全部记录排序完毕。
插入排序的思想是：每次从无序区取一元素将其添加到有序区中。
2、希尔排序：先将整个序列分割成若干个子列，分别在各个子列中运用直接插入排序，待整个序列基本有序时，再对全体记录进行一次直接插入排序。
北邮数据结构实验报告 图
北邮数据结构实验报告图一、实验报告规范实习报告的开头应给出题目、班级、姓名、学号和完成日期，并包括以下七个内容：1.需求分析以无歧义的陈述说明程序设计的任务，强调的是程序要做什么?明确规定：(1)输入的形式和输入值的范围;(2)输出的形式;(3)程序所能达到的功能;(4)测试数据：包括正确的输入及其输出结果和含有错误的输入及其输出结果。
2.概要设计说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次(调用)关系。
3.详细设计实现概要设计中定义的所有数据类型，对每个操作只需要写出伪码算法;对主程序和其他模块也都需要写出伪码算法(伪码算法达到的详细程度建议为：按照伪码算法可以在计算机键盘直接输入高级程序设计语言程序);画出函数的调用关系图。
4.调试分析内容包括：(1)调试过程中遇到的问题是如何解决的以及对设计与实现的回顾讨论和分析;(2)算法的时空分析(包括基本操作和其他算法的时间复杂度和空间复杂度的分析)和改进设想;(3)经验和体会等。
5.用户使用说明说明如何使用你编写的程序，详细列出每一步的操作步骤。
6.测试结果列出你的测试结果，包括输入和输出。
这里的测试数据应该完整和严格，最好多于需求分析中所列。
7.附录带注释的源程序。
如果提交源程序软盘，可以只列出程序文件名的清单。
值得注意的是，实习报告的各种文档资料，如：上述中的前三部分要在程序开发的过程中逐渐充实形成，而不是最后补写(当然也可以应该最后用实验报告纸誊清或打印)。
数据结构实验报告;实验名称：实验一线性表实现一个多项式;学生姓名：黄锦雨;班级：XX211109;班内序号：20;学号：XX210263;日期：XX年10月31日;实验目的：;1.熟悉C++语言的基本编程方法，掌握集成编译环;2.学习指针、模板类、异常处理的使用;3.掌握线性表的操作的实现方法;4.学习使用线性表解决实际问题的能力;实验内容：;数据结构实验报告实验名称：实验一线性表实现一个多项式学生姓名：黄锦雨班级：XX211109班内序号： 20学号： XX210263日期： XX年10月31日实验目的：1.熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法2.学习指针、模板类、异常处理的使用3.掌握线性表的操作的实现方法4.学习使用线性表解决实际问题的能力实验内容：利用线性表实现一个一元多项式Polynomialf(x) = a0 + a1x + a2x2 + a3x3 + … + anxn要求：1. 能够实现一元多项式的输入和输出2. 能够进行一元多项式相加3. 能够进行一元多项式相减4. 能够计算一元多项式在x处的值5. 能够计算一元多项式的导数(选作)6. 能够进行一元多项式相乘(选作)7. 编写测试main()函数测试线性表的正确性2. 程序分析由于多项式是线性结构，故选择线性表来实现，在这个程序中我采用的是单链表结构，每个结点代表一个项，多项式的每一项可以用其系数和指数唯一的表示。
迷宫问题 火车车厢重排问题 实验报告
实验报告了便于从列车上卸掉相应的车厢，车厢的编号应与车站的编号相同，这样，在每个车站只要卸掉最后一节车厢。
所以，给定任意次序的车厢，必须重新排列它们。
车厢的重排工作可以通过转轨站完成。
在转轨站中有一个入轨、一个出轨和k个缓冲轨，缓冲轨位于入轨和出轨之间。
假定缓冲轨按先进先出的方式运作，设计算法解决火车车厢重排问题。
②基本要求●设计存储结构表示n个车厢、k个缓冲轨以及入轨和出轨；●设计并实现车厢重排算法；●分析算法的时间性能。
③思考●如果缓冲轨按后进先出的方式工作，即用栈表示缓冲轨，应如何解决火车车厢重排问题？二、数据结构设计迷宫问题和火车重排问题可以通过栈与队列实现的。
迷宫的进出和车厢的出入轨和缓冲轨主要是对栈与队列的判断和操作。
int empty( STLink top[],int n) /*判断是否为空*/{return (top[n]==NULL);}int push(STLink top[],int A,int m) /*入栈*/{STLink p;if(!(p=(STLink)malloc(LEN)))return 0;else{p->data=A;p->link=top[m];top[m]=p;return 1;}}int pop(STLink top[],int m) /*出栈*/{int A;STLink p;p=top[m];A=p->data;top[m]=top[m]->link;free(p);return A;}struct Node{ /定义队列int data;Node* next;};三、算法设计1.迷宫问题：进入格子后，需要判断此时格子位置周围障碍物的位置，对其进行压栈，判断，然后看是否满足条件，满足就进栈，不满足就弹出，然后输出不能通过建立迷宫：typedef struct LStack{Element elem;struct LStack *next;}*PLStack;int InitStack(PLStack &S){S=NULL;return 1;}int StackEmpty(PLStack S){if(S==NULL)return 1;elsereturn 0;}int Push(PLStack &S, Element e){PLStack p;p=(PLStack)malloc(sizeof(LStack));p->elem=e;p->next=S;S=p;return 1;}（2）.输出路径2.火车车厢排序六、实验收获与思考通过本次实验，进一步增强了对栈和队列的理解，明白的栈的先进后出和队列先进先出的方式，对压栈和出入栈与队列有了深刻认识。
车厢重排问题实验报告
实验报告1．实验要求利用队列结构实现车厢重排问题。
车厢重排问题如下：一列货车共有n节车厢，每个车厢都有自己的编号，编号范围从1~n。
给定任意次序的车厢，的车厢编号。
提示：一列火车的每个车厢按顺序从入轨进入不同缓冲轨，缓冲轨重排后的进入出轨，重新编排成一列货车。
比如：编号为3的车厢进入缓冲轨1，则下一个编号小于3的车厢则必须进入下一个缓冲轨2，而编号大于3的车厢则进入缓冲轨1，排在3号车厢的后面，这样，出轨的时候才可以按照从小到大的顺序重新编排。
2. 程序分析2.1 存储结构本程序采用单链表结构，具体为链队列结构，使用队列结构的先进先出原则可以较好地处理车厢重排问题。
链队列结构示意图如下：2.2 关键算法分析一、本程序的关键算法主要为处理车厢重排问题的函数TrainPermute()，其伪代码如下：void TrainPermute():1. 初始化条件:计数器i=0,与非门aa=12. 判断是否能入轨while(用i<n判断是否n节车厢都入缓冲轨)&&(用aa=1判断是否有合适的缓冲轨可入)2.1将aa置空；2.2用for循环，依次取入入轨中的每一个车厢的编号进入合适的缓冲轨；2.2.1如果缓冲轨中尾指针比进入缓冲轨元素小，则进入该缓冲轨；计数器i+1;有合适缓冲轨，将aa变为真;跳出for循环并进入while循环；2.2.2如果缓冲轨中第一个元素为空，则进入缓冲轨成为第一个元素；计数器i+1;有合适缓冲轨，将aa变为真;跳出for循环并进入while循环；2.3 用aa判断是否有进入合适的缓冲轨2.3.1 aa=0即没有合适的缓冲轨，则输出无法排列；2.3.2 aa=1即有合适的缓冲轨，则2.3.2.1遍历缓冲轨，输出每个缓冲轨按顺序存储的车厢；2.3.2.2 按从小到大的顺序出轨for(引入输出轨计数器newOut=1;newOut<n; newOut+1;)newOut与每个队列的头元素比较若相等，则元素出队；输出显示；具体代码如下：void TrainPermute(int arr[],LinkQueue<int> a[],int n,int k){int i=0;bool aa=1;while((i<n)&&(aa)) //当入轨中有车厢时{for(int m=0;m<k;m++){if(a[m].GetRear()<arr[i]){a[m].EnQueue(arr[i]);i++;}if(a[m].front->next==NULL){a[m].EnQueue(arr[i]);aa=1;i++;break;}}}if(aa==0) //当无法将入轨中队头车厢移至合适缓冲轨中时，程序结束{cout<<"车厢无法重排,算法结束"<<endl;}else //当入轨中已经没有车厢时{for(int m=0;m<k;m++){cout<<"第"<<(m+1)<<"个缓冲轨的列车编号";a[m].Trans();cout<<endl;}cout<<"火车车厢出轨顺序为:"<<endl;for(int newOut=1;newOut<=n;newOut++){for(int j=0;j<k;j++) //扫描缓冲轨，将其队头元素依次由小到大输出{if(a[j].GetFront()==newOut){cout<<a[j].DeQueue()<<" ";}}}}}二、主函数伪代码如下：1. 输入n与k值，若输入值错误，则程序结束；2. 通过循环结构为数组array[]赋值，具体分析见代码；3. 输出入轨中火车车厢号码排列；4. 调用TrainPermute()函数；三、为array[]随机赋值的基本思想为：设置计数器count=0，设置数组ifmark[]来标记array[]赋值情况，依次将1至n等n个数随机赋给array[]，其中，若array[t]未被赋值，即ifmark[t]=0，则将值赋给array[t]，计数器加一；若array[t]已被赋值，即ifmark[t]=1，则重新开始循环。
北邮操作系统第二次实验
北京邮电大学操作系统实验实验报告班号：14 姓名： oneseven学号：实验日期：实验名称：操作系统实验一、实验目的通过模拟实现内存分配的伙伴算法和请求页式存储管理的几种基本页面置换算法，了解存储技术的特点。
掌握虚拟存储请求页式存储管理中几种基本页面置换算法的基本思想和实现过程，并比较它们的效率。
二、实验内容1.实现一个内存管理的伙伴算法，实现内存块申请时的分配和释放后的回收。
实验准备用随机函数仿真进程进行内存申请，并且以较为随机的次序进行释放。
对其碎片进行统计，当申请分配内存失败时区分实际空间不足和由于碎片而不能满足。
2.设计一个虚拟存储区和内存工作区，并使用下述算法计算访问命中率。
1) 最佳置换算法（Optimal）2) 先进先出法（Fisrt In First Out）3) 最近最久未使用（Least Recently Used）4) 最不经常使用法（Least Frequently Used）其中，命中率＝１－页面失效次数／页地址流长度。
试对上述算法的性能加以较各：页面个数和命中率间的关系；同样情况下的命中率比较。
实验准备本实验中主要的流程：首先用srand( )和rand( )函数定义和产生指令序列，然后将指令序列变换成相应的页地址流，并针对不同的算法计算出相应的命中率。
实验可先从一个具体的例子出发。
(1)通过随机数产生一个指令序列，共2048条指令。
指令的地址按下述原则生成：A：50%的指令是顺序执行的B：25%的指令是均匀分布在前地址部分C：25%的指令是均匀分布在后地址部分具体的实施方法是：A：在[0，1023]的指令地址之间随机选取一起点mB：顺序执行一条指令，即执行地址为m+1的指令C：在前地址[0,m+1]中随机选取一条指令并执行，该指令的地址为m’D：顺序执行一条指令，其地址为m’+1E：在后地址[m’+2，2047]中随机选取一条指令并执行F：重复步骤A-E，直到2048次指令(2)将指令序列变换为页地址流设：页面大小为4K；用户内存容量4页到32页；用户虚存容量为32K。
北邮数据结构实验第二次实验图
数据结构实验报告1．实验要求（1）实验目的通过选择下面5个题目之一进行实现，掌握如下内容：掌握图基本操作的实现方法了解最小生成树的思想和相关概念了解最短路径的思想和相关概念学习使用图解决实际问题的能力(2)实验内容根据图的抽象数据类型的定义，使用邻接矩阵或邻接表实现一个图。
图的基本功能：1、图的建立2、图的销毁3、深度优先遍历图4、广度优先遍历图5、使用普里姆算法生成最小生成树6、使用克鲁斯卡尔算法生成最小生成树7、求指定顶点到其他各顶点的最短路径8、其他：比如连通性判断等自定义操作编写测试main()函数测试图的正确性2. 程序分析存储结构图：(1)带权值的无向图V09 6V1 2 V2(2)带权值的有向图V063 9 4V1 2 V2关键算法分析（1）深度优先遍历int visited[MAXSIZE]={false};template<class T>void MGraph<T>::DFS(int v){cout<<vertex[v];visited[v]=true;for(int j=0;j<vNum;j++)if(arc[v][j]==1&&!visited[j])DFS(j);}时间复杂度：O(n²)（2）广度优先遍历int queue[MAXSIZE];int f=0,r=0;cout<<vertex[v];visit[v]=true;queue[++r]=v;while(f!=r){v=queue[++f];for(int j=0;j<vNum;j++){if(arc[v][j]==1&&!visit[j]){cout<<vertex[j];visit[j]=true;queue[++r]=j;}时间复杂度：O（n²）（3）普利姆算法int adjvex[MAXSIZE];int lowcost[MAXSIZE];int MAX=10000;template<class T>int mininum(MGraph<T> G,int a[]){int min=MAX;int k=0;for(int i=0;i<;i++){if(a[i]!=0&&a[i]<min)romV=i;E[k].endV=j;E[k].weight=[i][j];k++;}for(i=0;i<;i++){for(j=i+1;j<;j++)if(E[i].weight>E[j].weight){VEdge t=E[i];E[i]=E[j];E[j]=t;}}}const int MAX_VERTEXT=20;template<class T>void MGraph<T>:: Kruskal(VEdge E[],int n,int e){int vset[MAX_VERTEXT];for(int i=0;i<n;i++) vset[i]=i;romV,n=E[j].endV;int sn1=vset[m]; 程序运行结果（1）流程图：初始化带权值的无向图深度优先遍历，广度优先遍历用普利姆算法求最小生成树用克鲁斯卡尔算法求最小生成树初始化带权值的有向图用Floyd算法求任意两点间最短路径，并判断连通性删除图（2）本程序所用的图带权值的无向图V09 6V1 2 V2带权值的有向图V063 9 4V1 2 V2（3）程序结果4. 总结（1）遇到的问题：私有数据访问权的问题，在编程时应该注意（2）心得体会：通过这次实验，我掌握了图基本操作的实现方法，了解最小生成树的思想和相关概念，了解最短路径的思想和相关概念等等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告
实验名称：实验二——车厢重排
学生姓名：
班级：
班内序号：
学号：
日期：
1．实验要求
（1）、实验目的：
①进一步掌握指针、模板类、异常处理的使用
②掌握栈的操作的实现方法
③掌握队列的操作的实现方法
④学习使用栈解决实际问题的能力
⑤学习使用队列解决实际问题的能力
（2）、实验内容：
一列货车共有n节车厢，每个车厢都有自己的编号，编号范围从1~n。
给定任意次序的车厢，通过转轨站将车厢编号按顺序重新排成1~n。
转轨站共有k个缓冲轨，缓冲轨位于入轨和出轨之间。
开始时，车厢从入轨进入缓冲轨，经过缓冲轨的重排后，按1~n的顺序进入出轨。
缓冲轨按照先进先出方式，编写一个算法，将任意次序的车厢进行重排，输出每个缓冲轨中的车厢编号。
2. 程序分析
2.1 存储结构
链队列:
2.2 关键算法分析
（1）、入队操作：（时间复杂度为O（1））
①.建立新结点：rear->next=new Node<T>
②.移动队尾指针：rear=rear->next
③.赋值：rear->data=x
④.将新结点的next指针域赋为空：rear->next=NULL
入队结构示意图如下：
（2）、出队操作：（时间复杂度为O（1））
算法伪代码如下：
①.保存队头元素指针：Node<T>*p=front->next；
②.如果为空队则抛出异常：if(!p)throw"下溢";
③.原队头元素出列：front->next=p->next;
④.保存队头数据：T x=p->data;
⑤.释放原队头：delete p;
⑥.若队列变为空队，修改队尾指针：if(!(front->next))rear=front;
⑦.返回出队数据：return x;
出队结构示意图如下：
（3）、查找队头元素：（时间复杂度为O（1））
算法分析：1.如果是空队列，则抛出异常：if (!(front->next))throw"上溢";
2. 否则返回队头元素：return front->next->data;
（4）、查找队尾元素：（时间复杂度为O（1））
算法分析：1.如果是空队列，返回0：if(rear==front) return 0;
2.否则返回队尾元素return rear->data;
（5）、车厢重排函数：（时间复杂度为O（n））
算法分析：1. 建立k+2个新队列：LinkQueue<int> *rail;
rail=new LinkQueue<int>[k+2]
2.将n节乱序的车厢放进入轨：cin>>arr[j];
rail[k].EnQueue(arr[j])
3. 将入轨中的车厢放进缓冲轨中，设置一个变量判断车厢是否成功放进缓冲轨：
while((i<n)&&success!=0)
3.1如果队列不为空而且该队列的队尾元素小于入轨中的头元素，则头元素
入轨，并且跳出for循环：rail[j].EnQueue(num);
success=1;
i++;
break;
3.2否则，如果队列为空，则入队：if(!rail[j].Empty())
rail[j].EnQueue(num);
success=1;
i++;
break;
3.3如果两种情况都不满足的话，则跳出while循环：success=0
4.如果车厢没有全部放进缓冲轨，则输出“缓冲轨不足，无法进行后续排序！”。
5.否则的话，可以进行排序：
5.1若此时要输出的车厢号小于等于总的车厢数，则进行出轨操作
5.1.1依次获取缓冲轨的头元素，如果与此时要输出的车厢号相同，则将其出队，并且放进出轨中，并且跳出for循环：if(rail[j].GetFront()==order)
{ ReNum=rail[j].DeQueue();
rail[k+1].EnQueue(ReNum);
order++;
break; }
6. 输出排序后的车厢顺序：cout<<rail[k+1].DeQueue()
（6）、主函数：直接调用重排函数：ReArrangement();
2.3 其他
将入轨中的元素放入缓冲轨中，如果有入轨中的元素无法放进缓冲轨，则说明缓冲轨不够，无法进行排序。
若车厢全部放入了缓冲轨，则能按顺序将车厢放入出轨中，排序完成。
3. 程序运行结果
1.测试主函数流程图：
2.测试条件：输入的车厢数n,缓冲轨数k均应该是整数，且车厢标号为从1到n。
3.测试结论：如果未输入n节车厢，则抛出错误。
如果缓冲轨数不够，则输出无法排序；如果入轨中的车厢均进入缓冲轨，则输出各车厢进入的缓冲轨的顺序与进入的缓冲轨，最后输出排序后的车厢顺序。
4.总结
1.调试时出现的问题及解决方法：
但我在调试程序的时候发相，如果输入的车厢数小于n值时，直接按Ctrl+Z结束输入，则由于开始给每个车厢都赋值为0，造成后面的车厢编号相同，无法进行正常的排序。
因此，我在车厢入轨后加入了一个异常处理，判断是否给每一个车厢都进行了赋值。
若已赋值，则进行下面的过程。
若未赋值则直接输出程序无法进行。
2.心得体会：
通过这个实验，我熟悉了队列的使用方法。
进一步加深了对于出入队的理解。
同时我也意识到，在一个程序基本功能实现之后，其实还有许多我们未曾想到的BUG。
当我们按我们所设计的方式操作时，这些BUG好像并没有什么影响。
但一旦我们错误操作，这些BUG就会使我们的程序崩掉。
所以写程序时要特别注意异常处理。
3.下一步的改进：
我了解到，车厢重排问题其实也可以用递归方法写，这样的代码会更为简单。
这次我设计的程序还应该多增加一些创新点，如如何重排任意序号的车厢，而非由1~n的车厢。
这些都是下一步改进的方向。