数据结构实验--图的遍历及Dijkstra算法

实验内容

（1）采用邻接表建立图；
（2）采用深度优先/广度优先搜索方式遍历图；
（3）编程实现Dijkstra最短路径算法。
参考界面：

实验步骤

1. 邻接表创建有向图，先输入顶点值，创建表头结点并初始化表头结点指针域为空；接下来输入边的信息构造邻接表，输入一条边依附的两个顶点及其权值，用LocateVex（）方法获取顶点位置，生成一个新结点p并将输入信息赋值给p。
2. 深度优先遍历，类似于树的先序遍历。从某个顶点v出发，访问v并置相应标志位true；然后新结点p指向刚访问结点的第一个边结点，如果其非空且标志数组为false则递归访问，然后p指向下一个边结点。
3. 广度优先遍历，类似于树的层序遍历，借助一个辅助队列数组。从第一个结点开始，若未访问，则访问输出并置标志位为true，然后v入队。若队列非空，则队头顶点u出队，依次检查u的邻接点w，若w访问过，则入队，未访问则访问，直到队列为空。
4. Dijkstra最短路径算法
   （1）初始化最短路径数组D，将其赋值为最大值10000；
   （2）如果v0与vi之间有弧，则将他们的权值赋给D[i]；
   （3）初始化数组S，将源点v0加到S中，即S[v0] = true；
   （4）选择下一条最短路径的终点vk，令S[k]=true；
   （5）根据条件更新从v0到其他顶点的最短路径的长度，若D[k]+p->info < D[p->adjvex],则令D[p->adjvex]= D[k]+p->info。

代码示例

#include <iostream>
#include<iomanip>
using namespace std;

//图的邻接表存储表示
#define MVNum 100           //最大顶点数
bool visited[MVNum]= {false};          //访问标志数组，其初值为false
typedef int OtherInfo;
typedef char VerTexType;
//边结点
typedef struct ArcNode
{
    int adjvex;                                    //该边所指向的顶点的位置
    struct ArcNode *nextarc;          //指向下一条边的指针
    OtherInfo info;                           //和边相关的信息,权值
} ArcNode;
//顶点信息
typedef struct VNode
{
    VerTexType data;                    //顶点的值
    ArcNode *firstarc;                  //指向第一条依附该顶点的边的指针
} VNode,AdjList[MVNum];
//邻接表
typedef struct
{
    AdjList vertices;
    int vexnum,arcnum;          //图的当前顶点数和边数
} ALGraph;


/************************确定顶点u在图中的位置**************************/
int LocateVex(ALGraph G,VerTexType u)
{
    //若G中存在顶点u，则返回该顶点的位置，否则返回-1
    for(int i=0; i<G.vexnum; i++)
    {
        if(u==G.vertices[i].data)
            return i;
    }
    return -1;
}

/****************************采用邻接表创建有向图**********************/
void CreatDG(ALGraph &G)
{
    VerTexType v1,v2;
    OtherInfo info;
    cout<<"输入图的总顶点数和总边数：";
    cin>>G.vexnum>>G.arcnum;

    //构造表头结点
    cout<<"输入顶点的值：";
    for(int i=0; i<G.vexnum; i++)
    {
        cin>>G.vertices[i].data;          //输入顶点值
        G.vertices[i].firstarc=NULL;      //初始化表头结点的指针域为空
    }

    //边结点
    int j,k;
    cout << "输入一条边依附的两个顶点以及边的权值：";
    for(int i=0; i<G.arcnum; i++)
    {
        cin >> v1 >> v2 >> info;
        j = LocateVex(G,v1);
        k = LocateVex(G,v2);  //确定v1,v2在G中的位置，即顶点在G.vertices中的序号
        ArcNode* p1 = new ArcNode;                       //生成一个新的边结点
        p1->adjvex = k;                                          //邻接点序号为k
        p1->info = info;
        p1->nextarc = G.vertices[j].firstarc;
        G.vertices[j].firstarc = p1;
    }

}

/*****************************深度优先遍历****************************/
void DFS_AL(ALGraph G,int v)
{
    //图G为邻接表类型，从第v个顶点出发深度优先遍历图G
    int w;
    cout<<G.vertices[v].data<<" ";
    visited[v]=true;    //访问第v个顶点，并置访问标志数组相应分量为true
    ArcNode *p=G.vertices[v].firstarc;                                //p指向v的边链表的第一个结点
    while(p!=NULL)
    {
        w=p->adjvex;                 //表示w是v的邻接点
        if(!visited[w])
            DFS_AL(G,w);
        p=p->nextarc;                 //p指向下一个边结点
    }
}

/*****************************广度优先遍历****************************/
void BFS_AL(ALGraph G)
{
    int v,w;

    //辅助队列
    int front=0, rear = 0;
    VNode Queue[MVNum];
    ArcNode *p;

    //初始化标志数组
	for (v = 0; v < G.vexnum; ++v)
	{
		visited[v] = false;
	}

    for (v = 0; v < G.vexnum; v++)
    {
        if (!visited[v])//v尚未访问
        {
            visited[v] =true;
            cout << G.vertices[v].data<<" ";
            Queue[++rear] = G.vertices[v];//v入队列
            while (front != rear)//判断队列是否为空
            {
                VNode u = Queue[++front];//队头元素出队列，并等于u
                /*
                判断该结点的后序表结点,存在即输出，入队列
                */
                for (p = u.firstarc; p; p = p->nextarc)
                {
                    w = p->adjvex;
                    if (!visited[w])
                    {
                        visited[w] = true;
                        cout << G.vertices[w].data << " ";
                        Queue[++rear] = G.vertices[w];
                    }
                }
            }
        }
    }
}


/**************************Dijkstra最短路径**********************/
void ShortestPath_DIJ(ALGraph G,int v0)
{
    int n = G.vexnum,k;
    bool S[n] = {false};
    OtherInfo D[n],Min;
    int Path[n];

    ArcNode* p;
    //初始化最短路径的值
    for(int v=0; v<n; ++v)
        D[v] = 10000;
    p = G.vertices[v0].firstarc;
    //将与v0相关联的边的权值赋给D[]
    while(p != NULL)
    {
        D[p->adjvex] = p->info;
        p = p->nextarc;
    }
    S[v0] = true;       //将v0加入终点集
    Path[0] = v0;       //记录最短路径
    D[v0] = 0;
    for(int v=1; v<n; ++v)
    {
        Min = 10000;
        //寻找最小值
        for(int w=0; w<n; ++w)
        {
            if(!S[w] && D[w]<Min)
            {
                k = w;
                Min = D[w];
            }
        }
        S[k] = true;
        Path[v] = k;
        p = G.vertices[k].firstarc;
        while(p != NULL)
        {
            if(!S[p->adjvex] && D[k]+p->info<D[p->adjvex])
                D[p->adjvex] = D[k]+p->info;
            p = p->nextarc;
        }
    }
    for(int i=1; i<n; i++)
    {
        cout << "终点集为：";
        for(int j=0; j<=i; j++)
            cout << G.vertices[Path[j]].data;
        cout << setw(15) << "最短路径值为:" << D[Path[i]] << endl;
    }
}

/*************************显示邻接表*************************/
void show(ALGraph G)
{
	int i;
	ArcNode *p;
	cout << "输出邻接表（（0）代表无权值）：" << endl;
	for (i = 0; i < G.vexnum; ++i)
	{
		cout<<i<<":"<< G.vertices[i].data;
		p = G.vertices[i].firstarc;
		while (p)
		{
			cout<<"   -> "<<p->adjvex<<"("<<p->info<<")";
			p = p->nextarc;
		}
		cout << endl;
	}
}

void show_help()
{
    cout<<"******* Data Structure ******"<<endl;
    cout<<"1----邻接表建立图"<<endl;
    cout<<"2----深度优先遍历"<<endl;
    cout<<"3----广度优先遍历"<<endl;
    cout<<"4----Dijkstra最短路径"<<endl;
    cout<<"5----显示邻接表"<<endl;
    cout<<"     退出，输入0"<<endl;
}

int main()
{
    char operate_code;
    show_help();
    ALGraph G;
    int v0;
    VerTexType data;
    while(1)
    {
        cout<<"请输入操作选项: ";
        cin>>operate_code;
        if(operate_code=='1')
        {
            CreatDG(G);
        }
        else if (operate_code=='2')
        {
            cout<<"深度优先遍历结果：";
            DFS_AL(G,0);
            cout<<endl;
        }
        else if (operate_code=='3')
        {
            cout<<"广度优先遍历结果：";
            BFS_AL(G);
            cout<<endl;
        }
        else if (operate_code=='4')
        {
            cout<<"请输入v0的值：";
            cin>>data;
            v0=LocateVex(G,data);
            ShortestPath_DIJ(G,v0);
        }
        else if (operate_code=='5')
        {
            show(G);
        }
        else if (operate_code=='0')
        {
            break;
        }
        else
        {
            cout<<"\n操作码错误！！！"<<endl;
            show_help();
        }
    }
    return 0;
}