数据结构课程设计图 指针的指针.docx

数据结构课程设计图 指针的指针.docx

《数据结构课程设计图 指针的指针.docx》由会员分享，可在线阅读，更多相关《数据结构课程设计图 指针的指针.docx（23页珍藏版）》请在冰豆网上搜索。

数据结构课程设计图指针的指针

课程设计

课程：

数据结构

题目：

图11（邻接表）

班级：

信管08级

姓名：

XXXXXX

学号：

XXXXXXXX

设计时间：

2010年01月10日——2010年05月10日

成绩：

指导教师：

XXXXXXXX

一、题目

题目

图11

结构

邻接表

表示

顶点链的头指针

回传方式

指针的指针

操作

图的基本操作

二、概要设计

1.存储结构

typedefstructvnode//顶点结构

{

chard;//顶点信息

structlnode*h;//邻接表表头

structvnode*next;//指向下一个顶点

charch;//遍历过程中访问标记

}*Net;

structlnode//邻接表结点结构

{

structvnode*a;//出端

structlnode*next;//指向下一个邻接点

};

图的邻接表存储（顶点链）：

h－

→

－

→…→

顶点

—

→…

—

→

入端地址

—

→…

入端地址

—

→…

2．.设计要点

（1）Netins_V（Net*G,charv）//插入顶点

（2）Netins_E（Net*G,charu,charv,floatc）//插入边

（3）NetDeleteEdge（Net*G,charVertex1,charVertex2）//删除边

（4）NetDeleteVertex（Net*G,charVertex）//删除顶点

（5）voidout1（Net*G）//输出

（6）voidout2（Net*G）//输出

（7）Netcreat1（Net*G）//创建图

（8）Netcreat2（Net*G）//创建图

（9）NetDFS（Net*G,charVertex）//广度优先遍历

（10）NetBFSM（Net*G,vnode&_ver）//深度优先遍历

（11）NetDFSL（Net*G）//深度优先遍历以邻接表存储的图G

3．存储要点

（1）创建图Netcreat1（Net*G）//创建

Netp=newvnode;

（2）插入顶点：

Netins_V（NetG,charv）：

通过扫描图的顶点链表，找到链表的尾部，在尾部添加一个顶点。

（3）插入边：

Netins_E（NetG,charu,charv）：

找到边顶点的地址，在相应的顶点下，将地址添加到链表中，一般追加到链表的尾部。

四源程序

#include

usingnamespacestd;

typedefstructvnode//顶点结构

{

chard;//顶点信息

structlnode*h;//邻接表表头

structvnode*next;//指向下一个顶点

charch;//遍历过程中访问标记

}*Net;

structlnode//邻接表结点结构

{

structvnode*a;//出端地址

structlnode*next;//指向下一个邻接点

};

structQNode//图的广度优先遍历，用到队列，再次定义队列

{

vnode*Ver;

QNode*Next;

};

structLQNode

{

QNode*front;

QNode*rear;

};

classQueue

{

public:

Queue（）;

~Queue（）;

boolEmptyQueue（）;

voidAddQueueNodeVertex（QNode**NV）;

vnode*DeleteQueueNodeVertex（）;

private:

LQNode*LQ;

};

Queue:

:

Queue（）{this->LQ=NULL;}

Queue:

:

~Queue（）{}

boolQueue:

:

EmptyQueue（）

{

if（this->LQ==NULL）

return1;

else

return0;

}

voidQueue:

:

AddQueueNodeVertex（QNode**NV）

{

QNode*P;

P=newQNode;

P->Ver=（*NV）->Ver;

P->Next=NULL;

if（this->LQ==NULL）

{

this->LQ=newLQNode;

this->LQ->front=P;

this->LQ->rear=P;

}

else

{

this->LQ->rear->Next=P;

this->LQ->rear=P;

}

}

vnode*Queue:

:

DeleteQueueNodeVertex（）

{

if（this->EmptyQueue（））

cout<<"对空！

！

！

"<

else

{

if（this->LQ->front==this->LQ->rear）

{

vnode*Q;

Q=this->LQ->front->Ver;

deletethis->LQ->front;

deletethis->LQ;

this->LQ=NULL;

returnQ;

}

else

{

vnode*Q;

QNode*P=this->LQ->front;

this->LQ->front=this->LQ->front->Next;

Q=P->Ver;

deleteP;

returnQ;

}

}

}

Netins_V（Net*G,charv）//插入顶点

{

Net_G=*G;

if（*G==NULL）

{

Netp=newvnode;

p->next=*G;

*G=p;

（*G）->h=0;

（*G）->d=v;

（*G）->ch='0';

}

else

{

while（_G->d!

=v&&_G->next!

=NULL）

{

_G=_G->next;

}

if（_G->next==NULL）

{

Netp=newvnode;

p->next=*G;

*G=p;

（*G）->h=0;

（*G）->d=v;

（*G）->ch='0';

}

else

{

cout<<"节点重复，请按任意键推出：

";

getchar（）;

exit

（1）;

}

}

return*G;

}

Netins_E（Net*G,charu,charv,floatc）//插入边

{

Netp=*G,q=*G;

lnode*r;

while（p&&p->d!

=u）p=p->next;

while（q&&q->d!

=v）q=q->next;

r=newlnode;

r->next=p->h;

r->a=q;

p->h=r;

return*G;

}

voidout1（Net*G）//输出

{

Netp=*G;lnode*q;

while（p）{

cout<<"顶点"<d<<"出端:

";

q=p->h;

if（q）{cout<a->d<<'';q=q->next;}

while（q）{cout<a->d<<'';q=q->next;}

cout<

p=p->next;

}

}

voidout2（Net*G）//输出

{

Netp=*G;lnode*q;

while（p）{

cout<<"顶点"<d<<"出端:

";

q=p->h;

if（q）{cout<a->d<<'';q=q->next;}

while（q）{cout<a->d<<'';q=q->next;}

cout<

p=p->next;

}

}

Netcreat1（Net*G）//创建图

{

*G=ins_V（G,'d'）;*G=ins_V（G,'c'）;

*G=ins_V（G,'b'）;*G=ins_V（G,'a'）;

*G=ins_E（G,'a','b',8）;

*G=ins_E（G,'a','c',7）;

*G=ins_E（G,'b','c',6）;

*G=ins_E（G,'c','d',5）;

*G=ins_E（G,'d','a',6）;

return*G;

}

Netcreat2（Net*G）//创建图

{

*G=ins_V（G,'p'）;*G=ins_V（G,'l'）;

*G=ins_V（G,'q'）;*G=ins_V（G,'n'）;

*G=ins_V（G,'m'）;

*G=ins_E（G,'m','n',6）;

*G=ins_E（G,'m','q',8）;

*G=ins_E（G,'n','q',9）;

*G=ins_E（G,'q','l',6）;

*G=ins_E（G,'l','p',5）;

*G=ins_E（G,'p','m',4）;

return*G;

}

voidVisit（charVertex）

{

cout<

}

boolJudgementInDegree（vnode&ver1,vnode&ver2）//判断ver1是否是ver2的入度接点

{

if（&ver1==&ver2）

{

return0;

}

else

{

if（ver1.h==NULL）

return0;

else

{

lnode*NE=NULL;

NE=ver1.h;

while（NE->next!

=NULL&&NE->a!

=&ver2）

{

NE=NE->next;

}

if（NE->a==&ver2）

return1;

else

return0;

}

}

}

NetDFS（Net*G,charVertex）

{

//ver1指向当前接点所在

vnode*ver1=NULL;

vnode*ver=*G;

while（ver->d!

=Vertex&&ver->next!

=NULL）

{

ver=ver->next;

}

if（ver->next==NULL&&ver->d!

=Vertex）

cout<<"输入顶点数据错误，程序退出！

！

！

"<

else

ver1=ver;

structnode

{

vnode*Ver;

node*next;

};

node*M=NULL;

node*N=NULL;

lnode*NE=NULL;

if（ver1->h==NULL）

M=NULL;

else

{

NE=ver1->h;

//M指向邻接点链表的头结点

M=newnode;

M->Ver=NE->a;

M->next=NULL;

N=M;

while（NE->next!

=NULL）

{

node*L=newnode;

L->Ver=NE->next->a;

L->next=NULL;

N->next=L;

N=L;

NE=NE->next;

}

}

ver=*G;

while（ver!

=NULL）

{

if（ver!

=ver1）

{

if（JudgementInDegree（*ver,*ver1））

{

node*LL=newnode;

LL->Ver=ver;

LL->next=NULL;

if（N==NULL）

{

N=LL;

M=N;

}

else

{

N->next=LL;

}

}

}

ver=ver->next;

}

node*k;

k=M;

ver1->ch='1';

Visit（ver1->d）;

for（k=M;k!

=NULL;k=k->next）

{

if（k->Ver->ch=='0'）

DFS（G,k->Ver->d）;

}

return*G;

}

NetBFSM（Net*G,vnode&_ver）

{

vnode*_g=*G;

do

{

_g->ch='0';

_g=_g->next;

}while（_g!

=NULL）;

QueueQue;

vnode*H;

Visit（_ver.d）;

_ver.ch='1';

QNode*P=newQNode;

P->Ver=&_ver;

Que.AddQueueNodeVertex（&P）;

while（Que.EmptyQueue（）!

=1）

{

H=Que.DeleteQueueNodeVertex（）;

QNode*M=NULL;

QNode*N=NULL;

vnode*ver;

lnode*NE=NULL;

if（H->h==NULL）

M=NULL;

else

{

NE=H->h;

//M指向邻接点链表的头结点

M=newQNode;

M->Ver=NE->a;

M->Next=NULL;

N=M;

while（NE->next!

=NULL）

{

/*N->Vnext=NE->Enext->Edge;

N=NE->Enext->Edge;

NE=NE->Enext;*/

QNode*L=newQNode;

L->Ver=NE->next->a;

L->Next=NULL;

N->Next=L;

N=L;

NE=NE->next;

}

}

ver=*G;

while（ver!

=NULL）

{

if（ver!

=H）

{

if（JudgementInDegree（*ver,*H））

{

QNode*LL=newQNode;

LL->Ver=ver;

LL->Next=NULL;

if（N==NULL）

{

N=LL;

M=N;

}

else

{

N->Next=LL;

}

}

}

ver=ver->next;

}

QNode*A;

//QNode*B;

A=M;

while（A!

=NULL）

{

if（A->Ver->ch=='0'）

{

Visit（A->Ver->d）;

A->Ver->ch='1';

Que.AddQueueNodeVertex（&A）;

}

A=A->Next;

}

}

return*G;

}

NetDeleteEdge（Net*G,charVertex1,charVertex2）

{

vnode*NA=NULL;

vnode*NB=NULL;

lnode*EA=NULL;

lnode*EB=NULL;

//NA指向当前Vertex1接点

NA=*G;

while（NA->d!

=Vertex1）

{

NA=NA->next;

}

//起始接点的边集

EA=NA->h;

//第一个接点是目标接点

if（EA->a->d==Vertex2）

{

//第一种情况为边集next为空

if（EA->next==NULL）

{

deleteEA;

NA->h=NULL;

}

//第二种情况为边集next不为空

else

{

NA->h=EA->next;

deleteEA;

}

}

//第一个接点不是目标接点

else

{

//EA是目标接点

//EB是前驱接点

EB=EA;

while（EA->a->d!

=Vertex2）

{

EB=EA;

EA=EA->next;

}

if（EA->a->d==Vertex2）

{

if（EA->next==NULL）

{

EB->next=NULL;

deleteEA;

}

else

{

if（EA->next!

=NULL）

{

EB->next=EA->next;

deleteEA;

}

}

}

}

return*G;

}

NetDeleteVertex（Net*G,charVertex）

{

//ver1指向当前接点所在

vnode*ver1=NULL;

vnode*ver=*G;

vnode*Q=ver;

while（ver->d!

=Vertex&&ver->d!

=NULL）

{

Q=ver;

ver=ver->next;

}

if（ver->next==NULL&&ver->d!

=Vertex）

cout<<"输入顶点数据错误，程序退出！

！

！

"<

else

ver1=ver;

structnode

{

vnode*Ver;

node*next;

};

node*M=NULL;

node*N=NULL;

node*K=NULL;

node*C=NULL;

lnode*NE=NULL;

if（ver1->h==NULL）

M=NULL;

else

{

NE=ver1->h;

//M指向邻接点链表的头结点

M=newnode;

M->Ver=NE->a;

M->next=NULL;

N=M;

while（NE->next!

=NULL）

{

/*N->Vnext=NE->Enext->Edge;

N=NE->Enext->Edge;

NE=NE->Enext;*/

node*L=newnode;

L->Ver=NE->next->a;

L->next=NULL;

N->next=L;

N=L;

NE=NE->next;

}

}

K=N;

ver=*G;

while（ver!

=NULL）

{

if（ver!

=ver1）

{

if（JudgementInDegree（*ver,*ver1））

{

node*LL=newnode;

LL->Ver=ver;

LL->next=NULL;

if（N==NULL）

{

N=LL;

C=N;

}

else

{

N->next=LL;

C=LL;

N=LL;

}

}

}

ver=ver->next;

}

node*A=NULL;

node*B=NULL;

A=M;

while（A!

=K）

{

DeleteEdge（G,Vertex,A->Ver->d）;

A=A->next;

}

while（C!

=NULL）

{

DeleteEdge（G,C->Ver->d,Vertex）;

C=C->next;

}

Q->next=ver1->next;

if（ver1==*G）

{

*G=ver1->next;

}

deletever1;

return*G;

}

voidmain（）

{

charv1;

charv2;

charv3;

NetG1=0;//structvnode*G

cout<<"图1的输出如下：

"<

G1=creat1（&G1）;

out1（&G1）;

NetG2=0;

cout<

"<

G2=creat2（&G2）;

out2（&G2）;

cout<<"\n\n图1的深度优先遍历结果：

"<

DFS（&G1,'a'）;

cout<<"\n\n图1的广度优先遍历结果：

"<

BFSM（&G1,*G1）;

cout<<"\n\n请输入删除的点：

";cin>>v3;

DeleteVertex（&G1,v3）;

out1（&G1）;

cout<<"\n\n请输入删除的边：

";cin>>v1;cin>>v2;

DeleteEdge（&G1,v1,v2）;

out1（&G1）;

getchar（）;

}

/*

d

bc

*/

图1的输出如下：

顶点a出端:

c