图

图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为G=（V，G）。其中，G表示一个图，V表示图G中顶点的集合，E是图G中顶点之间边的集合。
在图中，顶点个数不能为0，但可以没有边。
若顶点Vi和Vj之间的边没有方向，则称这条边为无向边，表示为（Vi，Vj）。
如果图中任意两个顶点之间的边都是无向边，则称图为无向图。
若从顶点Vi到Vj的边有方向，则称这条边为有向边，表示为<Vi,Vj>。
如果图的任意两个顶点之间的边都是有向边，则称该图为有向图。
简单图：
在图中，若不存在顶点到其自身的边，且同一条边不重复出现。
邻接，依附：
无向图中，对于任意两个顶点vi和顶点vj，若存在边(vi，vj)，则称顶点vi和顶点vj互为邻接点，同时称边(vi，vj)依附于顶点vi和顶点vj。
有向图中，对于任意两个顶点vi和顶点vj，若存在弧<vi，vj>，则称顶点vi邻接到顶点vj，顶点vj邻接自顶点vi，同时称弧<vi，vj>依附于顶点vi和顶点vj 。
无向完全图：在无向图中，如果任意两个顶点之间都存在边，则称该图为无向完全图。
有向完全图：在有向图中，如果任意两个顶点之间都存在方向相反的两条弧，则称该图为有向完全图。
顶点的度：在无向图中，顶点v的度是指依附于该顶点的边数，通常记为TD (v)。
顶点的入度：在有向图中，顶点v的入度是指以该顶点为弧头的弧的数目，记为ID (v)；
顶点的出度：在有向图中，顶点v的出度是指以该顶点为弧尾的弧的数目，记为OD (v)。
权：是指对边赋予的有意义的数值量。
网：边上带权的图，也称网图。
路径：在无向图G=(V, E)中，从顶点vp到顶点vq之间的路径是一个顶点序列(vp=vi0,vi1,vi2, …, vim=vq)，其中，(vij-1,vij)∈E（1≤j≤m）。若G是有向图，则路径也是有方向的，顶点序列满足<vij-1,vij>∈E。
非带权图——路径上边的个数
带权图——路径上各边的权之和
回路（环）：第一个顶点和最后一个顶点相同的路径。
简单路径：序列中顶点不重复出现的路径。
简单回路（简单环）：除了第一个顶点和最后一个顶点外，其余顶点不重复出现的回路。
子图：若图G=（V，E），G’=（V’，E’）*，如果V’ 属于V 且E’ 属于 E ，则称图G’是G的子图。
连通图：在无向图中，如果从一个顶点vi到另一个顶点vj(i≠j)有路径，则称顶点vi和vj是连通的。如果图中任意两个顶点都是连通的，则称该图是连通图。
连通分量：非连通图的极大连通子图称为连通分量。
强连通图在有向图中，对图中任意一对顶点vi和vj (i≠j)，若从顶点vi到顶点vj和从顶点vj到顶点vi均有路径，则称该有向图是强连通图。
强连通分量：非强连通图的极大强连通子图。
生成树：n个顶点的连通图G的生成树是包含G中全部顶点的一个极小连通子图
图的遍历是从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。
如何选取遍历的起始顶点
从编号小的顶点开始。
从某个起点始可能到达不了所有其它顶点
多次调用从某顶点出发遍历图。
图中可能存在回路，某些顶点可能会被重复访问，
附设访问标志数组visited[n]
深度优先搜索
⑴ 访问顶点v；
⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。
广度优先搜索
⑴ 访问顶点v；
⑵ 依次访问v的各个未被访问的邻接点v1, v2, …, vk；
⑶ 分别从v1，v2，…，vk出发依次访问它们未被访问的邻接点，并使“先被访问顶点的邻接点”先于“后被访问顶点的邻接点”被访问。直至图中所有与顶点v有路径相通的顶点都被访
图的存储结构及实现
用一维数组存储图中顶点的信息。
用一个二维数组（邻接矩阵）存储图中各顶点之间的邻接关系。
假设图G＝(V，E)有n个顶点，则邻接矩阵是一个n×n的方阵，定义为：
arc[i] [j]等于1(若（Vi,Vj)属于E或<vi,vj>属于E
arc[i][j]等于0（其他）
网图的邻接矩阵：
arc[i][j]=wij (如果<vi,vj>或者（vi,vj)属于E
arc[i][j]=0(如果i=j)
arc[i][j]=无穷大（其他）
无穷大表示一个计算机允许的，大于所有边上权值的数。
无向图
求顶点的度：邻接矩阵的第i行（或第i列）非零元素的个数。
如何判断邻接矩阵中相应位置的元素arc[i][j] 是否为1。
如何求顶点i的所有邻接点，
将数组中第i行元素扫描一遍，若arc[i][j]为1，则顶点j为顶点i的邻接点。
有向图
如何求顶点i的出度：
邻接矩阵的第i行元素之和。
如何求订单i的入度：
邻接矩阵的第j列元素之和。
邻接矩阵存储无向图的类：

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; //顶点，边的数目
};

构造函数

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;  //置有边标志    
    }
}

深度优先搜素遍历

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)//找V的没有遍历过的邻接点
           DFSTraverse( j );
}

广度优先搜素遍历
用队列来进行广度搜素。

int visited[MaxSize];
template <class T>
void MGraph::BFSTraverse(int v){     
    front=rear=-1;   //假设采用顺序队列且不会发生溢出
   int Q[MaxSize]; cout<<vertex[v]; visited[v]=1;  Q[++rear]=v; 
    while (front!=rear)    {
         v=Q[++front];   
         for (j=0; j<vertexNum; j++)
            if (arc[v][j]==1 && visited[j]==0 ) {
                  cout<<vertex[j]; visited[j]=1; Q[++rear]=j;
            }
      }
}

邻接表：
邻接表存储的基本思想：
对于图的每个顶点vi，将所有邻接于vi的顶点链成一个单链表，称为顶点vi的边表（对于有向图则称为出边表）
所有边表的头指针和存储顶点信息的一维数组构成了顶点表。
邻接表的两种结点结构：顶点表结点，边表结点。
vertex：数据域，存放顶点信息。
firstedge：指针域，指向边表中第一个结点。
adjvex：邻接点域，边的终点在顶点表中的下标。
next：指针域，指向边表中的下一个结点。
struct ArcNode{
int adjvex;
ArcNode *next;
};
template
struct VertexNode{//顶点表
T vertex;
ArcNode *firstedge;
};
每个结点对应图中的一条边，邻接表的空间复杂度为O(n+e)。
为方便的计算有向图的顶点的入度，可以构造逆邻接表。
在逆邻接表中，边表中存储的是以顶点vi为弧头的弧。
用邻接表存储有向图的类

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;
       }
    }
}

十字链表：
有向图的链式存储结构：
将邻接表与逆邻接表合二为一。
vertex：数据域，存放顶点信息；
firstin：入边表头指针；
firstout：出边表头指针；
tailvex：弧的起点在顶点表中的下标；
headvex：弧的终点在顶点表中的下标；
headlink：入边表指针域；指向终点相同的下一条边
taillink：出边表指针域。直线起集数组点相同的下一条边。
边集数组
利用两个一维数组
一个数组存储顶点信息，
另外一个数组存储边及其权
数组分量包含三个域：边所依附的两个顶点，权值
各边在数组中的次序可以任意。
空间复杂性： O（n+e）
寻找一条边： O(e）
适用性：
对边依次进行处理的操作。（加边法求最小代价生成树