数据结构—基于广度优先遍历算法的应用

/*
基于广度优先遍历算法的应用。
假设图G采用邻接表存储：
（1）求不带权无向连通图G中从顶点u到顶点v的一条最短路径；
（2）求不带权无向连通图G中距离顶点v的最远的一个顶点。
*/
#include 
#include 
#include 
#define MAXV 50
using namespace std;
int visited[MAXV];
//邻接表类型
typedef struct ANode
{
    int adjvex;             //该边的编号
    struct ANode *nextarc;  //指向下一条边的信息
} ArcNode;                  //边节点的类型

typedef struct Vnode
{
    ArcNode *firstarc;      //指向第一条边
} VNode;                    //邻接表头节点类型

typedef VNode AdjList[MAXV];
typedef struct
{
    AdjList adjlist;       //邻接表
    int n,e;               //图中顶点数n和边数e
} ALGraph;                 //完整的图邻接表类型

void ArrayToList(int *Arr, int n, ALGraph *&G)  //用普通数组构造图的邻接表
{
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    G->n=n;
    for (i=0; iadjlist[i].firstarc=NULL;
    for (i=0; i=0; j--)
            if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                p->adjvex=j;
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                G->adjlist[i].firstarc=p;
            }

    G->e=count;
}

void DispAdj(ALGraph *G)   //输出邻接表G
{
    int i;
    ArcNode *p;
    for (i=0; in; i++)
    {
        p=G->adjlist[i].firstarc;
        printf("%3d: ",i);
        while (p!=NULL)
        {
            printf("-->%d ",p->adjvex);
            p=p->nextarc;
        }
        printf("\n");
    }
}

/*
求不带权无向连通图G中从顶点u到顶点v的一条最短路径:
利用广度优先遍历算法，一层层的向外扩展，直到找到了终点即可。
*/
typedef struct
{
    int data;            //顶点编号
    int parent;          //前一个顶点的位置
}Queue;                  //非环形队列类型
void ShortPath(ALGraph *G,int u,int v)
{
    ArcNode *p;
    int w,i;
    Queue qu[MAXV];
    int front=-1,rear=-1;
    int visited[MAXV];
    for(i=0;in;i++)
        visited[i]=0;
    rear++;
    qu[rear].data=u;      //初始顶点入队
    qu[rear].parent=-1;
    visited[u]=1;
    while(front!=rear)
    {
        front++;
        w=qu[front].data; //出队顶点w
        if(w==v)
        {                  //找到v时输出路径之逆并退出
            i=front;
            while(qu[i].parent!=-1)
            {
                cout<adjlist[w].firstarc;   //找到w的第一个邻接点
        while(p!=NULL)
        {
            if(visited[p->adjvex]==0)
            {                       //将w未访问过的邻接点进队
                visited[p->adjvex]=1;
                rear++;
                qu[rear].data=p->adjvex;
                qu[rear].parent=front;
            }
            p=p->nextarc;          //找w的下一个邻接点
        }
    }
}

/*
求不带权无向连通图G中距离顶点v的最远的一个顶点:
利用广度优先遍历算法，一层层的向外扩展，直到找到了终点,最后一个顶点即为距离最远的顶点。
*/
int Maxdist(ALGraph *G,int v)
{
    ArcNode *p;
    int Qu[MAXV];
    int front=0,rear=0;
    int visited[MAXV];
    int i,j,k;
    for(i=0;in;i++)
        visited[i]=0;
    rear++;
    Qu[rear]=v;      //初始顶点入队
    visited[v]=1;
    while(rear!=front)
    {
        front=(front+1)%MAXV;
        k=Qu[front]; //出队顶点
        p=G->adjlist[k].firstarc;   //第一个邻接点
        while(p!=NULL)
        {                         //所有未访问过的相邻点入队
            j=p->adjvex;
            if(visited[j]==0)
            {                       //未访问过的邻接点进队
                visited[j]=1;
                rear=(rear+1)%MAXV;
                Qu[rear]=j;
            }
            p=p->nextarc;          //找w的下一个邻接点
        }
    }
    return k;
}

int main()
{
    int i;
    ALGraph *G1;
    int B[5][5]=
    {
        {0,1,0,1,1},
        {1,0,1,1,0},
        {0,1,0,1,1},
        {1,1,1,0,1},
        {1,0,1,1,0}
    };
    ArrayToList(B[0], 5, G1);
    for (i=0; in; i++)
        visited[i]=0; //访问标志数组初始化
    printf("无向图G1的邻接表:\n");
    DispAdj(G1);
    cout<n; i++)
        visited[i]=0; //访问标志数组初始化
    printf("求不带权无向连通图G中从顶点u到顶点v的一条最短路径:\n");
    ShortPath(G1,1,4);
    cout<n; i++)
        visited[i]=0; //访问标志数组初始化
    cout<<"求不带权无向连通图G中距离顶点v的最远的一个顶点："<

运行结果：