/misc/src/release/graphviz-2.18-1/src/graphviz-2.18/lib/neatogen/bfs.c

Go to the documentation of this file.
00001 /* $Id: bfs.c,v 1.3 2006/12/07 22:49:36 erg Exp $ $Revision: 1.3 $ */
00002 /* vim:set shiftwidth=4 ts=8: */
00003 
00004 /**********************************************************
00005 *      This software is part of the graphviz package      *
00006 *                http://www.graphviz.org/                 *
00007 *                                                         *
00008 *            Copyright (c) 1994-2004 AT&T Corp.           *
00009 *                and is licensed under the                *
00010 *            Common Public License, Version 1.0           *
00011 *                      by AT&T Corp.                      *
00012 *                                                         *
00013 *        Information and Software Systems Research        *
00014 *              AT&T Research, Florham Park NJ             *
00015 **********************************************************/
00016 
00017 
00018 /******************************************
00019 
00020         Breadth First Search
00021         Computes single-source distances for
00022         unweighted graphs
00023 
00024 ******************************************/
00025 
00026 #include "bfs.h"
00027 #include <stdlib.h>
00028 /* #include <math.h> */
00029 
00030 void bfs(int vertex, vtx_data * graph, int n, DistType * dist, Queue * Q)
00031  /* compute vector 'dist' of distances of all nodes from 'vertex' */
00032 {
00033     int i;
00034     int closestVertex, neighbor;
00035     DistType closestDist = INT_MAX;
00036 
00037     /* initial distances with edge weights: */
00038     for (i = 0; i < n; i++)
00039         dist[i] = -1;
00040     dist[vertex] = 0;
00041 
00042     initQueue(Q, vertex);
00043 
00044     if (graph[0].ewgts == NULL) {
00045         while (deQueue(Q, &closestVertex)) {
00046             closestDist = dist[closestVertex];
00047             for (i = 1; i < graph[closestVertex].nedges; i++) {
00048                 neighbor = graph[closestVertex].edges[i];
00049                 if (dist[neighbor] < -0.5) {    /* first time to reach neighbor */
00050                     dist[neighbor] = closestDist + 1;
00051                     enQueue(Q, neighbor);
00052                 }
00053             }
00054         }
00055     } else {
00056         while (deQueue(Q, &closestVertex)) {
00057             closestDist = dist[closestVertex];
00058             for (i = 1; i < graph[closestVertex].nedges; i++) {
00059                 neighbor = graph[closestVertex].edges[i];
00060                 if (dist[neighbor] < -0.5) {    /* first time to reach neighbor */
00061                     dist[neighbor] =
00062                         closestDist +
00063                         (DistType) graph[closestVertex].ewgts[i];
00064                     enQueue(Q, neighbor);
00065                 }
00066             }
00067         }
00068     }
00069 
00070     /* For dealing with disconnected graphs: */
00071     for (i = 0; i < n; i++)
00072         if (dist[i] < -0.5)     /* 'i' is not connected to 'vertex' */
00073             dist[i] = closestDist + 10;
00074 }
00075 
00076 int
00077 bfs_bounded(int vertex, vtx_data * graph, int n, DistType * dist,
00078             Queue * Q, int bound, int *visited_nodes)
00079  /* compute vector 'dist' of distances of all nodes  from 'vertex' */
00080  /* ignore nodes whose distance to 'vertex' is more than bound */
00081 {
00082     /* we assume here, that all distances are initialized with -1 !!!! */
00083 
00084     int i;
00085     int num_visit;
00086     int closestVertex, neighbor;
00087     DistType closestDist;
00088     /* initialize distances with edge weights: */
00089     /* for (i=0; i<n; i++)  */
00090     /* dist[i]=-1; */
00091 
00092     dist[vertex] = 0;
00093 
00094     initQueue(Q, vertex);
00095 
00096     num_visit = 0;
00097     while (deQueue(Q, &closestVertex)) {
00098         closestDist = dist[closestVertex];
00099         if (closestDist > bound) {
00100             dist[closestVertex] = -1;
00101             break;
00102         } else {
00103             visited_nodes[num_visit++] = closestVertex;
00104         }
00105         for (i = 1; i < graph[closestVertex].nedges; i++) {
00106             neighbor = graph[closestVertex].edges[i];
00107             if (dist[neighbor] < -0.5) {        /* first time to reach neighbor */
00108                 dist[neighbor] = closestDist + 1;
00109                 enQueue(Q, neighbor);
00110             }
00111         }
00112     }
00113 
00114     /* set distances of all nodes in Queue to -1 */
00115     /* for next run */
00116     while (deQueue(Q, &closestVertex)) {
00117         dist[closestVertex] = -1;
00118     }
00119     dist[vertex] = -1;
00120     return num_visit;
00121 }
00122 
00123 #ifndef __cplusplus
00124 
00125 void mkQueue(Queue * qp, int size)
00126 {
00127     qp->data = N_GNEW(size, int);
00128     qp->queueSize = size;
00129     qp->start = qp->end = 0;
00130 }
00131 
00132 Queue *newQueue(int size)
00133 {
00134     Queue *qp = GNEW(Queue);
00135     mkQueue(qp, size);
00136     return qp;
00137 }
00138 
00139 void freeQueue(Queue * qp)
00140 {
00141     free(qp->data);
00142 }
00143 
00144 void delQueue(Queue * qp)
00145 {
00146     free(qp->data);
00147     free(qp);
00148 }
00149 
00150 void initQueue(Queue * qp, int startVertex)
00151 {
00152     qp->data[0] = startVertex;
00153     qp->start = 0;
00154     qp->end = 1;
00155 }
00156 
00157 boolean deQueue(Queue * qp, int *vertex)
00158 {
00159     if (qp->start >= qp->end)
00160         return FALSE;           /* underflow */
00161     *vertex = qp->data[qp->start++];
00162     return TRUE;
00163 }
00164 
00165 boolean enQueue(Queue * qp, int vertex)
00166 {
00167     if (qp->end >= qp->queueSize)
00168         return FALSE;           /* overflow */
00169     qp->data[qp->end++] = vertex;
00170     return TRUE;
00171 }
00172 
00173 #endif

Generated on Mon Mar 31 19:03:27 2008 for Graphviz by  doxygen 1.5.1