第五次大数据结构上机实验报告材料.docx

第五次大数据结构上机实验报告材料.docx

《第五次大数据结构上机实验报告材料.docx》由会员分享，可在线阅读，更多相关《第五次大数据结构上机实验报告材料.docx（11页珍藏版）》请在冰豆网上搜索。

第五次大数据结构上机实验报告材料

一、调试成功程序及说明

1、

题目：

1．编程实现书P156ADTGraph基本操作13个，用邻接矩阵存储结构实现；

算法思想：

以邻接矩阵的形式实现操作

源程序：

#defineINFINITYINT_MAX//最大值为无穷大

#defineMAX_VERTEX_NUM20//最大顶点个数

#include

usingnamespacestd;

typedefenum{DG,DN,AG,AN}GraphKind;//{有向图，有向网，无向图，无向网}

typedefintStatus;

typedefintVRType;

typedefcharInfoType;

typedefstructArcCell{

VRTypeadj;//表示顶点关系，对于无向图有向图用0和1表示是否相邻，对于有向图有向网用权值类型表示

InfoType*info;//该弧相关信息的指针

}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedefstruct{//点的值

charname;

char*data;

}VertexType[MAX_VERTEX_NUM];

typedefstruct{

VertexTypevexs;//顶点向量

AdjMatrixarcs;//邻接矩阵

intvexnum;//图的当前顶点数

intarcnum;//图的当前弧数

GraphKindkind;//图的种类标志

}MGraph;

//***********************以下操作默认是无向网，即Kind=AG**************************

//***********************顶点是名称字母。

书上的是数字，例如v************************

StatusLocateVex（MGraphG,charu）{

if（G.vexnum==0）return-1;//图不存在

inti;

for（i=0;i

if（G.vexs[i].name==u）

returni;

return-2;//图中不存在与u相等的点

}

StatusCreateGraph（MGraph&G）{

inti,j,k;

VRTypew;

charv1,v2;

chardata[50];

cout<<"你想要创建几个顶点？

"<

cin>>G.vexnum;

cout<<"你想要创建几条弧？

"<

cin>>G.arcnum;

cout<<"依次输入顶点名称:

"<

for（i=0;i

cin>>G.vexs[i].name;//构造顶点向量

for（i=0;i

for（j=0;j

G.arcs[i][j].adj=INFINITY;//初始化邻接矩阵

G.arcs[i][j].info=NULL;

}

for（k=0;k

cout<<"输入一条边依附的两个顶点:

";

cin>>v1>>v2;

cout<<"输入这条边的权值:

"<

cin>>w;

cout<<"输入这条边的信息:

"<

cin>>data;

i=LocateVex（G,v1）;

j=LocateVex（G,v2）;

G.arcs[i][j].adj=w;

G.arcs[i][j].info=data;

G.arcs[j][i]=G.arcs[i][j];

}

return1;

}

StatusDestroyGraph（MGraph&G）{

G.vexnum=NULL;

G.arcnum=NULL;

return1;

}

char*GetVex（MGraphG,charv）{

if（G.vexnum==0）returnNULL;

inti;

i=LocateVex（G,v）;

if（i>=0）//判断是否是图上的顶点，后面的函数省略了这一步

returnG.vexs[i].data;

else

returnNULL;

}

StatusPutVex（MGraph&G,charv,char*value）{

if（G.vexnum==0）return0;

inti;

i=LocateVex（G,v）;

G.vexs[i].data=value;

return1;

}

//VertexTypeFirstAdjVex（MGraphG,charv）{}//返回第一个邻接顶点，邻接表操作

//VertexTypeNextAdjVex（MGraphG,charv,charw）{}//邻接表操作

StatusInsertVex（MGraph&G,charv）{

if（G.vexnum==0）return0;

inti;

G.vexs[G.vexnum].name=v;

G.vexnum++;

for（i=0;i

G.arcs[i][G.vexnum-1].adj=INFINITY;

G.arcs[G.vexnum-1][i].adj=INFINITY;

}

return1;

}

StatusDeleteVex（MGraph&G,charv）{

if（G.vexnum==0）return0;

inti,j,k;

k=LocateVex（G,v）;

for（i=0,j=0;i

if（G.arcs[i][k].adj!

=INFINITY）

j++;

for（i=k;i

G.vexs[i]=G.vexs[i+1];

G.vexs[i].name=NULL;

G.vexs->data=NULL;

G.vexnum--;

G.arcnum=G.arcnum-j;

return1;

}

StatusInsertArc（MGraph&G,charv,charw）{

if（G.vexnum==0）return0;

inti,j;

VRTypeq;

chardata[50];

i=LocateVex（G,v）;

j=LocateVex（G,w）;

cout<<"输入这条边的权值:

"<

cin>>q;

cout<<"输入这条边的信息:

"<

cin>>data;

G.arcs[i][j].adj=q;

G.arcs[i][j].info=data;

G.arcs[j][i]=G.arcs[i][j];

G.arcnum=G.arcnum+2;

return1;

}

StatusDeleteArc（MGraph&G,charv,charw）{

if（G.vexnum==0）return0;

inti,j;

i=LocateVex（G,v）;

j=LocateVex（G,w）;

G.arcs[i][j].adj=INFINITY;

G.arcs[i][j].info=NULL;

G.arcs[j][i]=G.arcs[i][j];

G.arcnum=G.arcnum-2;

return1;

}

StatusPrint（MGraphG）{

inti,j;

for（i=0;i

for（j=0;j

cout<

cout<

}

return1;

}

intmain（）

{

intj;

chari,c,d;

MGraphG;

CreateGraph（G）;

cout<<"此时矩阵为:

"<

Print（G）;

cout<<"输入i：

:

";

cin>>i;

j=LocateVex（G,i）;

cout<<"i为第"<

cout<<"为两个点添加边，输入添加边的两个顶点:

"<

cin>>c>>d;

InsertArc（G,c,d）;

cout<<"此时矩阵为:

"<

Print（G）;

DeleteArc（G,c,d）;

cout<<"添加顶点V；"<

cout<<"此时矩阵为:

"<

Print（G）;

c='V';

InsertVex（G,c）;

cout<<"此时矩阵为:

"<

Print（G）;

cout<<"删除顶点B；"<

d='B';

DeleteVex（G,d）;

cout<<"此时矩阵为:

"<

Print（G）;

DestroyGraph（G）;

return0;

}

运行结果：

2、

题目：

2.哈夫曼树的建立。

算法思想：

（1）将w1、w2、…，wn看成是有n棵树的森林（每棵树仅有一个结点）；

（2）在森林中选出两个根结点的权值最小的树合并，作为一棵新树的左、右子树，且新树的根结点权值为其左、右子树根结点权值之和；

（3）从森林中删除选取的两棵树，并将新树加入森林；

（4）重复

（2）、（3）步，直到森林中只剩一棵树为止，该树即为所求得的哈夫曼树。

源程序：

#include

#defineMAXVALUE100000

usingnamespacestd;

constintn=4;//叶子节点个数

//构造哈夫曼树结点

typedefstruct{

intweight;//权值

intparent;//父节点

intlchild;//左子树

intrchild;//右子树

}HNodeType;

HNodeTypeHFMTree[2*n-1];//结点数

//构造哈夫曼编码数组

typedefstruct{

intbit[n];

intstart;

}HCodeType;

HCodeTypeHFMCode[n];

//创建哈夫曼树

voidcreateHFMTree（HNodeTypeHFMTree[],intn）{

intm1,x1,m2,x2;

inti,j;

//初始化

for（i=0;i<2*n-1;i++）{

HFMTree[i].weight=0;

HFMTree[i].parent=-1;

HFMTree[i].lchild=-1;

HFMTree[i].rchild=-1;

}

cout<<"请输入结点权值：

"<

for（i=0;i

cin>>HFMTree[i].weight;

}

for（i=0;i

x1=x2=MAXVALUE;

m1=m2=0;

for（j=0;j

if（HFMTree[j].parent==-1&&HFMTree[j].weight

x2=x1;

m2=m1;

x1=HFMTree[j].weight;

m1=j;

}

elseif（HFMTree[j].parent==-1&&HFMTree[j].weight

x2=HFMTree[j].weight;

m2=j;

}

}

HFMTree[m1].parent=n+i;HFMTree[m2].parent=n+i;

HFMTree[n+i].weight=HFMTree[m1].weight+HFMTree[m2].weight;

HFMTree[n+i].lchild=m1;

HFMTree[n+i].rchild=m2;

}

}

//转化编码

voidcreateHFMCode（HNodeTypeHFMTree[],HCodeTypeHFMCode[]）{

HCodeTypecd;

inti,j,c,p;

for（i=0;i

cd.start=n-1;

c=i;

p=HFMTree[c].parent;

while（p!

=-1）

{

if（HFMTree[p].lchild==c）cd.bit[cd.start]=0;

elsecd.bit[cd.start]=1;

cd.start--;

c=p;

p=HFMTree[c].parent;

}

for（j=cd.start+1;j

HFMCode[i].bit[j]=cd.bit[j];

HFMCode[i].start=cd.start+1;

}

}

//主函数

intmain（）

{

inti,j;

//创建树

createHFMTree（HFMTree,n）;

//转码

createHFMCode（HFMTree,HFMCode）;

cout<

for（i=0;i

{

for（j=HFMCode[i].start;j<=n-1;j++）

{

cout<

}

cout<

}

return0;

}

运行结果：