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

以你之姓@ 2022-08-23 05:42 109阅读 0赞

/*
    基于广度优先遍历算法的应用。
    假设图G采用邻接表存储：
    （1）求不带权无向连通图G中从顶点u到顶点v的一条最短路径；
    （2）求不带权无向连通图G中距离顶点v的最远的一个顶点。
    */
    #include <iostream>
    #include <stdio.h>
    #include <malloc.h>
    #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; i<n; i++)                 //给邻接表中所有头节点的指针域置初值
            G->adjlist[i].firstarc=NULL;
        for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素
            for (j=n-1; j>=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; i<G->n; 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;i<G->n;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<<qu[i].data<<" ";
                    i=qu[i].parent;
                }
                cout<<qu[i].data;
                break;
            }
            p=G->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;i<G->n;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; i<G1->n; i++)
            visited[i]=0; //访问标志数组初始化
        printf("无向图G1的邻接表:\n");
        DispAdj(G1);
        cout<<endl;
        for (i=0; i<G1->n; i++)
            visited[i]=0; //访问标志数组初始化
        printf("求不带权无向连通图G中从顶点u到顶点v的一条最短路径:\n");
        ShortPath(G1,1,4);
        cout<<endl;
        for (i=0; i<G1->n; i++)
            visited[i]=0; //访问标志数组初始化
        cout<<"求不带权无向连通图G中距离顶点v的最远的一个顶点："<<Maxdist(G1,1)<<endl;
        cout<<endl;
        return 0;
    }

运行结果：

![Center][]

[Center]: /images/20220721/b14c7bb4c30346e6bd0b669658b14890.png