算法与数据结构实验四

实验项目名称：实验四       

一、 实验目的

1）掌握图的邻接矩阵、邻接表存储结构表示及其创建算法
2）掌握图的深度优先搜索遍历算法和图的广度优先搜索遍历算法；
3）掌握图的最短路径的算法。

二、 实验内容

7-1 邻接表存储实现图的深度优先遍历

编写程序，实现由邻接表存储实现无向图的深度优先搜索遍历的功能。顶点为字符型。

输入格式:

第一行输入顶点个数及边的个数，第二行依次输入各顶点，第三行开始依次输入边的两个顶点，用空格分开。最后输入深度优先遍历的起始点。

输出格式:

输出深度优先遍历结果，空格分开，若起始点不合理，则输出error。

输入样例:

在这里给出一组输入。例如：

8 9

0 1 2 3 4 5 6 7

0 1

0 2

1 3

1 4

2 5

2 6

3 7

4 7

5 6

0

输出样例:

在这里给出相应的输出。例如：

0 2 6 5 1 4 7 3 

 

7-2 迪杰斯特拉方法实现最短路径

用迪杰斯特拉算法实现有向网的最短路径

输入格式:

第一行输入有向网的顶点和边数，第二行输入各顶点值，用空格间隔，第三行开始输入各条边的 两个点的及边上的权值，用空格间隔。最后一行输入要求路径的两个顶点。

输出格式:

输出最短路径经过的各顶点，中间用-->连接。

输入样例:

在这里给出一组输入。例如：

6 8

0 1 2 3 4 5

0 2 10

0 4 30

0 5 100

1 2 5

2 3 50

3 5 10

4 3 20

4 5 60

0 3

输出样例:

在这里给出相应的输出。例如：

0-->4-->3

 

 

三、 设计文档

 

 

四、 源程序

7-1 邻接表存储实现图的深度优先遍历

#include<iostream>

#include<cstdio>

using namespace std;

struct edge{

    int v;

    edge* next;

};

struct node{

    char val;

    edge* next;

}a[1010];

int n;

 

int find(char ch){

    for(int i=0;i<n;i++){

        if(a[i].val==ch){

            return i;

        }

    }

    return -1;

}

 

void add(int u,int v){

    edge* e=new edge();

    e->next=a[u].next;

    e->v=v;

    a[u].next=e;

}

 

bool st[1010];

void dfs(int u){

    cout<<a[u].val<<' ';

    st[u]=1;

    edge* e=a[u].next;

    while(e!=NULL){

        if(st[e->v]==0){

            dfs(e->v);

        }

        e=e->next;

    }

}

 

int main(){

    int m;

    cin>>n>>m;

    

    for(int i=0;i<n;i++){

        char ch;

        cin>>ch;

        a[i].val=ch;

    }

    

    for(int i=0;i<m;i++){

        char u,v;

        cin>>u>>v;

        int uu=find(u),vv=find(v);

        add(uu,vv);

        add(vv,uu);

    }

    

    char ch;

    cin>>ch;

    int k;

    if((k=find(ch))!=-1){

        dfs(k);

    }else{

        cout<<"error";

    }

    

    return 0;

}

 

 

 

7-2 迪杰斯特拉方法实现最短路径

#include<iostream>

#include<cstring>

#include<cstdio>

using namespace std;

const int N=1010;

 

struct edge{

    int v,w;

    edge* next;

};

struct node{

    int k;

    edge* next;

}a[1010];

int n;

 

int find(int u){

    for(int i=0;i<n;i++){

        if(a[i].k==u){

            return i;

        }

    }

    return -1;

}

 

void add(int u,int v,int w){

    edge* e=new edge();

    e->v=v;

    e->w=w;

    e->next=a[u].next;

    a[u].next=e;

}

 

int dis[N],pre[N];

bool st[N];

 

void dijkstra(int u){

    memset(pre,-1,sizeof pre);

    memset(dis,0x3f,sizeof dis);

    dis[u]=0;

    for(int i=0;i<n-1;i++){

        int k=-1;

        for(int j=0;j<n;j++){

            if(st[j]==0&&(k==-1||dis[j]<dis[k])){

                k=j;

            }

        }

        if(dis[k]==0x3f3f3f3f){

            continue;

        }

        st[k]=1;

        for(edge* j=a[k].next;j!=NULL;j=j->next){

            int v=j->v,w=j->w;

            if(dis[v]>dis[k]+w){

                dis[v]=dis[k]+w;

                pre[v]=k;

            }

        }

    }

}

 

void showRoad(int v){

    if(pre[v]!=-1){

        showRoad(pre[v]);

        cout<<"-->"<<a[v].k;

    }else{

        cout<<a[v].k;

    }

}

 

int main(){

    int m;

    cin>>n>>m;

     

    for(int i=0;i<n;i++){

        int k;

        cin>>k;

        a[i].k=k;

    }

     

    for(int i=0;i<m;i++){

        int u,v,w;

        cin>>u>>v>>w;

        int uu=find(u),vv=find(v);

        add(uu,vv,w);

    }

     

    int u,v;

    cin>>u>>v;

    dijkstra(u);

     

    showRoad(v);

     

    return 0;

}