图的链式存储结构的建立

<pre name="code" class="cpp">#ifndef Graph_H
#define MAX_VEX_NUM 20 
#define OK 1
#define MAX_NAME 3/*顶点字符串的最大长度+1*/
#define MAX_INFO 20/*相关字符串的最大长达+1*/
/结构定义//
//图的种类有向图，有向网，无向图，无向网
typedef enum{DG,DN,AG,AN} GraphKind ;
typedef int InfoType ;
typedef char VertexType[MAX_NAME];
typedef int Status ;
typedef int VRType;  

typedef struct ArcNode{
	int adjvex;               //该弧指向的顶点的位置
	struct ArcNode *nextarc; //指向下一条弧的指针
	InfoType *info ;         //网的权值指针
}ArcNode;    /*表结点*/

typedef struct{
	VertexType data ;        //顶点信息
	ArcNode *firstarc;       //指向第一条弧
}VNode,AdjList[MAX_VEX_NUM];

typedef struct{
	AdjList vertices; //顶点的数组
	int vexnum,arcnum ;//图当前顶点的个数和弧数
	int kind ; //图的种类
}ALGraph; 

//最小生成树
/*辅助结构*/
typedef struct Minimum{ //此结构存放当前过程中V中各节点到U中各节点的最小权值信息  
    VertexType data;    //保存U中与V中该结点相连接的结点值，使V中该结点到U中各节点间权值最小  
    VRType lowcost;     //保存两结点间最小的权值(代价)  
    int flag;           //表示V中该结点在某一过程中是否被更新的标志，flag=0表示尚未更新，flag=1表示已经更新，不用再更新了，图使用邻接表存储时要注意设置此标志，以免某一结点的minimum结构被更新多次，得不到正确的最小权值  
}Minimum,closedge[20];  
//
操作定义///
int LocateVex(ALGraph G,VertexType u);
Status CreateGraph(ALGraph *G);
void Destory(ALGraph *G);
VertexType* GetVex(ALGraph G ,int v);
Status PutVex(ALGraph *G, VertexType v,VertexType value);
int FirstAdjVex(ALGraph G,VertexType v);
int NextAdjVex(ALGraph G,VertexType v,VertexType w);
void InsertVex(ALGraph *G, VertexType v);
Status DeleteVex(ALGraph *G, VertexType v);
Status InserArc(ALGraph *G, VertexType v,VertexType w);
Status DeleteArc(ALGraph *G,VertexType v,VertexType w);

void DFS(ALGraph G,int v);
void DFSTraverse(ALGraph G);
void BFSTraverse(ALGraph G);
void Display(ALGraph G);
void Visit(char s[]);

int minimum(ALGraph G,closedge MinEdge);
void MinSpanTree(ALGraph G,VertexType u);
//

//队列
#define ERROR 0
#define OVERFLOW -2 

typedef int QElemType;
typedef int Status;

typedef struct QNode{
	QElemType data ;
	struct QNode *next ;
}QNode , *QueuePtr;

typedef struct {
	QueuePtr front ;
	QueuePtr rear ;
}LinkQueue;

//--------基本操作------------
Status InitQueue(LinkQueue &Q);
Status DestroyQueue(LinkQueue &Q);
Status ClearQueue(LinkQueue &Q);
Status QueueEmpty(LinkQueue Q);
int QueueLength(LinkQueue Q);
Status GetHead(LinkQueue Q,QElemType &e);
Status EnQueue(LinkQueue &Q,QElemType e);
Status DeQueue(LinkQueue &Q,QElemType &e);
bool IsEmpty(LinkQueue Q);
//
#endif

</pre><p></p><p><pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Graph.h"




//操作的具体实现//


int LocateVex(ALGraph G,VertexType u){
	/*初始条件:图G存在，u和G中的顶点有相同的特征*/
	/*操作结果: 若u在G中，则返回u顶点的位置，否则返回-1*/
	int i ;
	for(i=0;i<G.arcnum;i++)
		if(strcmp(u,G.vertices[i].data)==0)
			return i ;
		return -1 ;
	
}

Status CreateGraph(ALGraph *G){
	/*采用邻接表存储结构,构造没哟u相关信息的图G(用一个函数构造4中图)*/
	int i,j,k;
	int w ;   /*权重*/
	VertexType va,vb ;
	ArcNode *p;
	printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
	scanf("%d",&((*G).kind));
	printf("%d",G->kind);
	printf("请输入图的顶点数,边数: ");
	scanf("%d,%d",&((*G).vexnum),&((*G).arcnum));
	printf("请输入%d个顶点的值(<%d个字符): \n",G->vexnum,MAX_NAME);
	/*构造顶点向量*/
	for(i=0;i<G->vexnum;i++){
		scanf("%s",&(*G).vertices[i].data);
		(*G).vertices[i].firstarc=NULL ;

	}
	
	if(G->kind==1||G->kind==3)/*网*/
		printf("请输入每条弧(边)的权值，弧尾和弧头(以空格作为间隔): \n");
	else  /*图*/
		printf("请顺序输入每条弧的弧尾和弧头(以空格作为间隔): \n");
	for(k=0;k<G->arcnum;k++){
		if(G->kind==1||G->kind==3)
			scanf("%d%s%s",&w,va,vb);
		else
			scanf("%s%s",va,vb);
		i=LocateVex(*G,va); /*弧尾*/

		j=LocateVex(*G,vb); /*弧头*/

		p=(ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex=j;
		if(G->kind==1||G->kind==3){//网
			p->info= (int *)malloc(sizeof(int));
			*(p->info)=w;
		}else{
			p->info=NULL;
		}
		p->nextarc = G->vertices[i].firstarc;/*插在表头*/
		G->vertices[i].firstarc = p;

		if(G->kind>=2){/*无向图，或网产生第二个结点*/
			p=(ArcNode*)malloc(sizeof(ArcNode));
			p->adjvex=i;
			if(G->kind==3){
				p->info=(int *)malloc(sizeof(int));
				*(p->info)=w;
			}else
				p->info=NULL;
			p->nextarc = G->vertices[j].firstarc;
			G->vertices[j].firstarc=p;
		}

	}
	return OK ;
}

void Destory(ALGraph *G){
	/*初始条件:图G存在,操作结果:销毁G*/
	int i ;
	ArcNode *p,*q;
	for(i=0;i<G->vexnum;i++){
		p=G->vertices[i].firstarc;
		while(p){
			q=p->nextarc;
			if(G->kind%2){/*网,这与前面的规定顺序有关*/
				free(p->info);
			}
			free(p);
			p=q;
		}
	}
	G->arcnum = 0;
	G->vexnum = 0;
}
VertexType* GetVex(ALGraph G,int v){
	/*初始条件:图G存在,v是图中某个顶点的序号.*/
	/*操作结果:返回序号为v顶点的值*/
	//1.判断位置,体现程序的健壮性
	if(v>G.vexnum||v<0){
		printf("位置不正确\n");
		exit(-1);
	}
	return &G.vertices[v].data;
}

Status PutVex(ALGraph *G, VertexType v,VertexType value){
	/*初始条件:图G存在，v为图中顶点，value为替换v的值*/
	/*操作结果:将图G中的v替换成新的值value*/
	int i ;
	i= LocateVex(*G,v);
	if(i<0){
		printf("图G中不存在值为%d的顶点\n",v);
		return -1;
	}

	strcpy(G->vertices[i].data , value) ;
	return OK ;
}

int FirstAdjVex(ALGraph G,VertexType v){
	/*初始条件:图G存在，v为图G中的某个顶点*/
	/*操作结果:返回v的第一个邻接顶点的序号,若不存在则返回-1*/
	ArcNode *p;
	int v1 ;//顶点v在图G中的序号
	v1= LocateVex(G,v);
	p=G.vertices[v1].firstarc;
	if(p)
		return p->adjvex;
	return -1 ;

}

int NextAdjVex(ALGraph G,VertexType v,VertexType w){
	/*初始条件:图G存在,v是G中的某个顶点,w是v的邻接顶点*/
	/*操作结果:返回v(相对于w)的下一个邻接顶点的序号，若w是最后一个节点，返回-1*/
	ArcNode *p;
	int v1,w1 ;
	v1 = LocateVex(G,v);
	w1 = LocateVex(G,w);/*w1为w在G中的位置*/
	p=G.vertices[v1].firstarc;
	while(p&&p->adjvex!=w1)
		p=p->nextarc;
	if(!p||!p->nextarc)
		return -1 ;
	else   /*p->adjvex=w1*/
		return p->nextarc->adjvex;
}

void InsertVex(ALGraph *G, VertexType v){
	/*初始条件:图G存在,v和图中顶点相同特征*/
	/*操作结果:在图G中增添顶点，不添加与顶点相关的弧，招待InsertArc去做*/
	strcpy(	G->vertices[G->vexnum].data , v);
	G->vertices[G->vexnum].firstarc = NULL;
	G->vexnum++;   /*图G的顶点数加1*/
}

Status DeleteVex(ALGraph *G, VertexType v){
	/*初始条件:图G存在,v是图G中的某个顶点*/
	/*操作结果:删除G中的顶点v*/
	int i,j;
	ArcNode *p,*q ;
	j = LocateVex(*G,v);
	if(j<0) /*v不是图G中的顶点*/
		return -1;
	p=G->vertices[j].firstarc;/*删除以v为出度的节点*/
	while(p){
		q=p;
		p=p->nextarc;
		if(G->kind%2)/*网*/
			free(q->info);
		free(q);
		G->arcnum--;/*弧或边减少1*/
	}
	for(i=j;i<G->vexnum;i++)
		G->vertices[i]=G->vertices[i+1];/*顶点数组向前移*/
	G->vexnum--;/*顶点减少1*/
	for(i=0;i<G->vexnum;i++){/*删除以v为入度的弧或边且必要的时候修改表节点的顶点的位置*/
		p=G->vertices[i].firstarc;
		while(p){/*有弧*/
			if(p->adjvex==j){
				if(p==G->vertices[i].firstarc){/*待删除的是第一个结点*/
					G->vertices[i].firstarc=p->nextarc;
					if(G->kind%2) /*网，则销毁info信息*/
						free(p->info);
					free(p);
					p=G->vertices[i].firstarc;
					if(G->kind<2)
						G->arcnum--;	
				}else{
					q->nextarc=p->nextarc;
					if(G->kind%2)
						free(p->info);
					free(p);
					p=q->nextarc;
					if(G->kind<2)
						G->arcnum--;
				}
			}else{
				if(p->adjvex>j)
					p->adjvex--;/*修改表结构的顶点位置值(序号)*/
				q=p;
				p=p->nextarc;
			}
		}
	}
	return OK;
}
Status InserArc(ALGraph *G, VertexType v,VertexType w){
	/*初始条件:图G存在,v,w是G中的两个顶点*/
	/*操作结果:在G曾增加<v,w>的一条弧，若是无向图则增加另一条<w,v>的弧*/
	ArcNode *p ;
	int w1,i,j ;

	i=LocateVex(*G,v);
	j=LocateVex(*G,w);
	if(i<0||j<0)
		return -1;
	G->arcnum++;
	if(G->kind%2){/*网*/
		printf("请输入弧(边)%s->%s的权值: ");
		scanf("%d",&w1);
	}

	p=(ArcNode*)malloc(sizeof(ArcNode));
	p->adjvex=j;
	if(G->kind%2){/*网*/
		p->info = (int *)malloc(sizeof(int));
		*(p->info)=w1;
	}else{
		p->info=NULL;
	}

	p->nextarc=G->vertices[i].firstarc;
	G->vertices[i].firstarc=p;
	if(G->kind>=2){/*无向，生成另一条表结点*/
		p=(ArcNode*)malloc(sizeof(ArcNode));
		p->adjvex=i;
		if(G->kind==3){/*无向网*/
			p->info = (int *)malloc(sizeof(int));
			*(p->info)=w1;
		}else{
			p->info=NULL;
		}
		p->nextarc=G->vertices[j].firstarc;
		G->vertices[j].firstarc=p;
	}
	return OK ;
}

Status DeleteArc(ALGraph *G,VertexType v,VertexType w){
	/*初始条件:图G存在,v和w分别是G中的顶点*/
	/*操作结果:删除G中<v,w>的弧或边,若是无向图,则删除另一条<w,v>的边或弧*/
	int i,j;
	ArcNode *p,*q;
	i=LocateVex(*G,v);
	j=LocateVex(*G,w);
	//健壮性判断
	if(i<0||j<0||i==j)
		return -1;
	p=G->vertices[i].firstarc;/*指向顶点v的第一条弧*/
	while(p&&p->adjvex!=j){
		q=p;
		p=p->nextarc;
	}
	if(p&&p->adjvex==j)/*找到弧<v,w>*/
	{
		/*分两种情况分别处理:1.是第一个邻接点2.是后面的邻接点*/
		if(p==G->vertices[i].firstarc){
			G->vertices[i].firstarc=p->nextarc;
		}else{
			q->nextarc=p->nextarc;
		}
		if(G->kind%2)
			free(p->info);
		free(p);
		G->arcnum--;

	}
	if(G->kind>=2){//无向图或网
		p=G->vertices[j].firstarc;/*指向w的第一条弧或边*/
		while(p&&p->adjvex!=i){
			q=p;
			p=p->nextarc;
		}

		if(p&&p->adjvex==i){
			if(p==G->vertices[j].firstarc)
				G->vertices[j].firstarc= p->nextarc;
			else
				q->nextarc=p->nextarc;
			if(G->kind==3)
				free(p->info);
			free(p);
		}
	}
	return OK ;
}

bool visited[MAX_VEX_NUM] ;
void DFS(ALGraph G,int v){
	int w ;
	VertexType v1,w1;
	strcpy(v1,*GetVex(G,v));
	visited[v]=true;/*标志已经访问*/

	Visit(G.vertices[v].data);
	for(w=FirstAdjVex(G,v1);w>=0;w=NextAdjVex(G,v1,strcpy(w1,*GetVex(G,w))))
		if(!visited[w])
			DFS(G,w);
}
void DFSTraverse(ALGraph G){
	/*对图深度优先遍历*/
	int v;/*顶点的序号*/

	for(v=0;v<G.vexnum;v++){
		visited[v]=false;
	}

	for(v=0;v<G.vexnum;v++)
		if(!visited[v])
			DFS(G,v);
		printf("\n");
}

void BFSTraverse(ALGraph G){
	/*广度优先搜索(非递归),需要一个辅助队列Q和访问标志visited[]数组*/
	int v,u,w ;
	VertexType u1,w1 ;
	LinkQueue Q ;
	for(v=0;v<G.vexnum;v++){
		visited[v]=false;
	}
	InitQueue(Q);
	for(v=0;v<G.vexnum;v++){/*若是连通图,v=0就能遍历全部顶点*/
		if(!visited[v]){
			visited[v]= true;
			Visit(G.vertices[v].data);
			EnQueue(Q,v);
			while(!IsEmpty(Q)){/*队列不空*/
				DeQueue(Q,u);
				strcpy(u1,*GetVex(G,u));
				for(w=FirstAdjVex(G,u1);w>=0;w=NextAdjVex(G,u1,strcpy(w1,*GetVex(G,w)))){
					if(!visited[w]){
						visited[w]=true;
						Visit(G.vertices[w].data);
						EnQueue(Q,w);
					}
				}
			}
		}
	}
	printf("\n");
}

/***************最小生成树算法*************/
int minimum(ALGraph G,closedge MinEdge){  //寻找V中各节点到U中各节点间最小的权值，返回结点的编号  
    int i,j,first,min;  
    for(i=0;i<G.vexnum;i++){  /*获得MinEdge中第一个lowcost不为0的位置*/
        if(MinEdge[i].lowcost!=0){  //MinEdge[i].lowcost==0说明编号为i的结点在U中  
            min=MinEdge[i].lowcost;  /*记当前的第一个lowcost不为0,默认为最小值*/
            first=i;  /*记住默认最小值的当前位置*/
            break;  
        }  
    }  
    k=i;  
    for(i=first;i<G.vexnum;i++){  /*循环遍历获得最小值为位置*/
        if(min>MinEdge[i].lowcost&&MinEdge[i].lowcost!=0){  
            min=MinEdge[i].lowcost;  
            k=i;  
        }  
    }  
    return k;  
}  
  
void MinSpanTree(ALGraph G,VertexType u){  //从图中结点u开始生成最小生成树的过程  
    int i,k;  
    ArcNode *p;  
    closedge MinEdge;  
    k=LocateVex(G,u);  
    for(i=0;i<G.vexnum;i++)  
        MinEdge[i].flag=0;  //访问标志初始化为0  
	/******初始化MinEdge数组*****/
	/*初始化的算法为:*/
    for(i=0;i<G.vexnum;i++){  
        if(i!=k){  
            strcpy(MinEdge[i].data,u);     
            for(p=G.vertices[i].firstarc;p!=NULL;p=p->nextarc){  
                if(p->adjvex==k){   //p->adjvex==k说明编号为i的结点与编号为k的结点间有弧连接，需要把MinEdge的lowcost修改为弧上的权值  
                    MinEdge[i].lowcost=*(p->info);  
                    MinEdge[i].flag=1;    //设置标志，表示编号为i的结点在这一过程中已更新过权值  
                }  
                else if(MinEdge[i].flag==0)    
                    MinEdge[i].lowcost=100;  
            }  
        }  
        strcpy(MinEdge[k].data,G.vertices[k].data);  
        MinEdge[k].lowcost=0;  
    }  
    for(i=1;i<G.vexnum;i++){  
        k=minimum(G,MinEdge); 
		printf("(%s-%s):%d",G.vertices[k].data,MinEdge[k].data,MinEdge[k].lowcost);
        
        MinEdge[k].lowcost=0;   //将结点加入U中  
        for(p=G.vertices[k].firstarc;p!=NULL;p=p->nextarc){  
            if(MinEdge[p->adjvex].lowcost>*(p->info)){  
                MinEdge[p->adjvex].lowcost=*(p->info);  
               strcpy( MinEdge[p->adjvex].data,G.vertices[k].data);  
            }  
        }  
    }  
}  
/******************************************/
void Display(ALGraph G){
	/*输出图的邻接矩阵*/
	int i ;
	ArcNode *p;
	switch(G.kind){
		case DG:printf("有向图\n");
			break;
		case DN:printf("有向网\n");
			break ;
		case AG:printf("无向图\n");
			break;
		case AN:printf("无向网\n");
			break;
	}
	printf("%d个顶点: \n",G.vexnum);

	for(i=0;i<G.vexnum;i++){
		printf("%s",G.vertices[i].data);
	}
	printf("\n%d条弧(边)",G.arcnum);
	for(i=0;i<G.vexnum;i++){
		p=G.vertices[i].firstarc;
		while(p){
			if(G.kind<=1){//有向
				printf("%s->%s",G.vertices[i].data,G.vertices[p->adjvex].data);
				if(G.kind==DN)/*网*/
					printf(":%d",*(p->info));
			}else{//无向
				if(i<p->adjvex){
					printf("%s-%s",G.vertices[i].data,G.vertices[p->adjvex].data);
					if(G.kind==AN)
						printf(":%d",*(p->info));
				}
			}
			p=p->nextarc;
		}
		printf("\n");
	}
}
void Visit(char str[]){
	printf("%s",str);
}
/*****************队列实现******************************/
Status InitQueue(LinkQueue &Q){
	Q.front = Q.rear=(QueuePtr)malloc(sizeof(QNode));
	if(!Q.front) exit(OVERFLOW);
	Q.front->next = NULL;
	return OK ;
}

Status EnQueue(LinkQueue &Q,QElemType e){
	QueuePtr p =NULL ;
	p= (QueuePtr)malloc(sizeof(QNode));
	if(!p) exit(OVERFLOW);

	p->data = e ;

	Q.rear->next=p;
	Q.rear = p;
	p->next=NULL;
	return OK ;
}

Status DeQueue(LinkQueue &Q,QElemType &e){
	if(Q.front==Q.rear) 
		return ERROR ;//队列为空
	QueuePtr p=NULL;
	p= Q.front->next;
	e= p->data ;
	Q.front->next = p->next;
	if(Q.rear==p) //队列中只有一个元素
		Q.rear=Q.front;
	free(p);
	return OK ;
}

Status DestroyQueue(LinkQueue &Q){
	while(Q.front){
		Q.rear = Q.front->next;
		free(Q.front);
		Q.front = Q.rear;
	}
	return OK ;
}

int QueueLength(LinkQueue Q){
	int length =0 ;
	QueuePtr p ;
	if(Q.front==Q.rear) return ERROR ;

	p= Q.front->next ;

	while(p!=NULL){
		length++ ;
		p=p->next ;
	}
	return length ;
}

bool IsEmpty(LinkQueue Q)//判断队列是否为空  
{  
    return Q.front == Q.rear ? true : false;  
}  
/*****************************************************************/

void main(){
	ALGraph G ;
	CreateGraph(&G);
	Display(G) ;
//	printf("%c",GetVex(G,3));
//	Destory(&G);
//	Display(G) ;
//	PutVex(&G,'A','F');
//	Display(G) ;
//	int i= FirstAdjVex(G,"B");
//	printf("pos=%d:value=%s\n",i,G.vertices[i].data);

//	int i=NextAdjVex(G,"A","C");
//	printf("pos=%d:value=%s\n",i,G.vertices[i].data);

//	InsertVex(&G, "E");
//	Display(G);

//	DeleteVex(&G,"A");
//	Display(G);

//	InserArc(&G,"C","D");
//	Display(G);

	DFSTraverse(G);
	BFSTraverse(G);

	MinSpanTree(G,"v1");
}

有向图，十字链表实现：

http://www.cnblogs.com/cpoint/p/3480214.html