华东交通大学软件基础课设报告Word文档格式.docx
《华东交通大学软件基础课设报告Word文档格式.docx》由会员分享，可在线阅读，更多相关《华东交通大学软件基础课设报告Word文档格式.docx（28页珍藏版）》请在冰豆网上搜索。
index[2]=b3;
elements=b1*b2*b3;
base=（datatype*）malloc（elements*sizeof（datatype））;
if（!
（A->
base））return（0）;
c[0]=b2*b3;
c[1]=b3;
c[2]=1;
//error:
c[0]=1;
returnOK;
}
Statusvalue（arrayA,inti1,inti2,inti3,datatype&
x）
intoff;
if（i1<
0||i1>
=A.index[0]||i2<
=A.index[1]||i3<
=A.index[2]）
returnERROR;
off=i1*A.c[0]+i2*A.c[1]+i3*A.c[2];
x=*（A.base+off）;
Statusassign（array&
A,datatypee,inti1,inti2,inti3）
0||i2>
0||i3>
*（A.base+off）=e;
voidmain（）
inti,j,k,y=1;
arrayX;
InitArray（&
X,3,4,5）;
for（i=0;
i<
X.index[0];
i++）
{
for（j=0;
j<
X.index[1];
j++）//error:
for（j=0;
=X.index[0];
j++）
for（k=0;
k<
X.index[2];
k++）//error:
for（k=0;
=X.index[2];
k++）
{
assign（X,y++,i,j,k）;
}
}
printf（"
^^^^^^^[%d]^^^^^^^\n"
i+1）;
for（j=0;
j++）
{
for（k=0;
{
value（X,i,j,k,y）;
printf（"
%4d"
y）;
//erase:
%2d"
}
\n"
）;
2）、运行结果：
第二次上机报告
线性表的合并
1、学会线性表的合并及线性表的表示方法
2、掌握线性表的合并方法
1）、源程序：
#include<
iostream>
stdlib.h>
usingnamespacestd;
constmax=100;
#defineelemtypeint
{
elemtype*elem;
//线性表的基地址
intlength;
//线性表当前的长度
intlistsize;
//线性表当前分配的最大存储内容容量
}SeqList;
voidCreatList（SeqList*L）
cout<
<
"
输入线性表当前长度:
;
cin>
>
L->
length;
//分配空间
L->
elem=（int*）malloc（L->
length*sizeof（int））;
请输入线性表的各个元素:
for（inti=0;
i++）
{cin>
elem[i];
}
listsize=L->
}
voidMergeSeqList（SeqList*A,SeqList*B,SeqList*C）
elemtype*pa,*pb,*pc,*palast,*pblast;
pa=A->
elem;
pb=B->
C->
length=A->
length+B->
elem=（elemtype*）malloc（C->
length*sizeof（elemtype））;
C->
elem）exit（-1）;
palast=A->
elem+A->
length-1;
pblast=B->
elem+B->
pc=C->
while（pa<
=palast&
&
pb<
=pblast）
if（*pa<
=*pb）
*pc=*pa;
pc++;
pa++;
else{
*pc=*pb;
pb++;
while（pa<
=palast）{
*pc=*pa;
pc++;
pa++;
while（pb<
=pblast）
*pc=*pb;
pb++;
voidDisList（SeqList*L）
for（inti=0;
length-1;
{cout<
elem[i]<
→"
endl;
voidmain（）
SeqListA,B,C;
顺序表A：
CreatList（&
A）;
顺序表B：
B）;
MergeSeqList（&
A,&
B,&
C）;
合并后的顺序表C：
DisList（&
system（"
pause"
2）、运行结果:
第三次上机报告
1、实验题目：
队列
二、实验目的：
1.熟悉队列的排序
三、实验环境：
stdio.h>
#defineMaxsize50
structduilie
chardata[Maxsize];
intfront;
intrear;
};
voidinitduilie（structduilie*s）
s->
front=s->
rear=0;
intduilieEmpty（structduilie*s）
returns->
front==s->
rear;
intduiliefull（structduilie*s）
return（s->
rear+1）%Maxsize==s->
front;
voidenterduilie（structduilie*s,charx）
if（duiliefull（s））printf（"
¶
Ó
Á
Ð
Â
ú
Ë
else{
data[s->
rear]=x;
rear=（s->
rear+1）%Maxsize;
charoutduilie（structduilie*s）
if（s->
rear）printf（"
¿
Õ
front];
//s->
front=（s->
front+1）%Maxsize;
chara;
duilie*s;
s=（structduilie*）malloc（sizeof（structduilie））;
initduilie（s）;
a=getchar（）;
while（a!
='
\n'
）
enterduilie（s,a）;
while（!
duilieEmpty（s））
Ê
ä
³
ö
:
%c\n"
outduilie（s））;
第四次上机报告
二叉树的存储与遍历
1、熟悉二叉链表的存储结构；
2、熟练掌握生成二叉链表的过程。
#include<
malloc.h>
//#defineNULL0
#defineN100/*定义二叉树最大结点数*/
typedefstructtreenode{
//elemtypedata;
/*结点数据域的数据类型*/
intdata;
structtreenode*lchild,*rchild;
}TREENODE,*TREENODEPTY,*BTREE;
/*建立二叉树的算法*/
voidCreateTree（BTREE*root）{
intvalue,front,rear;
TREENODEPTYt,q[N];
/*q是队列，front,rear是队头队尾的下标*/
scanf（"
%d"
&
value）;
/*开始创建根结点*/
if（value==0）{*root=NULL;
return;
/*输入0表示空结点*/
*root=（TREENODEPTY）malloc（sizeof（TREENODE））;
（*root）->
data=value;
rear=front=1;
q[front]=*root;
/*根指针入队*/
while（front<
=rear）{/*队列不空*/
t=q[front];
front++;
scanf（"
if（value==0）{t->
lchild=NULL;
t->
lchild=（TREENODEPTY）malloc（sizeof（TREENODE））;
lchild->
/*建立左孩子结点*/
rear++;
q[rear]=t->
lchild;
/*左孩子入队*/
}
rchild=NULL;
rchild=（TREENODEPTY）malloc（sizeof（TREENODE））;
rchild->
/*建立右孩子结点*/
rchild;
/*右孩子入队*/
}/*while*/
}/*CreateTree*/
/*先序遍历*/
voidPreOrder（BTREEroot）{
TREENODEPTYp,s[N];
inttop=0;
/*s是栈，top是栈顶下标*/
p=root;
while
（1）{
while（p!
=NULL）{/*一直向左*/
printf（"
p->
data）;
top++;
s[top]=p;
p=p->
if（top!
=0）{/*右孩子转去递归*/
p=s[top];
top--;
}elsereturn;
}/*while
（1）*/
/*中序遍历*/
voidInOrder（BTREEroot）{
/*s是栈,top是栈顶下标*/
/*后序遍历*/
voidPostOrder（BTREEroot）{
=NULL）{
}/*一直向左递归，直到最左端*/
while
（1）{
if（s[top]->
rchild!
=NULL）{/*如果是左，返回*/
p=s[top]->
/*向右进一步，跳出循环，进入递归*/
break;
/*开始从右边返回，包括右子树不空的右返回*/
while（top!
=0&
（s[top]->
rchild==NULL||p==s[top]->
rchild））{
p=s[top];
top--;
printf（"
if（top==0）return;
}/*while
（1）*/
voidmain（）{
BTREEroot;
请按层次结构输入二叉树：
（输入0表示空结点）\n"
CreateTree（&
root）;
/*建立二叉树*/
\n先序遍历的结果：
PreOrder（root）;
\n中序遍历的结果：
InOrder（root）;
\n后序遍历的结果：
PostOrder（root）;
\n遍历完成\n"
第五次上机报告
图的遍历
1、熟悉图的几种遍历方法
2、掌握图在用邻接表表示下的遍历
iostream.h>
#defineMaxVerNum50
structedgenode
intendver;
intinform;
edgenode*edgenext;
structvexnode
charvertex;
edgenode*edgelink;
structGraph
vexnodeadjlists[MaxVerNum];
intvexnum;
intarcnum;
//队列的定义及相关函数的实现
structQueueNode
intnData;
QueueNode*next;
structQueueList
QueueNode*front;
QueueNode*rear;
voidEnQueue（QueueList*Q,inte）
QueueNode*q=newQueueNode;
q->
nData=e;
next=NULL;
if（Q==NULL）
return;
if（Q->
rear==NULL）
Q->
front=Q->
rear=q;
else
rear->
next=q;
rear=Q->
next;
voidDeQueue（QueueList*Q,int*e）
if（Q==NULL）
if（Q->
front==Q->
rear）
*e=Q->
front->
nData;
rear=NULL;
//创建图
voidCreatAdjList（Graph*G）
inti,j,k;
edgenode*p1;
edgenode*p2;
请输入顶点数和边数:
G->
vexnum>
arcnum;
开始输入顶点表:
vexnum;
cin>
adjlists[i].vertex;
G->
adjlists[i].edgelink=NULL;
开始输入边表信息:
for（k=0;
k++）
cout<
请输入边<
Vi,Vj>
对应的顶点:
i>
j;
p1=newedgenode;
p1->
endver=j;
edgenext=G->
adjlists[i].edgelink;
adjlists[i].edgelink=p1;
p2=newedgenode;
p2->
endver=i;
adjlists[j].edgelink;
adjlists[j].edgelink=p2;
//因为是无向图，所以有两次建立边表的过程
//-------------------------------------------------------------深度优先遍历
voidDFS（Graph*G,inti,intvisit[]）
adjlists[i].vertex<
"
visit[i]=1;
edgenode*p=newedgenode;
p=G->
if（G->
adjlists[i].edgelink&
!
visit[p->
endver]）
DFS（G,p->
endver,visit）;
voidDFStraversal（Graph*G,charc）//深度优先遍历
该图的深度优先遍历结果为:
intvisit[MaxVerNum];
visit[i]=0;
//全部初始化为0，即未访问状态
intm;
if（G->
adjlists[i].vertex==c）//根据字符查找序号
m=i;
DFS（G,i,visit）;
break;
//继续访问未被访问的结点
for（i=0;
if（visit[i]==0）
//-------------------------------------------------------------广度优先遍历
voidBFS（Graph*G,intv,intvisit[]）
QueueList*Q=newQueueList;
Q->
EnQueue（Q,v）;
while（Q->
rear!
=NULL）
inte=0;
DeQueue（Q,&
e）;
adjlists[e].vertex<
visit[e]=1;
edgenode*p=newedgenode;
p=G->
adjlists[e].edgelink;
if（p）
intm=p->
endver;
if（m==0）
EnQueue（Q,m）;
while（visit[m]==0）
{
升级会员 