图的遍历、拓扑排序、最短路径算法

//深度优先遍历：
void DFSTraverse ( Graph G )
{
  visited [0 .. G.vexnum-1] = false;   // 初始化访问标志为未访问(false)
  for ( v = 0; v < G.vexnum; v ++ )
    if ( ! visited[v] )  DFS ( G, v );  // 从未被访问的顶点开始DFS
}

void DFS ( Graph G, int v )
{
  visit ( v );  visited [v] = true;   // 访问顶点v并作标记
  for ( w = FirstAdjVex(G,v); w >= 0; w = NextAdjVex(G,v,w) )
    if ( ! visited[w] )  DFS ( G, w );  // 分别从每个未访问的邻接点开始DFS
}

//广度优先遍历：利用队列(类似按层遍历二叉树)。
void BFSTraverse ( Graph G )
{
  visited [0 .. G.vexnum-1] = false;   // 初始化访问标志为未访问(false)
  InitQueue ( Q );
  for ( v = 0; v < G.vexnum; v++ )
    if ( ! visited[v] )
    {
      // 从v出发广度优先搜索
      visit ( v );  visited [v] = true;
      EnQueue ( Q, v );
      while ( ! QueueEmpty(Q) )
      {
        DeQueue ( Q, u );
        for ( w = FirstAdjVex(G,u); w >= 0; w = NextAdjVex(G,u,w) )
          if ( ! visited[w] )
          {
            visit ( w );  visited [w] = true;
            EnQueue ( Q, w );
          }
      }
    }
}

//拓扑排序：可以测试一个有向图是否有环
void Graph::topsort( )
{
    Queue<Vertex> q;
    int counter = 0;
    q.makeEmpty( );
    for each Vertex v
        if( v.indegree == 0 )
            q.enqueue( v );
    while( !q.isEmpty( ) )
    {
        Vertex v = q.dequeue( );
        v.topNum = ++counter;  // Assign next number
        for each Vertex w adjacent to v
            if( --w.indegree == 0 )
                q.enqueue( w );
    }
    if( counter != NUM_VERTICES )
        throw CycleFoundException( );
}

/*迪杰斯特拉算法：
求一个顶点到其他各顶点的最短路径。
算法：
(a) 初始化：用起点v到该顶点w的直接边(弧)初始化最短路径，否则设为∞；
(b) 从未求得最短路径的终点中选择路径长度最小的终点u：即求得v到u的最短路径；
(c) 修改最短路径：计算u的邻接点的最短路径，若(v,…,u)+(u,w)<(v,…,w)，则以(v,…,u,w)代替。
(d) 重复(b)-(c)，直到求得v到其余所有顶点的最短路径。
特点：总是按照从小到大的顺序求得最短路径。
*/
//单源最短路径dijkstra算法：s点到其他各顶点的最短路径
void Graph::dijkstra( Vertex s )
{
    for each Vertex v
    {
        v.dist = INFINITY;
        v.known = false;
    }
    s.dist = 0;
    for( ; ; )
    {
        Vertex v = smallest unknown distance vertex;
        if( v == NOT_A_VERTEX )
            break;
        v.known = true;
        for each Vertex w adjacent to v
            if( !w.known )
                if( v.dist + cvw < w.dist )
                {
                    // Update w
                    w.dist = v.dist + cvw;
                    w.path = v;
                }
    }
}

//图边的权值为1，最短路径：s点到其他各顶点的最短路径
void Graph::unweighted( Vertex s )
{
    for each Vertex v
    {
        v.dist = INFINITY;
        v.known = false;
    }
    s.dist = 0;
    for( int currDist = 0; currDist < NUM_VERTICES; currDist++ )
        for each Vertex v
            if( !v.known && v.dist == currDist )
            {
                v.known = true;
                for each Vertex w adjacent to v
                    if( w.dist == INFINITY )
                    {
                        w.dist = currDist + 1;
                        w.path = v;
                    }
            }
}
//图边的权值为1，最短路径：s点到其他各顶点的最短路径
void Graph::unweighted( Vertex s )
{
    Queue<Vertex> q;
    for each Vertex v
        v.dist = INFINITY;
    s.dist = 0;
    q.enqueue( s );
    while( !q.isEmpty( ) )
    {
        Vertex v = q.dequeue( );
        for each Vertex w adjacent to v
            if( w.dist == INFINITY )
            {
                w.dist = v.dist + 1;
                w.path = v;
                q.enqueue( w );
            }
    }
}

//有负边值的加权最短路径算法
void Graph::weightedNegative( Vertex s )
{
    Queue<Vertex> q;
    for each Vertex v
        v.dist = INFINITY;
    s.dist = 0;
    q.enqueue( s );
    while( !q.isEmpty( ) )
    {
        Vertex v = q.dequeue( );
        for each Vertex w adjacent to v
            if( v.dist + cvw < w.dist )
            {
                // Update w
                w.dist = v.dist + cvw;
                w.path = v;
                if( w is not already in q )
                    q.enqueue( w );
            }
    }
}

/**
 * Compute all-shortest paths.
 * a contains the adjacency matrix with a[ i ][ i ] presumed to be zero.
 * d contains the values of the shortest path.
 * Vertices are numbered starting at 0; all arrays have equal dimension. 
 * A negative cycle exists if d[ i ][ i ] is set to a negative value.
 * Actual path can be computed using path[ ][ ].
 * NOT_A_VERTEX is -1
 */
void allPairs( const matrix<int> & a, matrix<int> & d, matrix<int> & path ) 
{
    int n = a.numrows( );
    // Initialize d and path
    for( int i = 0; i < n; i++ )
        for( int j = 0; j < n; j++ )
        {
            d[ i ][ j ] = a[ i ][ j ];
            path[ i ][ j ] = NOT_A_VERTEX;
        }
    for( int k = 0; k < n; k++ )
        // Consider each vertex as an intermediate
        for( int i = 0; i < n; i++ )
            for( int j = 0; j < n; j++ )
                if( d[ i ][ k ] + d[ k ][ j ] < d[ i ][ j ] )
                {
                    // Update shortest path
                    d[ i ][ j ] = d[ i ][ k ] + d[ k ][ j ];
                    path[ i ][ j ] = k;
                }
}