数据结构——图

图的逻辑结构

图的定义和基本术语

一、图的定义
图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：
G=(V，E)
其中：G表示一个图，V是图G中顶点的集合，E是图G中顶点之间边的集合。
在线性表中，元素个数可以为零，称为空表；
在树中，结点个数可以为零，称为空树；
在图中，顶点个数不能为零，但可以没有边。
无向图：若顶点vi和vj之间的边没有方向，则称这条边为无向边，表示为(vi,vj)。如果图的任意两个顶点之间的边都是无向边，则称该图为无向图。
有向图：若从顶点vi到vj的边有方向，则称这条边为有向边，表示为<vi,vj>。 如果图的任意两个顶点之间的边都是有向边，则称该图为有向图。
二、图的基本术语
1.邻接、依附
无向图：对于任意两个顶点vi和顶点vj，若存在边(vi，vj)，则称顶点vi和顶点vj互为邻接点，同时称边(vi，vj)依附于顶点vi和顶点vj。
有向图：对于任意两个顶点vi和顶点vj，若存在弧<vi，vj>，则称顶点vi邻接到顶点vj，顶点vj邻接自顶点vi，同时称弧<vi，vj>依附于顶点vi和顶点vj 。
在线性结构中，数据元素之间仅具有线性关系；
在树结构中，结点之间具有层次关系；
在图结构中，任意两个顶点之间都可能有关系。
2.顶点的入度、出度
顶点的入度：在有向图中，顶点v的入度是指以该顶点为弧头的弧的数目，记为ID (v)；
顶点的出度：在有向图中，顶点v的出度是指以该顶点为弧尾的弧的数目，记为OD (v)。
3.无向完全图、有向完全图
无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。
有向完全图：在有向图中，如果任意两个顶点之间都存在方向相反的两条弧，则称该图为有向完全图。
4.稠密图、稀疏图
稀疏图：称边数很少的图为稀疏图；
稠密图：称边数很多的图为稠密图。
顶点的度：在无向图中，顶点v的度是指依附于该顶点的边数，通常记为TD (v)。

1.深度优先遍历 （DFS：Depth First Search）
基本思想 ：
⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
2. 广度优先遍历 （BFS：Broad First Search ；FIFO: First In First Out）
基本思想：
⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。

图的存储结构

1.邻接矩阵（数组表示法）
基本思想：
用一个一维数组存储图中顶点的信息
用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。
假设图G＝(V，E)有n个顶点，则邻接矩阵是一个n×n的方阵，定义为：
arc[i][j]＝1 若(vi, vj)∈E（或<vi, vj>∈E）
arc[i][j]＝0 其它

//邻接矩阵存储无向图的类：
const int MaxSize=10; 
template <class T>
class Mgraph{
public:
	MGraph(T a[ ], int n, int e );
	~MGraph( )
	void DFSTraverse(int v);
	void BFSTraverse(int v);
private:
	T vertex[MaxSize]; 
	int arc[MaxSize][MaxSize]; 
	int vertexNum, arcNum; 
};
/*
1.确定图的顶点个数和边的个数；
2.输入顶点信息存储在一维数组vertex中；
3.初始化邻接矩阵；
4.依次输入每条边存储在邻接矩阵arc中；
     4.1 输入边依附的两个顶点的序号i, j；
     4.2 将邻接矩阵的第i行第j列的元素值置为1；
     4.3 将邻接矩阵的第j行第i列的元素值置为1；
*/
template <class T>
MGraph::MGraph(T a[ ], int n, int e){
	vertexNum=n; arcNum=e;
    for (i=0; i<vertexNum; i++) 
        vertex[i]=a[i];
    for (i=0; i<vertexNum; i++)    //初始化邻接矩阵
	   for (j=0; j<vertexNum; j++)
           arc[i][j]=0;             
    for (k=0; k<arcNum; k++) {
        cin>>i>>j;     //边依附的两个顶点的序号
        arc[i][j]=1;  arc[j][i]=1;  //置有边标志    
    }
}
//深度优先遍历
int visited[MaxSize];
template <class T>
void MGraph::DFSTraverse(int v)  
{
     cout<<vertex[v]; visited [v]=1;
     for (j=0; j<vertexNum; j++)
         if (arc[v][j]==1 && visited[j]==0)
           DFSTraverse( j );
}
//广度优先遍历
int visited[MaxSize];
template <class T>
void MGraph::BFSTraverse(int v){
	int front=rear=-1;//假设采用顺序队列且不会发生溢出,初始化队列
	int Q[MaxSize],w,j;
	cout<<vertex[v];
	visited[v]=1;
	Q[++rear]=v;//被访问顶点入队
    while (front!=rear)//当队列非空时
    {
         v=Q[++front];//将队头元素出队并送到v中
         for (j=0;j<vertexNum;j++)
            if(arc[v][j]==1&&visited[j]==0){
                  cout<<vertex[j]; visited[j]=1; Q[++rear]=j;
            }
      }
}

2.邻接表
邻接表存储的基本思想：
对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表）
所有边表的头指针和存储顶点信息的一维数组构成了顶点表。

/*
vertex：数据域，存放顶点信息。 
firstedge：指针域，指向边表中第一个结点。 
adjvex：邻接点域，边的终点在顶点表中的下标。
next：指针域，指向边表中的下一个结点。 
*/
struct ArcNode
{   
      int adjvex; 
      ArcNode *next;
};
template <class T>
struct VertexNode 
{
      T vertex;
      ArcNode *firstedge;
};
const int MaxSize=10;    //图的最大顶点数
template <class T>
class ALGraph
{    
public:
	ALGraph(T a[], int n, int e);   
	~ALGraph;    
	void DFSTraverse(int v);      
	void BFSTraverse(int v);      
private:
	VertexNode adjlist[MaxSize];   
	int vertexNum, arcNum;       
};
//构造函数
template <class T>
ALGraph::ALGraph(T a[ ], int n, int e)
{   
    vertexNum=n; arcNum=e; 
    for (i=0; i<vertexNum; i++)   
    {
       adjlist[i].vertex=a[i];
       adjlist[i].firstedge=NULL;      
    } 
    for (k=0; k<arcNum; k++)   
    {
         cin>>i>>j;    
         s=new ArcNode; s->adjvex=j;  	        
         s->next=adjlist[i].firstedge;    
         adjlist[i].firstedge=s;
     }
}
//深度优先遍历
template <class T>
void ALGraph::DFSTraverse(int v){        
    cout<<adjlist[v].vertex;  visited[v]=1;
    p=adjlist[v].firstedge;    
    while (p!=NULL)     {
        j=p->adjvex;
        if (visited[j]==0) DFSTraverse(j);
    p=p->next;           
    }
}
//广度优先遍历
template <class T>
void ALGraph::BFSTraverse(int v){
   front=rear=-1;   
   cout<<adjlist[v].vertex;    visited[v]=1;   Q[++rear]=v;   
   while (front!=rear)  {
       v=Q[++front];    p=adjlist[v].firstedge;    
       while (p!=NULL)  {
            j= p->adjvex;
            if (visited[j]==0) {
                cout<<adjlist[j].vertex;  visited[j]=1; Q[++rear]=j;
            }
            p=p->next;
       }
    }
}
//图的销毁
template<T>
ALGraph :: ~ALGraph( )
{
	EdgeNode *p = NULL, *q = NULL;
	for (int i = 0; i < vertexNum; i++)
	{
		p=q=adjlist[i].firstEdge;
		while (p != NULL)
		{
			p = p->next;
			delete q; 
			q = p;
		}
	}
}