数组与稀疏矩阵及广义表递归Word下载.docx
《数组与稀疏矩阵及广义表递归Word下载.docx》由会员分享，可在线阅读，更多相关《数组与稀疏矩阵及广义表递归Word下载.docx（14页珍藏版）》请在冰豆网上搜索。
4、掌握递归算法的设计，递归算法到非递归算法的转换；
二．实验环境
装有VisualC++6.0的计算机一台。
三、实验内容与步骤
<
一>
数组实验—约瑟夫问题：
实验代码分析:
#include"
stdafx.h"
#include<
stdio.h>
#defineMaxSize100
voidjosephus（intn,intm）
{
intp[MaxSize];
inti,j,t;
for（i=0;
i<
n;
i++）/*构建初始序列*/
p[i]=i+1;
t=0;
/*首次报数的起始位置*/
printf（"
出列顺序:
"
）;
for（i=n;
i>
=1;
i--）/*i为数组p中的人数*/
{
t=（t+m-1）%i;
/*t为出列者的编号*/
printf（"
%d"
p[t]）;
/*编号为t的元素出列*/
for（j=t+1;
j<
=i-1;
j++）/*后面的元素前移一个位置*/
p[j-1]=p[j];
}
\n"
}
voidmain（）
josephus（8,4）;
实验截图：
实验结果：
二>
稀疏矩阵—实现两个稀疏矩阵的加法：
用i和j作为两个三元组的指针，以行序对它们的当前值进行相加运算，并将结果存放在c中。
具体算法如下：
实验代码分析：
tup.cpp"
intMatAdd（TSMatrixa,TSMatrixb,TSMatrix&
c）
inti=0,j=0,k=0;
ElemTypev;
if（a.rows!
=b.rows||a.cols!
=b.cols）
return0;
/*行数或列数不等时不能进行相加运算*/
c.rows=a.rows;
c.cols=a.cols;
/*c的行列数与a的相同*/
while（i<
a.nums&
&
j<
b.nums）/*处理a和b中的每个元素*/
{
if（a.data[i].r==b.data[j].r）/*行号相等时*/
{
if（a.data[i].c<
b.data[j].c）/*a元素的列号小于b元素的列号*/
{
c.data[k].r=a.data[i].r;
/*将a元素添加到c中*/
c.data[k].c=a.data[i].c;
c.data[k].d=a.data[i].d;
k++;
i++;
}
elseif（a.data[i].c>
b.data[j].c）/*a元素的列号大于b元素的列号*/
c.data[k].r=b.data[j].r;
/*将b元素添加到c中*/
c.data[k].c=b.data[j].c;
c.data[k].d=b.data[j].d;
k++;
j++;
else/*a元素的列号等于b元素的列号*/
{
v=a.data[i].d+b.data[j].d;
if（v!
=0）/*只将不为0的结果添加到c中*/
{
c.data[k].r=a.data[i].r;
c.data[k].c=a.data[i].c;
c.data[k].d=v;
k++;
}
i++;
elseif（a.data[i].r<
b.data[j].r）/*a元素的行号小于b元素的行号*/
c.data[k].r=a.data[i].r;
/*将a元素添加到c中*/
c.data[k].c=a.data[i].c;
c.data[k].d=a.data[i].d;
k++;
else/*a元素的行号大于b元素的行号*/
{
c.data[k].r=b.data[j].r;
c.data[k].c=b.data[j].c;
c.data[k].d=b.data[j].d;
c.nums=k;
return1;
ElemTypea[M][N]={{1,0,3},{0,2,0},{0,0,5}};
ElemTypeb[M][N]={{-1,0,2},{0,-2,0},{1,0,-5}};
TSMatrixx,y,z;
CreatMat（x,a）;
CreatMat（y,b）;
MatAdd（x,y,z）;
a的三元组:
DispMat（x）;
b的三元组:
DispMat（y）;
相加后的三元组:
DispMat（z）;
三>
广义表的基本运算：
广义表是一种非线性的数据结构，顾名思义，它也是线性表的一种推广。
它被广泛的应用于人工智能等领域的表处理语言LISP语言中。
在LISP语言中，广义表是一种最基本的数据结构。
线性表被定义为一个有限的序列（a1，a2，a3，…，an）其中ai被限定为是单个数据元素。
广义表也是n个数据元素d1，d2，d3，…，dn的有限序列，但不同的是，广义表中的di则既可以是单个元素，还可以是一个广义表，通常记作：
GL=（d1，d2，d3，…，dn）。
GL是广义表的名字，通常广义表的名字用大写字母表示。
n是广义表的长度。
若其中di是一个广义表，则称di是广义表GL的子表。
在广义表GL中，d1是广义表GL的表头，而广义表GL其余部分组成的表（d2，d3，…，dn）称为广义表的表尾。
广义表的基本运算有：
1.求广义表的长度
在广义表中,同一层次的每个结点是通过link域链接起来的,所以可把它看做是由link域链接起来的单链表。
这样,求广义表的长度就是求单链表的长度,可以采用以前介绍过的求单链表长度的方法求其长度。
求广义表长度的非递归算法如下：
intGLLength（GLNode*g）/*g为一个广义表头结点的指针*/
intn=0;
g=g->
val.sublist;
/*g指向广义表的第一个元素*/
while（g!
=NULL）
{n++;
link;
returnn;
2.求广义表的深度
对于带头结点的广义表g,广义表深度的递归定义是它等于所有子表中表的最大深度加1。
若g为原子,其深度为0。
intGLDepth（GLNode*g）/*求带头结点的广义表g的深度*/
{intmax=0,dep;
if（g->
tag==0）return0;
/*为原子时返回0*/
/*g指向第一个元素*/
if（g==NULL）return1;
/*为空表时返回1*/
=NULL）/*遍历表中的每一个元素*/
{if（g->
tag==1）/*元素为子表的情况*/
{dep=GLDepth（g）;
/*递归调用求出子表的深度*/
if（dep>
max）max=dep;
/*max为同一层所求过的子表中深度的最大值*/
/*使g指向下一个元素*/
return（max+1）;
/*返回表的深度*/
3.建立广义表的链式存储结构
假定广义表中的元素类型ElemType为char类型,每个原子的值被限定为英文字母。
并假定广义表是一个表达式,其格式为：
元素之间用一个逗号分隔,表元素的起止符号分别为左、右圆括号,空表在其圆括号内不包含任何字符。
例如“（a,（b,c,d））”就是一个符合上述规定的广义表格式。
生成广义表链式存储结构的算法如下：
GLNode*CreatGL（char*&
s）
{GLNode*h;
charch=*s++;
/*取一个扫描字符*/
if（ch!
='
\0'
）/*串未结束判断*/
{h=（GLNode*）malloc（sizeof（GLNode））;
/*创建新结点*/
if（ch=='
（'
）/*当前字符为左括号时*/
{h->
tag=1;
/*新结点作为表头结点*/
h->
val.sublist=CreatGL（s）;
/*递归构造子表并链到表头结点*/
elseif（ch=='
）'
）
h=NULL;
/*遇到'
字符,子表为空*/
else
tag=0;
/*新结点作为原子结点*/
h->
val.data=ch;
elseh=NULL;
/*串结束,子表为空*/
ch=*s++;
/*取下一个扫描字符*/
if（h!
=NULL）/*串未结束判断*/
if（ch=='
'
）/*当前字符为'
*/
link=CreatGL（s）;
/*递归构造后续子表*/
else/*串结束*/
link=NULL;
/*处理表的最后一个元素*/
returnh;
/*返回广义表指针*/
}
4.输出广义表
以h作为带表头附加结点的广义表的表头指针,打印输出该广义表时,需要对子表进行递归调用。
输出一个广义表的算法如下：
voidDispGL（GLNode*g）/*g为一个广义表的头结点指针*/
{if（g!
=NULL）/*表不为空判断*/
tag==1）/*为表结点时*/
{printf（"
（"
/*输出'
val.sublist==NULL）printf（"
/*输出空子表*/
elseDispGL（g->
val.sublist）;
/*递归输出子表*/
elseprintf（"
%c"
g->
val.data）;
/*为原子时输出元素值*/
if（g->
tag==1）printf（"
）"
/*为表结点时输出'
link!
"
DispGL（g->
link）;
/*递归输出后续表的内容*/
}
四>
递归算法的使用——求解“皇后”问题
设在初始状态下在国际象棋棋盘上没有任何棋子（皇后）。
然后顺序在第1行，第2行，…。
第8行上布放棋子。
在每一行中有8个可选择位置，但在任一时刻，棋盘的合法布局都必须满足
升级会员 