图的遍历：深度优先遍历，广度优先遍历

Posted 2023-05-16

参考技术A 连通图的深度优先遍历类似与树的先根遍历

DFS结果是213546

■用邻接矩阵来表示图，遍历图中每一个顶点都要从头扫描该顶点所在行
行，时间复杂度为O(n7)。
■用邻接表来表示图，虽然有2e个表结点，但只需扫描e个结点即可
完成遍历，加上访问n个头结点的时间，时间复杂度为O(n+ e)。

稠密图适于在邻接矩阵.上进行深度遍历;
稀疏图适于在邻接表上进行深度遍历。

●如果使用邻接矩阵，则BFS对于每个被访问到的顶点， 都要循巩
检测矩阵中的整整一行( n个元素) ,总的时间代价为O(n7)。
●用邻接表来表示图，虽然有2e个表结点，但只需扫描e个结点即
可完成遍历，加上访问n个头结点的时间，时间复杂度为O(n+e)。

●空间复杂度相同，都是O(n)(借用了堆栈或队列) ;
●时间复杂度只与存储结构(邻接矩阵或邻接表)有关，而与搜索路径无
关。

图的广度优先遍历和深度优先遍历

 图是一种很重要的数据结构，在我们的编程生活中应用极其广泛

 

 

 

#include <iostream>
using namespace std;
#define INFINITY 32767
#define MAX_VEX 20 //最大顶点个数
#define QUEUE_SIZE (MAX_VEX+1) //队列长度

bool *visited;  //访问标志数组
//图的邻接矩阵存储结构
typedef struct
{
    char *vexs; //顶点向量
    int arcs[MAX_VEX][MAX_VEX]; //邻接矩阵
    int vexnum,arcnum; //图的当前顶点数和弧数
}Graph;
//队列类
class Queue{
public:
    void InitQueue()
    {
        base=(int *)malloc(QUEUE_SIZE*sizeof(int));
        front=rear=0;
    }
    void EnQueue(int e)
    {
        base[rear]=e;
        rear=(rear+1)%QUEUE_SIZE;
    }
    void DeQueue(int &e)
    {
        e=base[front];
        front=(front+1)%QUEUE_SIZE;
    }
public:
    int *base;
    int front;
    int rear;
};


//图G中查找元素c的位置
int Locate(Graph G,char c)
{
    for(int i=0;i<G.vexnum;i++)
        if(G.vexs[i]==c) 
            return i;
    return -1;
}


//创建无向网
void CreateUDN(Graph &G)
{
    int i,j,w,s1,s2;
    char a,b,temp;
    cout<<"输入顶点数和弧数:";
    cin>>G.vexnum>>G.arcnum;
    G.vexs=(char *)malloc(G.vexnum*sizeof(char)); //分配顶点数目
    cout<<"输入"<<G.vexnum<<"个顶点."<<endl;
    for(i=0;i<G.vexnum;i++)
    { 
        //初始化顶点
        cout<<"输入顶点"<<i+1<<":";
        cin>>G.vexs[i];
    }
    for(i=0;i<G.vexnum;i++) //初始化邻接矩阵
        for(j=0;j<G.vexnum;j++)
            G.arcs[i][j]=INFINITY;
    cout<<"输入"<<G.arcnum<<"条弧."<<endl;
    for(i=0;i<G.arcnum;i++)
    { 
        //初始化弧
        cout<<"输入弧"<<i+1<<":";
        cin>>a>>b>>w; //输入一条边依附的顶点和权值
        s1=Locate(G,a);
        s2=Locate(G,b);
        G.arcs[s1][s2]=G.arcs[s2][s1]=w;
    }
}


//图G中顶点k的第一个邻接顶点
int FirstVex(Graph G,int k)
{
    if(k>=0 && k<G.vexnum)
    { 
        //k合理
        for(int i=0;i<G.vexnum;i++)
            if(G.arcs[k][i]!=INFINITY) 
                return i;
    }
    return -1;
}


//图G中顶点i的第j个邻接顶点的下一个邻接顶点
int NextVex(Graph G,int i,int j)
{
    if(i>=0 && i<G.vexnum && j>=0 && j<G.vexnum)
    { 
        //i,j合理
        for(int k=j+1;k<G.vexnum;k++)
            if(G.arcs[i][k]!=INFINITY) 
                return k;
    }
    return -1;
}


//深度优先遍历
void DFS(Graph G,int k)
{
    int i;
    if(k==-1)
    { 
        //第一次执行DFS时,k为-1
        for(i=0;i<G.vexnum;i++)
            if(!visited[i]) 
                DFS(G,i); //对尚未访问的顶点调用DFS
    }
    else
    {
        visited[k]=true;
        cout<<G.vexs[k]; //访问第k个顶点
        for(i=FirstVex(G,k);i>=0;i=NextVex(G,k,i))
            if(!visited[i]) 
                DFS(G,i); //对k的尚未访问的邻接顶点i递归调用DFS
    }
}


//广度优先遍历
void BFS(Graph G){
    int k;
    Queue Q; //辅助队列Q
    Q.InitQueue();
    for(int i=0;i<G.vexnum;i++)
        if(!visited[i])
        { 
            //i尚未访问
            visited[i]=true;
            cout<<G.vexs[i];
            Q.EnQueue(i); //i入列
            while(Q.front!=Q.rear)
            {
                Q.DeQueue(k); //队头元素出列并置为k
                for(int w=FirstVex(G,k);w>=0;w=NextVex(G,k,w))
                    if(!visited[w])
                    { 
                        //w为k的尚未访问的邻接顶点
                        visited[w]=true;
                        cout<<G.vexs[w];
                        Q.EnQueue(w);
                    }
            }
        }
}


//主函数
int main()
{
    int i;
    Graph G;
    CreateUDN(G);
    visited=(bool *)malloc(G.vexnum*sizeof(bool));
    cout<<"深度优先遍历: ";
    for(i=0;i<G.vexnum;i++)
        visited[i]=false;
    DFS(G,-1);
    cout<<"\n广度优先遍历: ";
    for(i=0;i<G.vexnum;i++)
        visited[i]=false;
    BFS(G);
    system("pause");
    return 0;
}