数据结构实验报告Word下载.docx
《数据结构实验报告Word下载.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告Word下载.docx（53页珍藏版）》请在冰豆网上搜索。
3。
6.实验收获及思考
学会运用建立链表解决实际问题。
7.源代码
#include<
iostream.h>
/*#include<
algorithm>
*/
usingnamespacestd;
typedefstructLNode
structLNode*next;
}LNode,*LinkList;
intmain（）
intm,n;
inti;
intnum;
i=1;
num=0;
//cout<
<
"
******约瑟夫环问题******"
endl;
cout<
请输入总人数n:
;
cin>
>
n;
请输入密码m:
m;
LinkListfirst,p,q;
first=（LinkList）malloc（sizeof（LNode））;
first->
data=i;
p=first;
while（i!
=n）
{
i+=1;
q=（LinkList）malloc（sizeof（LNode））;
q->
p->
next=q;
p=p->
next;
}
p->
next=first;
while
（1）
i=1;
while（i<
m-1）
{
p=p->
i++;
}
if（p->
next==p）
cout<
第"
n<
个出圈的人的号为:
p->
data<
break;
else
++num;
num<
next->
p->
next=p->
system（"
pause"
）;
return0;
}
第三章迷宫问题
设计性实验
1.问题描述
迷宫四周设为墙；
无填充处，为可通处。
设每个点有四个可通方向，分别为东、南、西、北。
左上角为入口。
右下角为出口。
迷宫有一个入口，一个出口。
设计程序求解迷宫的一条通路。
2.数据结构设计
设置迷宫，最外围1为墙里边0为可走路径1为障碍
{1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1},
{1,1,0,0,0,0,0,1},
{1,0,0,1,0,1,0,1},
{1,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1}
定义指针，设置方向，上下左右。
find为设置找不找得到路
lj[top].x=1;
lj[top].y=1;
migong[1][1]=-1;
find=0;
d=-1;
3.算法设计
循环语句，从起点查找开始路径，可走就继续进入下一格子。
if（lj[top].x==4&
&
lj[top].y==6）
迷宫路径如下:
开始->
for（inti=0;
i<
=top;
i++）
（"
lj[i].x<
"
lj[i].y<
）"
->
"
//把找到的路径输出
num++;
if（num%6==0）
结束!
d=4;
判断是否找得到
if（find==1）{
lj[top].d=d;
top++;
lj[top].x=x;
lj[top].y=y;
d=-1;
migong[x][y]=-1;
4.运行、测试与分析
运行程序：
5.实验收获及思考
学会用顺序栈，队列解决实际问题。
6.源代码
iostream>
intmigong[6][8]=//设置迷宫，最外围1为墙里边0为可走路径1为障碍
{1,1,1,1,1,1,1,1}
intnum;
struct
intx,y,d;
}lj[48];
//x,y分别为垂直和水平方向
voidstart（）
inttop=0,x,y,d,find;
//d为设置方向，上下左右。
while（top>
-1）{
if（lj[top].x==4&
while（d<
4&
find==0）{
d++;
switch（d）{
case0:
x=lj[top].x-1;
y=lj[top].y;
break;
//方向为上
case1:
x=lj[top].x;
y=lj[top].y+1;
break;
//方向为右
case2:
x=lj[top].x+1;
//方向为下
case3:
y=lj[top].y-1;
}//方向为左
if（migong[x][y]==0）
find=1;
if（find==1）{//判断是否找得到
//重新调整方向
else{
migong[lj[top].x][lj[top].y]=0;
top--;
d=lj[top].d;
//找不到的话退栈
start（）;
第三章火车重拍问题
一列货运列车共有n节车厢，每节车厢将停放在不同的车站。
假定n个车站的编号分别为1～n，即货运列车按照第n站至第1站的次序经过这些车站。
为了便于从列车上卸掉相应的车厢，车厢的编号应与车站的编号相同，这样，在每个车站只要卸掉最后一节车厢。
所以，给定任意次序的车厢，必须重新排列它们。
车厢的重排工作可以通过转轨站完成。
在转轨站中有一个入轨、一个出轨和k个缓冲轨，缓冲轨位于入轨和出轨之间。
假定缓冲轨按先进先出的方式运作，设计算法解决火车车厢重排问题。
创建头指针和尾指针。
typedefstruct
QueuePtrfront;
//头指针，若队列不空，指向队列头元素
QueuePtrrear;
//尾指针，若队列不空，指向队列尾元素的下一个位置
}LinkQueue;
构造一个空队列Q：
intInitQueue（LinkQueue&
Q）//{
Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;
if（!
Q.front）return0;
//存储分配失败
Q.front->
next=NULL;
return1;
voidResort（LinkQueue&
Q,intb[],LinkQueue*H,intk）//火车车厢重排
intnowOut=1,no=1,p=0;
while（nowOut<
10）
intflag=0,flag2=0;
//车厢出轨标记初始化为0
intc=DeQueue（Q）;
if（c==nowOut）
c<
直接出栈"
b[p]=c;
p++;
nowOut++;
flag=1;
for（intj=0;
j<
k;
j++）//输出对头元素
if（IsEmpty（H[j]））
if（Getfront（H[j]）==nowOut）
{
intm=DeQueue（H[j]）;
cout<
m<
从第"
个缓冲栈出来！
b[p]=m;
j=0;
}}}
4.运行、测试与分析
输入进队列顺序369247185
缓冲轨数为3
5.源代码
stdlib.h>
typedefstructQNode
structQNode*next;
}QNode,*QueuePtr;
Q）//构造一个空队列Q
{Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））;
intEnQueue（LinkQueue&
Q,inte）//插入元素e为Q的新的队尾元素
{
QueuePtrp;
p=（QueuePtr）malloc（sizeof（QNode））;
if（!
p）return0;
//队列满
data=e;
next=NULL;
Q.rear->
next=p;
Q.rear=p;
intDeQueue（LinkQueue&
Q）//若队列不空，则删除Q的队头元素，用e返回其值，并返回1;
否则返回0
if（Q.front==Q.rear）return0;
else
{
p=Q.front->
if（p->
next==NULL）
Q.front=Q.rear;
intm=p->
data;
free（p）;
returnm;
intGetfront（LinkQueue&
Q）//取队头元素
if（Q.front==Q.rear）return0;
returnQ.front->
intGetrear（LinkQueue&
Q）//取队尾元素
returnQ.rear->
intIsEmpty（LinkQueue&
Q）//判断队列为空
if（Q.front==Q.rear）
}
if（flag==0）//插入新的缓冲队列
for（inti=0;
if（IsEmpty（H[i]））
{
intn=Getrear（H[i]）;
if（c>
{
cout<
输入到第"
个缓冲栈！
EnQueue（H[i],c）;
flag2=1;
}
}
}
if（flag2==0）
if（no==k）
cout<
缓冲队列已用完，无法输出"
else
cout<
no<
EnQueue（H[no],c）;
no++;
LinkQueueQ,H[9];
intk,a[9],b[9];
InitQueue（Q）;
请输入你需要的缓冲队列个数:
InitQueue（H[i]）;
请输入火车入轨的编号序列:
9;
j++）
cin>
a[j];
EnQueue（Q,a[j]）;
火车车厢重排序列为:
Resort（Q,b,H,k）;
b[i]<
system（"
第五章魔方阵
魔方阵是一个古老的智力问题，它要求在一个m×
m的矩阵中填入1～m2的数字（m为奇数），使得每一行、每一列、每条对角线的累加和都相等，如图1所示。
15
8
1
24
17
16
14
7
5
23
22
20
13
6
4
3
21
19
12
10
9
2
25
18
11
inta[16][16],i,j,k,p,n;
//定义魔方阵最大结构，设置循环变量。
p=1;
判断是否在规定的范围内，而且要求输入的是奇数。
if（（n!
=0）&
（n<
=15）&
（n%2!
=0））
由三阶魔方阵的生成过程可知，某一位置（x,y）的左上角的位置是（x-1,y-1）,如果x-1≥0，不用调整，否则将其调整为x-1+m；
同理，如果y-1≥0，不用调整，否则将其调整为y-1+m。
所以，位置（x,y）的左上角的位置可以用求模的方法获得，即：
x=（x-1+m）%m
y=（y-1+m）%m
for（i=1;
=n;
for（j=1;
a[i][j]=0;
j=n/2+1;
a[i][j]=1;
for（k=2;
k<
=n*n;
k++）
i=i-1;
j=j+1;
if（（i<
1）&
（j>
n））
i=i+2;
j=j-1;
测试用例，输入奇数3和5：
实验中遇到问题自己想办法解决可以提高很快啊。
#include<
stdio.h>
inta[16][16],i,j,k,p,n;
while（p==1）
printf（"
enter奇数n:
scanf（"
%d"
&
n）;
if（（n!
p=0;
for（i=1;
else
if（i<
1）i=n;
if（j>
n）j=1;
if（a[i][j]==0）
a[i][j]=k;
a[i][j]=k;
for（i=1;
%5d"
a[i][j]）;
\n\n"
第六章二叉链表
1.问题描述
●二叉链表的C语言描述
●基本运算的算法——建立二叉链表、先序遍历二叉树、中序遍历二叉树、后序遍历二叉树、后序遍历求二叉树深度
2.数据结构设计
在建立二叉树时，我选用结构体来建立。
typedefstructbitnode
chardata;
structbitnode*lchild;
structbitnode*rchild;
}bitnode,*bitree;
3.算法设计
先后设计了先序遍历，中序遍历，后序遍历以及深度的算法。
voidpreordertraverse（bitree&
t）
if（t）
printf（"
%c"
t->
data）;
preordertraverse（t->
lchild）;
rchild）;
voidinordertraverse（bitree&
inordertraverse（t->
voidpostordertraverse（bitree&
postordertraverse（t->
intdepth（bitree&
intdepthval,depthleft,depthright;
if（!
depthval=0;
depthleft=depth（t->
depthright=depth（t->
depthval=1+（depthleft>
depthright?
depthleft:
depthright）;
returndepthval;
4.运行、测试
//数据结构实验6源代码
malloc.h>
string.h>
//建立二叉树
typedefstructbitnode{
//初始化二叉树
voidcreatebitree（bitree&
t）{
charch;
scanf（"
ch）;
if（ch=='
'
）
t=NULL;
return;
t=（bitnode*）malloc
升级会员 