数据结构C语言版（作业）之 图的创建及有关图的操作

1 邻接矩阵存图

#include<iostream>
#define MAXINT 32767
#define MVNUM 100
using namespace std;
typedef char elementype;
typedef struct{
    elementype vexs[MVNUM];//顶点 
	int arcs[MVNUM][MVNUM];//矩阵 
	int vexnum,arcnum;//顶点数和边数 
}amgraph;

int locate1(amgraph G,int x){//定位
     int i;
	for( i=0;i<G.vexnum;i++){
	   if(x==G.vexs[i])
		   return i;
	}
}
void creatudn(amgraph &G){ //采用邻接矩阵创建无向图
   int i,j;
  cout<<"输入顶点数和边数: ";
  cin>>G.vexnum>>G.arcnum;  //输入顶点数和边数

  cout<<endl<<"输入顶点值,如:a"<<endl;
  for( i=0;i<G.vexnum;i++){
	cout<<"输入顶点值: ";
    cin>>G.vexs[i];          //输入顶点值
  }

  for( i=0;i<G.vexnum;i++){
	  for( j=0;j<G.vexnum;j++){
	    G.arcs[i][j]=MAXINT;  //初始矩阵为最大值
	  }
  }
 
  elementype v1,v2;
  int w,k1,k2;
  cout<<endl<<"输入一条边的两个顶点及依附的权值,如 a b 2 "<<endl;
  for( i=0;i<G.arcnum;i++){
	  cout<<"输入一条边的两个顶点及依附的权值： ";
      cin>>v1>>v2>>w;       //输入一条边的两个顶点及依附的权值
	  k1=locate1(G,v1);
	  k2=locate1(G,v2);
      G.arcs[k1][k2]=G.arcs[k2][k1]=w;//无向网 
      //G.arcs[k1][k2]=w;//有向图 
  }
}

void printudn(amgraph G){//输出邻接矩阵
	int i,j;
    cout<<endl<<"********邻接矩阵为********"<<endl;
    cout<<"\t";
	for( i=0;i<G.vexnum;i++)
		cout<<G.vexs[i]<<"\t";
	cout<<endl;
    for( i=0;i<G.vexnum;i++){
		cout<<G.vexs[i]<<"\t";
		for( j=0;j<G.vexnum;j++){
		   if(i==j)
				cout<<"0"<<"\t";
		   else if(G.arcs[i][j]==MAXINT)
			    cout<<"∞"<<"\t";
		   else  cout<<G.arcs[i][j]<<"\t";	   
		}
		cout<<endl;
	}
}

int main(){
    
	cout<<"*********6.1采用邻接矩阵创建无向网********"<<endl<<endl;
    amgraph G;
	creatudn(G);//创建 
	printudn(G);//打印 	
    return 0;

}

2 邻接表存图

#include<iostream>
#include<cstring> 
#define MVNUM 100
using namespace std;
typedef char elementype ;
typedef struct arcnode{//边结点 
   int adjvex;//改边所指向的顶点的位置从0开始 
   struct arcnode *nextarc;//指向下一条边的指针 
   int info;
}arcnode;
typedef struct vnode{//顶点信息 
   elementype data;//顶点 
   arcnode * firstarc;//指向第一条依附该结点的指针 
}vnode,adglist[MVNUM];
typedef struct{//邻接表 
 adglist vertices;
 int vexnum,arcnum;//图当前的顶点数和边数 
}algraph;
int locate(algraph G,char x){//定位
	for(int i=0;i<G.vexnum;i++){
	    if(x==G.vertices[i].data)
			return i;
	}
}
void createudn(algraph &G){//采用邻接表创建无向图
	int i;
	cout<<"输入顶点数和边数: ";
    cin>>G.vexnum>>G.arcnum;      //输入顶点数和边数
    cout<<endl<<"输入顶点值,如:a"<<endl;
	for( i=0;i<G.vexnum;i++){
	  cout<<"输入顶点值: ";
	  cin>>G.vertices[i].data;      //输入各点
	  G.vertices[i].firstarc=NULL; //边结点初始为空
	}
	cout<<endl<<"输入一条边的两个顶点,如a b "<<endl;
	for( i=0;i<G.arcnum;i++){
	  elementype v1,v2;
	  cout<<"输入一条边的两个顶点: ";
	  cin>>v1>>v2;           //输入一条边依附的两个顶点
      int i=locate(G,v1);    //确定顶点在G.vertices的位置
	  int j=locate(G,v2);
	  arcnode *p1; 
	  p1=new arcnode;       //生成新结点 
	  p1->adjvex=j;
      p1->nextarc=G.vertices[i].firstarc; //连接
	  G.vertices[i].firstarc=p1;
	  
//	  arcnode *p2; //无向网时再加一个结点 
//	  p2=new arcnode;
//	  p2->adjvex=i;
//	  p2->nextarc=G.vertices[j].firstarc;
//	  G.vertices[j].firstarc=p2;
	}
}
void printudn(algraph G){//输出邻接表
	int i,j;
    cout<<endl<<"********邻接表为********"<<endl;
    for(i=0;i<G.vexnum;i++){
    	vnode temp = G.vertices[i];
    	arcnode *p = temp.firstarc;
    	if(p == NULL){
    		cout << G.vertices[i].data;
		}
		else{
			cout<<temp.data;
			while(p){
				cout << "->";
				cout << p->adjvex;
				p = p->nextarc;
			}
		}
    	cout<<endl;
		}
	
}


int main(){
	cout<<"*********6.2采用邻接表创建有向图********"<<endl<<endl;
    algraph G;
	createudn(G);//创建 
	printudn(G);//打印
	return 0;
}

3 邻接矩阵实现四个基本操作（增加结点，删除结点，增加一条边，删除一条边）

#include<iostream>
#define MAXINT 0
#define MVNUM 100
using namespace std;
typedef char elementype;
typedef struct{
    elementype vexs[MVNUM];//顶点 
	int arcs[MVNUM][MVNUM];//矩阵 
	int vexnum,arcnum;//顶点数和边数 
}amgraph;

int locate1(amgraph G,int x){//定位
     int i;
	for( i=0;i<G.vexnum;i++){
	   if(x==G.vexs[i])
		   return i;
	}
}
void creatudn(amgraph &G){ //采用邻接矩阵创建无向图
   int i,j;
  cout<<"输入顶点数和边数: ";
  cin>>G.vexnum>>G.arcnum;  //输入顶点数和边数

  cout<<endl<<"输入顶点值,如:a"<<endl;
  for( i=0;i<G.vexnum;i++){
	cout<<"输入顶点值: ";
    cin>>G.vexs[i];          //输入顶点值
  }

  for( i=0;i<G.vexnum;i++){
	  for( j=0;j<G.vexnum;j++){
		if(i==j) G.arcs[i][j]=1;
		else 
	       G.arcs[i][j]=MAXINT;  //初始矩阵为0
	  }
  }
 
  elementype v1,v2;
  int k1,k2;
  cout<<endl<<"输入一条边的两个顶点,如 a b "<<endl;
  for( i=0;i<G.arcnum;i++){
	 cout<<"输入一条边的两个顶点：";  
      cin>>v1>>v2;       //输入一条边的两个顶点
	  k1=locate1(G,v1);
	  k2=locate1(G,v2);
	  //无向网 
      G.arcs[k1][k2]=G.arcs[k2][k1]=1;//置1 
      //有向图
      //G.arcs[k1][k2]=1; 
  }
}

void printudn(amgraph G){//输出邻接矩阵
	int i,j;
    cout<<endl<<"********邻接矩阵为********"<<endl;
    cout<<"\t"; 
	for( i=0;i<G.vexnum;i++)
		cout<<G.vexs[i]<<"\t";
	cout<<endl;
    for( i=0;i<G.vexnum;i++){
    	cout<<G.vexs[i]<<"\t";
		for( j=0;j<G.vexnum;j++){
		     cout<<G.arcs[i][j]<<"\t";	   
		}
		cout<<endl;
	}
}

void Insertvex(amgraph &G,elementype v){//增加一个顶点 
	
	G.vexnum=G.vexnum+1;//顶点数加一 
	int i;
	for( i=0;i<G.vexnum-1;i++) G.arcs[i][G.vexnum-1]=0;
	for( i=0;i<G.vexnum;i++) G.arcs[G.vexnum-1][i]=0;
    G.arcs[G.vexnum-1][G.vexnum-1]=1;
	G.vexs[G.vexnum-1]=v;
}

void Delectvex(amgraph &G,elementype v){//删除一个顶点 
    int k=locate1(G,v);
    int i;
    for(i=0;i<G.vexnum;i++){
    	G.arcs[i][k]=G.arcs[i][G.vexnum-1];
	}
	for( i=0;i<G.vexnum;i++){
		G.arcs[k][i]=G.arcs[G.vexnum-1][i];
	}
    G.vexs[k]=G.vexs[G.vexnum-1];
    G.vexnum--;
}
void Insertarc(amgraph &G,elementype v,elementype w){//增加一条边 
	int i,j;
	i=locate1(G,v);//找到对应顶点的位置
	j=locate1(G,w); 

	G.arcs[i][j]=G.arcs[j][i]=1;//置1 
}
void Delectarc(amgraph &G,elementype v,elementype w){//删除一条边 
	int i,j;
	i=locate1(G,v);//找到对应顶点的位置
	j=locate1(G,w);

	G.arcs[i][j]=G.arcs[j][i]=MAXINT;//重置为0
	
}
int main(){
    
	cout<<"*********6.1采用邻接矩阵创建无向网********"<<endl<<endl;
    amgraph G;
	 	
	while(1){
	    cout<<endl<<endl<<"1,创建无向网；"<<endl;
		cout<<"2,增加新结点；"<<endl;
		cout<<"3,删除顶点；"<<endl;
		cout<<"4,增加一条边；"<<endl;
		cout<<"5,删除一条边；"<<endl;
		cout<<"6,打印邻接矩阵；"<<endl;
		cout<<"0,退出。"<<endl;
		int n;
		cout<<endl<<"输入选择的操作："; 
		cin>>n; 
		switch(n){
		    case 1:{
                  creatudn(G);//创建
				  break;
                
			  }
			case 2:{
				char v;
				cout<<"输入增加的顶点：";
				cin>>v; 
				Insertvex(G,v);
			
				break;
			}
			case 3:{
				char v;
				cout<<"输入删除的顶点：";
				cin>>v;
				Delectvex(G,v);
			
				break;
			}
			case 4:{
				char v,w;
				cout<<"输入增加的边（如 a b):";
				cin>>v>>w;
				Insertarc(G,v,w);
				
				break;
			}
			case 5:{
				char v,w;
				cout<<"输入删除的边（如 a b):";
				cin>>v>>w;
				Delectarc(G,v,w);
			 
				break;
			}
			case 6:	printudn(G); break;//打印
			case 0: return 0;break;
		}
	} 
    return 0;

}

4 邻接表实现四个基本操作（增加结点，删除结点，增加一条边，删除一条边）

#include<iostream>
#include<cstring> 
#define MVNUM 100
using namespace std;
typedef char elementype;
typedef struct arcnode{//边结点 
   int adjvex;//改边所指向的顶点的位置从0开始 
   struct arcnode *nextarc;//指向下一条边的指针 
   int info;
}arcnode;
typedef struct vnode{//顶点信息 
   elementype data;//顶点 
   arcnode * firstarc;//指向第一条依附该结点的指针 
}vnode,adglist[MVNUM];
typedef struct{//邻接表 
 adglist vertices;
 int vexnum,arcnum;//图当前的顶点数和边数 
}algraph;


int locate(algraph G,elementype x){//定位
	int i;
	for(i=0;i<G.vexnum;i++){
	    if(x==G.vertices[i].data)
			return i;
	}
}

void createudn(algraph &G){//采用邻接表创建无向图
	int i;
	cout<<"输入顶点数和边数: ";
    cin>>G.vexnum>>G.arcnum;      //输入顶点数和边数
    cout<<endl<<"输入顶点值,如:a"<<endl;
	for( i=0;i<G.vexnum;i++){
	  cout<<"输入顶点值: ";
	  cin>>G.vertices[i].data;      //输入各点
	  G.vertices[i].firstarc=NULL; //边结点初始为空
	}
	cout<<endl<<"输入一条边的两个顶点,如a b "<<endl;
	for( i=0;i<G.arcnum;i++){
	  elementype v1,v2;
	  cout<<"输入一条边的两个顶点: ";
	  cin>>v1>>v2;           //输入一条边依附的两个顶点
      int i=locate(G,v1);    //确定顶点在G.vertices的位置
	  int j=locate(G,v2);
	  arcnode *p1; 
	  p1=new arcnode;       //生成新结点 
	  p1->adjvex=j;
      p1->nextarc=G.vertices[i].firstarc; //连接
	  G.vertices[i].firstarc=p1;
	  
	  arcnode *p2; //无向图时再加一个结点 
	  p2=new arcnode;
	  p2->adjvex=i;
	  p2->nextarc=G.vertices[j].firstarc;
	  G.vertices[j].firstarc=p2;
	}
}
void printudn(algraph G){//输出邻接表
	int i;
    cout<<endl<<"********邻接表为********"<<endl;
    for(i=0;i<G.vexnum;i++){
    	vnode temp = G.vertices[i];
    	arcnode *p = temp.firstarc;
    	if(p == NULL){
    		cout << G.vertices[i].data;
		}
		else{
			cout<<temp.data;
			while(p){
				cout << "->";
				cout << p->adjvex;
				p = p->nextarc;
			}
		}
    	cout<<endl;
		}
	
}

void Insertvex(algraph &G,elementype v){//增加一个顶点 
   G.vexnum+=1;
   G.vertices[G.vexnum-1].data=v;
   G.vertices[G.vexnum-1].firstarc=NULL;
}

void Delectvex(algraph &G,elementype v){//删除一个顶点  
   int k=locate(G,v);//待删除顶点的下标
    
   //遍历整个表，将下标为k的跳过，下标为G.vexnum-1的置为k; 
   int i;
    for(i=0;i<G.vexnum;i++){
    	if(i==k) continue;
    	arcnode *p = G.vertices[i].firstarc;
	    if(p&&p->adjvex==k){
		    G.vertices[i].firstarc=p->nextarc;
		}
		else if(p&&p->adjvex==G.vexnum-1){
			p->adjvex=k;
		}	
		while(p&&p->nextarc){
				if(p->nextarc->adjvex==k)
					p->nextarc = p->nextarc->nextarc;
				else if(p->nextarc->adjvex==G.vexnum-1){
				   p->nextarc->adjvex=k;
				}
				p=p->nextarc;   
			}
			
		
	} 
	//将最后一个表覆盖下标为k的表	 
	G.vertices[k]=G.vertices[G.vexnum-1];
	G.vexnum-=1;
}
void Insertarc(algraph &G,elementype v,elementype w){//增加一条边 
    G.arcnum+=1;
	int i=locate(G,v);
	int j=locate(G,w);
	
	//在i链增加 
	arcnode *p1; 
      p1=new arcnode;       //生成新结点 
	  p1->adjvex=j;
      p1->nextarc=G.vertices[i].firstarc; //连接
	  G.vertices[i].firstarc=p1;
	  
	//在j链增加 
	arcnode *p2;
	  p2=new arcnode;
	  p2->adjvex=i;
	  p2->nextarc=G.vertices[j].firstarc;
	  G.vertices[j].firstarc=p2; 
}
void Delectarc(algraph &G,elementype v,elementype w){//删除一条边 
    G.arcnum-=1;
	int i=locate(G,v);
	int j=locate(G,w);
	//在i链删除 
	arcnode *p = G.vertices[i].firstarc;
	if(p->adjvex==j) {
		G.vertices[i].firstarc=p->nextarc;
	}  
	else{
		while(p&&p->nextarc){
		 if(p->nextarc->adjvex==j){
		 	p->nextarc=p->nextarc->nextarc;break;
		 }	 
		 p=p->nextarc;       
	  }
	} 
	
	//在j链删除 
	arcnode *q = G.vertices[j].firstarc;
	if(q->adjvex==i) {
		G.vertices[j].firstarc=q->nextarc;
	}	  
	else{
		while(q&&q->nextarc){
		 if(q->nextarc->adjvex==i){
		 	q->nextarc=q->nextarc->nextarc;break;
		 }	 
		 q=q->nextarc;       
    	}
	}
		
}

int main(){
	cout<<"*********6.2采用邻接表创建无向网********"<<endl<<endl;
    algraph G;
    while(1){
	    cout<<endl<<"1,创建无向网；"<<endl;
		cout<<"2,增加新结点；"<<endl;
		cout<<"3,删除结点；"<<endl;
		cout<<"4,增加一条边；"<<endl;
		cout<<"5,删除一条边；"<<endl;
		cout<<"6,打印邻接表；"<<endl;
		cout<<"0,退出。"<<endl;
		int n;
		cout<<endl<<"输入选择的操作："; 
		cin>>n; 
		switch(n){
		    case 1:{
                 createudn(G);//创建
				  break;
			  }
			case 2:{
				char v;
				cout<<"输入增加的顶点：";
				cin>>v; 
				Insertvex(G,v);
				break;
			}
			case 3:{
				char v;
				cout<<"输入删除的顶点：";
				cin>>v;
				Delectvex(G,v);
				break;
			}
			case 4:{
				char v,w;
				cout<<"输入增加的边（如 a b):";
				cin>>v>>w;
				Insertarc(G,v,w);
				break;
			}
			case 5:{
				char v,w;
				cout<<"输入删除的边（如 a b):";
				cin>>v>>w;
				Delectarc(G,v,w);
				break;
			}
			case 6:	printudn(G); break;//打印
			case 0: return 0;break;
		}
	} 
	return 0;
}