图

存储结构

1. 邻接矩阵存储结构

#define MaxVertexNum 100
typedef char VertexType;
typedef int EdgeType;
typedef struct
{
     
    VertexType Vex[MaxVertexNum];
    EdgeType Edge[MaxVertexNum][MaxVertexNum];
    int vexnum,arcnum;
} MGraph;

2. 邻接表存储结构

#define MaxVertexNum 100
typedef struct ArcNode // 边表结点
{
     
    int adjvex;
    struct ArcNode *next;
    //InfoType info;    // 网的边权值
} ArcNode;
typedef struct VNode // 顶点表结点
{
     
    VertexType data;
    ArcNode *first;
} VNode,AdjList[MaxVertexNum];
typedef struct // 邻接表
{
     
    AdjList vertices;
    int vexnum,arcnum;
} ALGraph;

算法

1. 广度优先搜索

//Graph以及FirstNeighbor、NextNeighbor函数可利用两种表类型处理
bool visited[MaxVertexNum];
SqQueue Q;// 队列
void BFS(Graph G,int v)
{
     
    visit(G,v);
    visited[v]=true;
    Enqueue(Q,v);
    while(!isEmpty(Q))
    {
     
        DeQueue(Q,v);
        for(int w=FirstNeighbor(G,v); w>=0; w=NextNeighbor(G,v,w))
            if(!visited[w])
            {
     
                visit(G,w);
                visited[w]=true;
                EnQueue(Q,w);
            }
    }
}
void BFSTraverse(Graph G)
{
     
    for(int i=0; i<G.vexnum; ++i)
        visited[i]=false;
    InitQueue(Q);
    for(int i=0; i<G.vexnum; ++i)
        if(!visited[i])
            BFS(G,i);
}

2. BFS求单源最短路径

#define inf 1000000
bool visited[MaxVertexNum];
SqQueue Q;// 队列
void BFS_MIN_Distance(Graph G,int u)
{
     
    //d[i]表示从u到i的最短路径
    for(int i=0; i<G.vexnum; ++i)
        d[i]=inf;
    for(int i=0; i<G.vexnum; ++i)
        visited[i]=false;
    InitQueue(Q);
    visited[u]=true;
    d[u]=0;
    EnQueue(Q,u);
    while(!isEmpty(Q))
    {
     
        DeQueue(Q,u);
        for(int w=FirstNeighbor(G,u); w>=0; w=NextNeighbor(G,u,w))
            if(!visited[w])
            {
     
                visited[w]=true;
                d[w]=d[u]+1;
                EnQueue(Q,w);
            }
    }
}

3. 深度优先搜索

bool visited[MaxVertexNum];
void DFS(Graph G,int v)
{
     
    visit(v);
    visited[v]=true;
    for(int w=FirstNeighbor(G,v); w>=0; w=NextNeighbor(G,v,w))
        if(!visited[w])
            DFS(G,w);
}
void DFSTraverse(Graph G)
{
     
    for(int v=0; v<G.vexnum; ++v)
        visited[v]=false;
    for(int v=0; v<G.vexnum; ++v)
        if(visited[v])
            DFS(G,v);
}

4. 拓扑排序

SqStack S;
int print[MaxVertexNum];
int indegree[MaxVertexNum];// 入度
bool TopologicalSort(ALGraph G)
{
     
    InitStack(S);
    int i;
    for(i=0; i<G.vexnum; ++i)
        if(indegree[i]==0)
            Push(S,i);
    int count=0;
    while(!IsEmpty(S))
    {
     
        Pop(S,i);
        print[count++]=i;
        for(p=G.vertices[i].first; p; p=p->next)
        {
     
            v=p->adjvex;
            if(!(--indegree[v]))
                Push(S,v);
        }
    }
    if(count<G.vexnum)
        return false;
    else
        return true;
}