数据结构——广度优先搜索求点到点的最短路径

#include <iostream>
using namespace std;

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define NULL 0
#define MAX_VERTEX_NUM 20 // 最大顶点数

typedef char VertexType;
typedef int VRType;
typedef int InforType;

typedef struct ArcNode
{
        int adjvex;   //该边所指的顶点的位置
        struct ArcNode *nextarc;   //指向下一条边的指针
        //int weight;  //边的权
}ArcNode;   //表的结点

typedef struct VNode
{
        VertexType data;        //顶点信息（如数据等）
        ArcNode *firstarc;        //指向第一条依附该顶点的边的弧指针
}VNode, AdjList[MAX_VERTEX_NUM];   //头结点

typedef struct ALGraph
{
        AdjList vertices;
        int visited[MAX_VERTEX_NUM];    //访问标志数组
        int vexnum, arcnum;   //图的当前顶点数和弧数
}ALGraph;

//==============================================================================
typedef struct qnode
{
    char data;    
    struct qnode * pre;
    struct qnode * next;    
}Qnode, * Queueptr;    //    创建链 Qnode是struct qnode的别名，Queueptr是struct qnode *的别名
typedef struct
{
    Queueptr front;    //对头指针
    Queueptr rear;    //队尾指针
}LinkQueue;    //创建队列

//初始化队列
void InitQueue(LinkQueue *Q)
{
    Q->front=(Queueptr) malloc(sizeof(Qnode));    //队头和队尾指向头结点
    if(!Q->front)
    {
        cout<<"no memory avaliable"<<endl;    //存储分配失败
    }
    else
    {  
        Q->front->next=NULL;  
        Q->rear=Q->front;  
    }
}

//入队列函数
void Enqueue(LinkQueue *Q,int value)
{
    Queueptr newp=(Queueptr)malloc(sizeof(Qnode));
    if(!newp)
        cout<<"no memory avaliable"<<endl;    //存储分配失败
    newp->data=value;
    newp->next=NULL;
    Q->rear->next=newp;    //p插入原队尾
    Q->rear=newp;    //p成为新的队尾
}
//================================================================================

//初始化图
void init_ALGraph(ALGraph &g)
{
    for(int i=0;i<MAX_VERTEX_NUM;i++)
        g.visited[i]=0;        //访问标志数组置0，表示没有被访问
    g.vexnum=0;
    g.arcnum=0;
}
//返回顶点v在顶点向量中的位置
int LocateVex(ALGraph &G, char v)
{
        int i;
        for(i = 0; v != G.vertices[i].data && i < G.vexnum; i++)
                ;
        if(i >= G.vexnum)
                return -1;
        return i;
}

//增加节点
void add_vex(ALGraph &G)
{
        cout<<"输入无向图顶点数: "<<endl;
        cin>>G.vexnum;
        //getchar();    //吃回车
        cout<<"输入顶点信息:"<<endl;
        for(int i = 0; i < G.vexnum; i++)
        {
                cin>>G.vertices[i].data;   //构造顶点向量
                G.vertices[i].firstarc = NULL;
                //getchar();
        }
}

//增加边
void add_arc(ALGraph &G)
{
        ArcNode *s, *t;
        ArcNode *p;

        cout<<"输入无向图边数: "<<endl;
        cin>>G.arcnum;
        char v1, v2;
        cout<<"输入边信息:"<<endl;
        for(int k = 0; k < G.arcnum; k++)
        {
                cin>>v1>>v2;
                int i = LocateVex(G, v1);
                int j = LocateVex(G, v2);    //确定v1 , v2在G中的位置

                s = (ArcNode*) malloc (sizeof(ArcNode));
                t = (ArcNode*) malloc (sizeof(ArcNode));

                s->adjvex = j;   //该边所指向的顶点的位置为j
                s->nextarc = NULL;
                if(!G.vertices[i].firstarc)
                {
                    G.vertices[i].firstarc=s;
                }
                else
                {
                    for(p = G.vertices[i].firstarc; p->nextarc; p = p->nextarc)
                            ;
                    p->nextarc=s;
                }

                t->adjvex = i;   //该边所指向的顶点的位置为j
                t->nextarc = NULL;
                if(!G.vertices[j].firstarc)
                {
                    G.vertices[j].firstarc=t;
                }
                else
                {
                    for(p = G.vertices[j].firstarc; p->nextarc; p = p->nextarc)
                            ;
                    p->nextarc=t;
                }
        }
}

//构造邻接链表
void CreateUDN(ALGraph &G)
{
        add_vex(G);        //增加节点
        add_arc(G);        //增加边        
}


void PrintAdjList(ALGraph &G)
{
        int i;
        ArcNode *p;
        cout<<"编号    顶点    邻点编号"<<endl;

        for(i = 0; i < G.vexnum; i++)
        {
                cout<<"  "<<i<<"       "<<G.vertices[i].data<<"      ";
                for(p = G.vertices[i].firstarc; p; p = p->nextarc)
                        cout<<p->adjvex<<"  ";
                cout<<endl;
        }
}

//求点到点的最短路径
void Path(ALGraph &g,char ch1, char ch2, char path[])    //从第i个顶点开始搜索
{
    ArcNode *p;
    int i = LocateVex(g, ch1);
    int s = LocateVex(g, ch2);
    int found=0;
    char gettop;
    int top;

    LinkQueue *Q=(LinkQueue *)malloc(sizeof(LinkQueue));
    //初始化队列
    InitQueue(Q);

        g.visited[i]=1;        //处理源点
        Enqueue(Q,g.vertices[i].data);    //源点入队
        Q->rear->pre=Q->front;    //第一个节点的前驱指针指向front

        Queueptr temp=Q->front->next;        //处理队列中的每个顶点

        while(!found)    
        {
            gettop=temp->data;
            top= LocateVex(g, gettop);
            for(p = g.vertices[top].firstarc; p && !found; p = p->nextarc)
            {
                if(s == p->adjvex)    //找到目标点
                {
                    found=1;    //标志设为1，入队列，退出
                    Enqueue(Q,g.vertices[p->adjvex].data);
                    Q->rear->pre=temp;    //加入队列中的点，前驱指针指向它的源点
                }
                else if( !g.visited[p->adjvex] )    //如果不是，就访问，并加入队列
                {
                    g.visited[p->adjvex]=1;
                    Enqueue(Q,g.vertices[p->adjvex].data);    //入队
                    Q->rear->pre=temp;
                }
            }
            temp=temp->next;
        }//while


    int j=0;
    for(temp=Q->rear; temp!=Q->front; temp=temp->pre)    //复制队列中的顶点到字符串中去
            path[j++]=temp->data;
    path[j]='\0';
}

int main()
{
        ALGraph G;    
        init_ALGraph(G);    //初始化图    
        CreateUDN(G);        //创建图
        PrintAdjList(G);    //打印图

        //求点到点的最短路径
        char ch1,ch2;
        char *path;        //存放路径
        path=(char *)malloc( MAX_VERTEX_NUM*sizeof(char) );

        cout<<"please input two points:"<<endl;
        cin>>ch1>>ch2;
        Path(G,ch1,ch2,path);    //广度优先搜索

        int i=0;
        while(path[i])
            cout<<path[i++];    //输出路径
        cout<<endl;

        return 0;
}