1、定义
A graph consists of a set of vertices V and a set of edges E.
Each edge is a pair (v, w), where v,w belong to V.
路径 A path in a graph is a sequence of vertices w1, w2, ... ,wn.
长度 The length of such a path is the number of edges on the path, which is equal to N-1.
权 Sometimes an edge has a third component, known as either a weight or a cost.
Spanning tree 生成树
假设一个连通图有N 个顶点和e条边，其中n-1 条边和n个顶点构成一个极小连通子图，称该极小连通子图为此树的生成树
2、图的储存表示
1）邻接矩阵表示法
顶点表：记录各个顶点信息的一位数组
邻接矩阵：一个表示各个顶点之间的关系（边或弧）的二维数组。
const MAX_NUM=20; //最大顶点数
typedef int AdjMatrix[MAX_NUM][MAX_NUM]; //邻接矩阵
typedef struct
{
VertexType vexs[MAX_NUM]; //顶点表
AdjMatrix arcs; //邻接矩阵
int vexnum, arcnum; //图实际顶点数与弧数
}MGraph;
在无向图中，第i行（列）1的个数就是顶点i的度。
无向图的邻接矩阵是对称的；
有向图的邻接矩阵可能是不对称的。
在有向图中，第i行1的个数就是顶点i的出度，第j列1的个数就是j的入度
如果有权值的存在，则也可以在邻接矩阵上加上
2）邻接表
以一种链式结构形式的存储结构
typedef struct ArcNode
{
int ajdvex; //该弧所指向结点的位置
ArcNode* nextArc; //指向下一条弧指针
InfoNode info; //弧所带信息，可以是权值
}ArcNode;
typedef struct VNode
{
VertexType data; //顶点信息
ArcNode* firstArc; //指向第一条依附该结点的弧的位置
}VNode, Adjist[MAX_NUM][MAX_NUM];
typedef struct
{
Adjist verties; //邻接表
int vexnum, arcnum;
int kind; //图的种类
}ALgraph;
带权图的边结点中info保存改变上的权值。
顶点Vi的边链表的头结点存放在下标为i的顶点数组中。
在邻接表的边链表中，各个边结点的链入顺序任意，视边结点输入次序而定。
设图中有n个结点，e条边，则用邻接表表示无向图时，需要n个顶点结点，2*e个边结点；
用邻接表表示有向图时，若不考虑你邻接表，只需n个顶点结点，e个边结点。
建立邻接表的时间复杂度为O(n*e)，若顶点信息为顶点的下标，则时间复杂度为O(n+e).
3、图的遍历
从图的某一个顶点出发访问遍图中其余顶点，且使每个顶点仅被访问过一次，就叫做图的遍历。
为避免重复访问，可设置一个表示顶点是否被访问过的辅助数组visited[]，它的初始状态设置为0，一旦某个结点被访问过则立即让对应的visited[i]=1
1）DFS 深度优先搜索
算法思想：
从图的某一结点v开始，由v出发，访问它的任一邻接顶点w1；再从w1出发，访问与w1邻接但还没有访问过的顶点w2；再从w2出发，进行类似的访问，…… 如此进行下去，直至到达所有的邻接顶点都被访问过的顶点u为止。接着，退回一步，退到前一次刚访问过的顶点，看是否还有其他没有访问过的邻接顶点。如果有，则访问此顶点，之后再从此顶点出发，进行与上述类似的访问；如果没有，就在退回一步进行搜索，重复上述过程，直到连通图中所有顶点都被访问过为止。（贪心算法？）
进一步描述：
（1）从图中某个顶点v出发，访问之；
（2）依次从顶点v的未被访问过的邻接点出发，深度优先遍历图，直到图中所有和顶点v有路径相同的顶点都被访问到；
（3）若此时图中尚有顶点未被访问到，则另选一个未被访问过的顶点作起始点，重复上述（1）（2）的操作，直到图中所哟的顶点都被访问到为止。
//DFS
//遍历算法
void Graph_Traverse(AdjGraph G)
{
int* visited = new int[NumVertices];
for(int i=0; i<G.n;i++)
visiter[i]=0; //访问数组visited初始化
for(int i=0;i<G.n;i++)
if(!visited[i])DFS(G, i, visited);
delete[] visited;
}
void DFS(AdjGraph G, int v, int visited[])
{
cout<<GetValue(G,v)<<" "<<endl; //访问顶点v
visited[v]=1;
int w=GetFirstNeighbor(G,v); //取v的第一个邻接顶点w
while(w!=-1)
{
if(!visited[w])DFS(G,w,visited); //若顶点w未访问过，递归访问顶点w
w=GetNextNeighbor(G,v,w); //取顶点v排在w后下一个邻接顶点
}
}
图中有n个顶点，e条边。
如果用邻接表表示图，沿Firstarc->nextarc 链可以找到某个顶点v 的所有邻接顶点w。由于总共有2e个边结点，所以扫描边的时间为O(e)，而且对所有顶点递归访问1次，时间复杂度为O(n+e)
如果用邻接矩阵表示图，则查找每一个顶点的所有的边，所需时间为O(n)，则时间复杂度为O(n^2).
2) 广度优先搜索BFS
算法思想：
访问了起始顶点v后，由v出发，依次访问v的各个未被访问过的邻接顶点w1, w2, w3,..., wt, 然后在顺序访问w1, w2, ... ,wt的所有还未被访问过的邻接顶点。再从这些访问过的邻接顶点出发，再访问它们的所有还未被访问过的邻接顶点，……如此做下去，直到图中所有顶点都被访问到为止。
进一步描述：
（1）从图中的某个顶点v出发，访问之；
（2）依次访问顶点v的各个未被访问过的邻接点，将v的全部邻接点都访问到；
（3）分别从这些邻接点出发，依次访问它们的未被访问过的邻接点，并使“先被访问过的顶点的邻接点” 先于“后被访问的顶点的邻接点”被访问，直到图中所有已被访问过的顶点的邻接点都被访问到。
//BFS
void Graph_Traverse(AdjGraph G)
{
int* visited = new int[NumVertices];
for(int i=0; i<G.n;i++)
visited[i]=0;
for(int i=0;i<G.n;i++)
if(!visited[i])BFS(G,i,visited);
delete[] visited;
}
void BFS(AdjGraph G, int v, int visited[])
{
cout<<GetValue(G, v)<<" "<<endl; //访问结点
Queue<int>q; //用队列来储存着一层正在访问的结点
InitQueue(&q);
EnQueue(&q,v); //进队列
while(!QueueEmpty(&q))
{
Dequeue(&q,v);
int w = GetFirstNeighbor(G,v);
while(w!=-1)
{
if(!visited[w])
{
cout<<GetValue(G, w)<<" "<<endl;
visited[w]=1;
EnQueue(&q, w);
}
w=GetNextNeighbor(G,v,w);
}
}
delete[] visited;
}
算法分析：
如果使用邻接表表示图，则循环的总时间代价为d0+d1+d2+ ... +d(n-1)=O(e)，其中的di是顶点i的度。
如果使用邻接矩阵，则对于每一个被访问过的顶点，循环要检测矩阵中的n个元素，总的时间代价为O(n^2).