计算机软件应用结课作业Word文档下载推荐.docx
《计算机软件应用结课作业Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《计算机软件应用结课作业Word文档下载推荐.docx（30页珍藏版）》请在冰豆网上搜索。
y=max（a,mid,right）;
returnx>
y?
x:
y;
}
voidmain（）
intn,i;
inta[1000];
cin>
n;
for（i=0;
i<
i++）cin>
a[i];
cout<
<
max（a,0,n）<
endl;
2、编写用回溯法求解n皇后的算法
n个皇后在n元棋盘上的布局有n的n次方种，用回溯发求解问题。
假设定义一个长度为n的一维数组q，其中的每一个元素q[i]（i=1,2,...,n）随时记录第n行上的皇后所在的序列号。
初始时，先将各皇后放在各行的第一列。
即数组q的初值为|q[i]-q[j]|=|i-j|
而它们在同一列上的条件为q[i]=q[j]
#include<
cmath>
classNQueen
private:
intnumOfQueen;
//thenumberofqueens
intnumOfanswer;
//thenumberofanswers
int*queen;
public:
NQueen（）;
NQueen（intm）;
~NQueen（）;
boolplace（intk）;
voidbacktrack（intt）;
voidshowQueen（）;
};
NQueen:
:
NQueen（）
numOfQueen=0;
numOfanswer=0;
queen=newint[1];
NQueen（intm）
numOfQueen=m;
queen=newint[m+1];
for（inti=0;
=m;
i++）
queen[i]=0;
~NQueen（）
delete[]queen;
cout<
"
queensaredeleted!
voidNQueen:
showQueen（）
for（inti=1;
=numOfQueen;
queen[i]<
"
;
boolNQueen:
place（intk）//theconstraintfunction
for（intj=1;
j<
k;
j++）
if（（fabs（k-j）==fabs（queen[j]-queen[k]））||（queen[j]==queen[k]））
returnfalse;
returntrue;
backtrack（intt）
inti=0;
if（t>
numOfQueen）
numOfanswer++;
showQueen（）;
else
for（i=1;
i<
i++）
queen[t]=i;
if（place（t））
backtrack（t+1）;
voidbacktrack（intt）
{
n）
output（x）;
for（i=f（n,t）;
=g（n,t）;
x[t]=h（i）;
if（constraint（t）&
&
bound（t））
}
voiditerativeBack（）
intt=1;
while（t>
0）
if（f（n,t）<
g（n,t））
for（i=f（n,t）;
x[t]=h（i）;
if（constraint（t）&
if（solution（t））
output（x）;
elset++;
elset--;
if（t>
else
for（i=0;
=1;
x[t]=i;
backtrack（t+1）;
for（i=t;
=n;
swap（x[t],x[i]）;
intmain（）
intm1=4,m2=8;
NQueenQ1（m1）;
thenumberofqueensare:
m1<
Q1.backtrack
（1）;
NQueen*Q2=newNQueen（m2）;
m2<
Q2->
backtrack
（1）;
return0;
}
3、给定n个城市间的距离，求从一个城市0出发经过其他城市一次且一次的一条最短路径（15分）。
从理论上讲，可以计算出最短路径，但要借助计算机，计算量较大，人力难以胜任。
方法如下：
假定出发城市编号为0，其他城市编号为1～n-1，将1～n-1号城市排列，按排列顺序计算每种排列从排头城市到排尾城市的距离和X，实际距离D=X+0和排头城市的距离+0和排尾城市的距离，这样共得到A<
n-1>
=（n-1）!
个距离D，从中选出最小的一个即可。
编一段简单程序，把n个城市间的距离输入进去，就能轻易算出最短距离
stdio.h>
{
intG[100][100]={0};
//一个记录图的邻接矩阵
inta,b,w;
//输入一共有7条边,5个点
inti,j,k;
for（i=1;
i<
=5;
i++）
for（j=1;
j<
j++）
G[i][j]=9999999;
for（i=1;
=7;
{
scanf（"
%d%d%d"
&
a,&
b,&
w）;
//输入每条边的信息，a和b代表这条边的两个顶点w代表两个点的距离
G[a][b]=w;
G[b][a]=w;
}
for（k=1;
k<
k++）
for（i=1;
for（j=1;
if（G[i][j]>
G[i][k]+G[k][j]）
G[i][j]=G[i][k]+G[k][j];
printf（"
%d"
G[1][4]）;
//输出两点之间的最短路，这里的两个点是3和5
return0;
}//G[i][j]代表i到j的距离，甲，乙，丙，丁，戊用1，2，3，4，5代替
4、将单链表看做二叉树，编写递归程序打印单链表
建立和遍历二叉树的程序都比较简单，关键在于按要求打印二叉树。
起初一直找不到合适的方法按题目要求打印二叉树，在和同学讨论了很久之后终于有了思路。
打印的格式中，最上层的节点是右子树层次最高的，于是就可以用递归调用的方式实现。
递归次数最高的就是输出最顶置的节点。
在调试程序的时候也出现了问题，起初没有在意输入方式对程序运行结果的影响，导致程序无法运行，在检查了很久之后终于找到了问题的所在，对输入进行了改正，得到了正确的结果。
在建立二叉树时，输入的格式一定要正确，没有孩子的要用空格表示，在测试用例中，F没有孩子，要用两个空格表示，如果输入“AB#D##CE#F”则没有输出结果。
stdlib.h>
malloc.h>
time.h>
#defineNUM_NODE12
#defineMOST_DEPTH10
typedefstructBiTree{
intdata;
BiTree*lchild;
BiTree*rchild;
}BiTree;
typedefstructAnswear{
intDegree0;
intDegree1;
intDegree2;
intDepth;
}Answear;
BiTree*CreateTree（intn）
BiTree*t;
if（n<
=0||n>
NUM_NODE）returnNULL;
if（!
（t=（BiTree*）malloc（sizeof（BiTree））））
returnNULL;
t->
data=n;
printf（"
%d"
t->
data）;
lchild=CreateTree（2*n）;
rchild=CreateTree（2*n+1）;
returnt;
voidFreeTree（BiTree*t）
if（t）
if（t->
lchild）
FreeTree（t->
lchild）;
rchild）
rchild）;
printf（"
free（t）;
//中序遍历
voidInOrder（BiTree*t）
BiTree**stack,**top,*p;
//创建堆栈
（stack=（BiTree**）malloc（NUM_NODE*sizeof（BiTree））））
InOrderfailedformemery\n"
）;
return;
//初始化堆栈
top=stack;
p=t;
while（p||top>
stack）//p不为NULL，堆栈不空
if（p）
{
*top++=p;
//p入堆栈
p=p->
lchild;
}
else
p=*--top;
//p出栈
if（p）printf（"
p->
rchild;
//前序遍历
voidPreOrder（BiTree*t）
stack）
//后序遍历
voidPostOrder（BiTree*t）
BiTree**stack,**top,*p,*p_old,*p_new;
intFlag;
Flag=0;
*top++=t;
while（top>
stack）
p=*（top-1）;
if（p->
lchild&
!
Flag）
*top++=p->
if（p->
{
*top++=p->
Flag=0;
}
else
p_old=*--top;
printf（"
p_old->
while（top>
{
p_new=*（top-1）;
if（p_old==p_new->
{
Flag=1;
break;
}
else
p_new=*--top;
printf（"
p_new->
p_old=p_new;
Flag=0;
}
//中序遍历求结点的深度和度为0，1,2的结点数，结果保存在pAns指的。
。
voidInOrderDO（BiTree*t,Answear*pAns）
//遍历用的数据
//求深度的数据
intcurDeep,MostDeep;
//初始化数据
curDeep=MostDeep=0;
pAns->
Degree0=pAns->
Degree1=pAns->
Degree2=0;
//遍历循环
curDeep++;
if（MostDeep<
curDeep）MostDeep=curDeep;
//保存最深度
curDeep--;
//if（p）printf（"
//Visit结点
//计算个结点的度
p->
rchild）pAns->
Degree2++;
elseif（p->
lchild||p->
Degree1++;
elsepAns->
Degree0++;
//得到深度
Depth=MostDeep;
return;
//前序递归求广度
voidPre（BiTree*T,int*woed,intdepth）
woed[depth]++;
if（T->
lchild）Pre（T->
lchild,woed,depth+1）;
rchild）Pre（T->
rchild,woed,depth+1）;
//求广度的程序，返回值为广度
intGetTreeWidth（BiTree*root）
inti,WidthOfEachDepth[MOST_DEPTH]={0};
Pre（root,WidthOfEachDepth,0）;
for（i=1;
MOST_DEPTH;
if（WidthOfEachDepth[0]<
WidthOfEachDepth[i]）
WidthOfEachDepth[0]=WidthOfEachDepth[i];
returnWidthOfEachDepth[0];
BiTree*root;
Answearans;
CreateTree\n"
root=CreateTree
（1）;
\nInOrder\n"
InOrder（root）;
\nPreOrder\n"
PreOrder（root）;
\nPostOrder\n"
PostOrder（root）;
InOrderDO（root,&
ans）;
\nTheMostDepthis:
%d\n"
ans.Depth）;
TheMostWidthis:
GetTreeWidth（root））;
EachDegree（0,1,2）is:
（%d,%d,%d）\n"
ans.Degree0,ans.Degree1,ans.Degree2）;
\nFreeTree\n"
FreeTree（root）;
return0;
5、编写二叉树的层次遍历算法
二叉树结构是一种非常重要的非线性数据结构，在遍历的过程中先遍历左子数，后遍历右子树。
在先左后右的原则下，根据访问根结点的次序，最后根据二叉树的三种遍历方法，即前序遍历、中序遍历、后序遍历，进行算法的书写。
//二叉树层次遍历算法
alloc.h>
#defineMaxSize1000
typedefcharElemType;
typedefstructnode
ElemTypedata;
structnode*lchild;
structnode*rchild;
}BTNode;
//创建二叉树
voidCreateBTNode（BTNode*&
b,char*str）
BTNode*St[MaxSize],*p=NULL;
inttop=-1,k,j=0;
charch;
b=NULL;
ch=str[j];
while（ch!
='
\0'
）
switch（ch）
case'
（'
top++;
St[top]=p;
k=1;
break;
）'
top--;
'
k=2;
default:
p=（BTNode*）malloc（sizeof（BTNode））;
data=ch;
p->
lchild=p->
rchild=NULL;
if（b==NULL）b=p;
switch（k）
case1:
St[top]->
lchild=p;
case2:
rchild=p;
}
j++;
//层次遍历算法
voidLevelOrder（BTNode*b）
BTNode*p;
BTNode*qu[MaxSize];
intfront,rear;
front=rear=-1;
rear++;
qu[rear]=b;
while（front!
=
升级会员 