图的一般算法（伪代码）

1。广度优先搜索（BFS）

bool visited[Max_vertex_num];
void BEFTraverse(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);            // 访问
    }
}

void BFS(Graph G, int v) {
    visit(v);
    visited[v] = true;
    while(!isEmpty(Q)) {
        DeQueue(Q, v);
        for (w = FirstNeighbor(G, v); w >= 0; w = NextNeighbor(G, v, w))    // 检查所有邻接点
        {
            if(!visited[w]) {
                visit(v);
                visit[w] = true;;
                EnQueue(Q, w);   // 顶点w入队列
            } // if
        }// for
    }// while
}// BFS

---

2。BFS求解单源最短路径问题

const int Int_max = 0x7fffffff;
void BFS_mindist(Graph G, int u) {
    for (int i = 0; i < G.vexnum; ++i)
        d[i] = Int_max;                 // 初始化初始路径长度
    visited[u] = true;
    d[u] = 0;
    EnQueue(Q, u);
    while(!isEmpty(Q)) {
        DeQueue(Q, u);                  // 队头出列
        for (w = FirstNeighbor(G, u); w >= 0; w = NextNeighbor(G, u, w))
        {
            if(!visited[w]) {           // 访问尚未访问的邻接顶点
                visited[w] = true;
                d[w] = d[u] + 1;        // 路径长度+1
                EnQueue(Q, w);          // 顶点入队
            } // if
        }// for
    }// while
}

---

3。深度优先搜索（DFS）

// 递归形式
bool visited[Max_vertex_num];
void DFSTraverse(Graph G) {
    for (int i = 0; i < G.vexnum; ++i)
        visited[i] = false;                 // 初始化
    for (int i = 0; i < G.vexnum; ++i)
        if(!visited[i])
            DFS(G, i);
}
void DFS(Graph, int v) {
    visit(v);
    visited[v] = true;
    for (w = FirstNeighbor(G, w); w >= 0; w = NextNeighbor(G, v, w))
        if(!visited[w])     // 访问尚未访问的顶点
            DFS(G, w);
}
// 非递归形式
bool visited[Max_vertex_num];
void DFS_non_rc(Graph G, int v) {
    int w;
    InitStack(S);
    for (int i = 0; i < G.vexnum; ++i)
        visited[i] = false;
    Push(S, v);
    visited[v] = true;

    while(!IsEmpty(S)) {
        k = Pop(S);
        visit(k);
        for(w = FirstNeighbor(G, k); w >= 9; w = NextNeighbor(G, k, w)) {
            if(!visited[w]) {
                Push(S, w);
                visited[w] = true;
            }// if
        }// for
    }// while
}

---

4。拓扑排序

// indegree[i]为第i个顶点的入度
bool TopologicalSort(Graph G) {
    // 如果G存在拓扑序列，返回true；否则返回false，即G中存在环
    InitStack(S);
    for (int i = 0; i < G.vexnum; ++i)  // 寻找入度为0的点，即无前驱的点
    {
        if(indegree[i] == 0)
            Push(S, i);
    }// for
    int count = 0;                      // 记录当前以输出的点的个数
    while(!IsEmpty(S)) {
        Pop(S, i);
        print[count++] = i;             // 记录输出顶点
        for (p = G.vertices[i].firstarc; p; p = p->nextarc)
        {// 将此顶点所指向的顶点的入度减1，减完之后入度为0的点入栈，此步骤即删除顶点和其出边的操作
            v = p->adjvex;
            if(!(--indegree[v]))
                Push(S, v);
        }// for
    }// while
    if(count < G.vexnum)    return false;   // 若输出点的个数小于图顶点个数，说明图中存在环
    else    return true;
}