数据结构躬行记7_图(邻接矩阵&深度优先&广度优先)

图

要点

重点在于掌握图的基本概念和存储，以及求关键路径、最短路径、拓扑排序的方法。

概念

图G由两个集合V和E组成，记为G=（V,E），其中V是顶点的有穷非空集合，E是V中顶点偶对 （称为边）的有穷集合。通常，也将图G的顶点集和边集分别记为V（G）和E（G）。E（G）可以是 空集。若E（G）为空，则图G只有顶点而没有边。

图的存储结构

邻接矩阵

邻接矩阵

图的遍历

图的遍历也是从某个顶点出发，沿着某条搜索路径对图中每个顶点各做一次且仅做一次访问， 常用的遍历算法包括以下深度优先和广度优先两种

代码实现

#include<iostream>
#include<queue>
#include<string.h>
using namespace std;
#define MaxInt 10000
#define Max_V 100
typedef char Vtype;//顶点数据类型是字符型
typedef int Arctype;//边的权值是整形
bool visited[MaxInt];
//图的邻接矩阵存储方式
typedef struct
{
    Vtype Vdata[Max_V];    //顶点数据
    Arctype arcs[Max_V][Max_V]; //邻接矩阵
    int vexnum,arcnum; //顶点数和边数
}AMGraph;


//邻接矩阵创建无向网
int LocateVex(AMGraph G,Vtype v);
void CreateGraph(AMGraph &G)
{
    cout<<"请输入无向网的顶点个数和边的条数:"<<endl;
    cin>>G.vexnum>>G.arcnum;
    cout<<"请依次输入顶点的信息:"<<endl;
    for(int i=0;i<G.vexnum;i++)
        cin>>G.Vdata[i];  //此处存放v1 v2 等等节点的名字
    for(int i=0;i<G.vexnum;i++)
        for(int j=0;j<G.vexnum;j++)
        G.arcs[i][j] = MaxInt;

    cout<<"请依次输入边的俩个顶点信息和边的权值:"<<endl;
    for(int k=0;k<=G.vexnum;k++)
    {
        int i,j;
        char v1,v2;
        Arctype w;

        cin>>v1>>v2>>w;
        i = LocateVex(G,v1);
        j = LocateVex(G,v2);
        G.arcs[i][j] = w;
        G.arcs[j][i] = G.arcs[i][j];
    }
}
void Initvisited(AMGraph G,bool v[])
{
    for(int i=0;i<G.vexnum;i++)
        v[i] = false;
}
//深度遍历无向网
void DFS_AM(AMGraph G,int v)
{
    int j;
    if(!visited[v]){
        cout<<G.Vdata[v]<<"->";
        visited[v] = true;
    }
    for(j=0;j<G.vexnum;j++)
    {
        if(G.arcs[v][j]!=MaxInt&&!visited[j])
        {
            DFS_AM(G,j);
        }
    }
}

//广度优先遍历无向网
void BFS(AMGraph G,int v)
{
    queue<Vtype> q;
    int i;
    if(!visited[v])
    {
        cout<<G.Vdata[v]<<"->";
        q.push(v);
        visited[v] = true;
    }
    while(!q.empty())
    {
        i = q.front();
        q.pop();
        for(int j=0;j<G.vexnum;j++)
        {
            if(G.arcs[i][j]!=MaxInt&&!visited[j])
            {
                cout<<G.Vdata[j]<<"->";
                q.push(j);
                visited[j] = true;
            }
        }
    }
}

int LocateVex(AMGraph G,Vtype v)
{
    int i;
    for(i=0;i<G.vexnum;i++)
    {
        if(G.Vdata[i] ==v)
            return i;
    }
    return -1;
}

int main()
{
    AMGraph m;
    CreateGraph(m);
    Initvisited(m,visited);
    cout<<"深度优先遍历:"<<endl;
    DFS_AM(m,0);
    Initvisited(m,visited);
    //memset(visited,false,sizeof(visited));
    cout<<endl;
    cout<<"广度优先遍历:"<<endl;
    BFS(m,0);
  return 0;
}

总结

深度遍历的思想是递归，类似于先序遍历输出，广度优先遍历涉及到了栈的知识，一个节点入栈之后接下来入栈的便是上一个入栈节点的子节点（孩子），这样就实现了广度优先。