图优先遍历

DFS深度优先搜索

DFS类似于树的先序遍历，尽可能先对深度进行搜索。将图从顶点开始进行深度优先搜索所走过的路径便是深度优先搜索树

深度搜索遍历邻接矩阵表示图

//邻接矩阵表示图
typedef struct
{
    char vexs[MAXSIZE];
    int arcs[MAXSIZE][MAXSIZE];
    int vexnum,arcnum;
}AMGraph;
//深度搜索遍历邻接矩阵表示图
void DFSAM(AMGraph G,int v)
{
    visited[v]=true;
    printf("%d",v);
    for(int w=0;w<G.vexnum;w++)
    {
        if(G.arcs[v][w]&&!visited[w])
        {
            DFSAM(G,w);
        }
    }
    return ;
}

时间复杂度O(n^2)

深度搜索遍历邻接表表示图

//邻接表表示图
typedef struct ArcNode
{
    int adj;
    struct ArcNode*next;
}ArcNode;
typedef struct VNode
{
    int data;
    ArcNode *First;
}VNode,AdjList[MAXSIZE];
typedef struct
{
    AdjList ver;
    int vexnum,arcnum;
}ALGraph;
//深度搜索遍历邻接表表示图
void DFSAL(ALGraph G,int v)
{
    visited[v]=1;
    printf("%d",G.ver[v].data);
    for(ArcNode *p=G.ver[v].First;p;p=p->next)
    {
        if(!visited[p->adj])
        {
            DFSAL(G,p->adj);
        }
    }
    return ;
}

时间复杂度O(n+e)

BFS广度优先搜索

BFS类似于树的层次遍历，尽可能先对广度进行搜索。将图从顶点开始进行广度优先搜索所走过的路径便是广度优先搜索树

利用循环队列实现BFS

typedef struct
{
    int *base;
    int front;
    int rear;
} SQueue;
SQueue Q;
int InitQuene()
{
    Q.base=(int *)malloc(MAXSIZE * sizeof(int));
    if(!Q.base)
    {
        return 0;
    }
    else
    {
        Q.front=0;
        Q.rear=0;
        return 1;
    }
}
int EnQuene(int e)
{
    if((Q.rear+1)%MAXSIZE==Q.front)
    {
        return 0;
    }
    else
    {
        Q.base[Q.rear]=e;
        Q.rear=(Q.rear+1)%MAXSIZE;
        return 1;
    }
}
int DeQuene()
{
    if(Q.rear==Q.front)
    {
        return 0;
    }
    else
    {
        int e=Q.base[Q.front];
        Q.front=(Q.front+1)%MAXSIZE;
        return 1;
    }
}
int QueueEmpty()
{
    return Q.front==Q.rear;
}
int GetTop()
{
    if(Q.front==Q.rear)
    {
        return 0;
    }
    else
    {
        return Q.base[Q.front];
    }
}

广度搜索遍历邻接矩阵表示图

//邻接矩阵表示图
typedef struct
{
    char vexs[MAXSIZE];
    int arcs[MAXSIZE][MAXSIZE];
    int vexnum,arcnum;
}AMGraph;
//广度搜索遍历邻接矩阵表示图
void BFSAM(AMGraph G,int v,int n)
{
    int i,j;
    InitQueue();
    printf("%d",v);
    visited[v]=true;
    EnQueue(v);
    while(!QueueEmpty())
    {
        i=GetTop();
        for(j=0;j<G.vexnum;j++)
        {
            if(G.arcs[i][j]==1&&visited[j]!=true)
            {
                printf("%d",j);
                visited[j]=true;
                EnQueue(j);
            }
        }
        DeQueue();
    }
}

时间复杂度O(n^2)

广度搜索遍历邻接表表示图

//邻接表表示图
typedef struct ArcNode
{
    int adj;
    struct ArcNode*next;
}ArcNode;
typedef struct VNode
{
    int data;
    ArcNode *First;
}VNode,AdjList[MAXSIZE];
typedef struct
{
    AdjList ver;
    int vexnum,arcnum;
}ALGraph;
//广度搜索遍历邻接表表示图
void BFSAL(ALGraph G,int v)
{
    int i,j;
    ArcNode *p;
    InitQueue();
    printf("%d",v);
    EnQueue(v);
    visited[v]=true;
    while(!QueueEmpty)
    {
        i=GetTop();
        p=G.ver[i].First;
        while(p!=NULL)
        {
            j=p->adj;
            if(!visited[j])
            {
                printf("%d",j);
                visited[j]=true;
                EnQueue(j);
            }
            p=p->next;
        }
        DeQueue();
    }
    return ;
}

时间复杂度O(n+e)

DFS和BFS完整代码：

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 100
//邻接表表示图
typedef struct ArcNode
{
    int adj;
    struct ArcNode*next;
}ArcNode;
typedef struct VNode
{
    char data;
    ArcNode *First;
}VNode,AdjList[MAXSIZE];
typedef struct
{
    AdjList ver;
    int vexnum,arcnum;
}ALGraph;
//利用循环队列实现广度优先搜索遍历
typedef struct
{
    int *base;
    int front;
    int rear;
} SQueue;
SQueue Q;
int InitQueue()
{
    Q.base=(int *)malloc(MAXSIZE * sizeof(int));
    if(!Q.base)
    {
        return 0;
    }
    else
    {
        Q.front=0;
        Q.rear=0;
        return 1;
    }
}
int EnQueue(int e)
{
    if((Q.rear+1)%MAXSIZE==Q.front)
    {
        return 0;
    }
    else
    {
        Q.base[Q.rear]=e;
        Q.rear=(Q.rear+1)%MAXSIZE;
        return 1;
    }
}
int DeQueue()
{
    if(Q.rear==Q.front)
    {
        return 0;
    }
    else
    {
        int e=Q.base[Q.front];
        Q.front=(Q.front+1)%MAXSIZE;
        return 1;
    }
}
int QueueEmpty()
{
    return Q.front==Q.rear;
}
int GetTop()
{
    if(Q.front==Q.rear)
    {
        return 0;
    }
    else
    {
        return Q.base[Q.front];
    }
}
//广度搜索遍历邻接表表示图
int visited1[MAXSIZE]={0};
void BFSAL(ALGraph G,int v)
{
    int i,j;
    ArcNode *p;
    InitQueue();
    printf("%d\n",v);
    EnQueue(v);
    visited1[v]=1;
    while(!QueueEmpty())
    {
        i=GetTop();
        p=G.ver[i].First;
        while(p!=NULL)
        {
            j=p->adj;
            if(!visited1[j])
            {
                printf("%d\n",j);
                visited1[j]=1;
                EnQueue(j);
            }
            p=p->next;
        }
        DeQueue();
    }
    return ;
}
//深度搜索遍历邻接表表示图
int visited2[MAXSIZE]={0};
void DFSAL(ALGraph G,int v)
{
    visited2[v]=1;
    printf("%d\n",G.ver[v].data);
    for(ArcNode *p=G.ver[v].First;p;p=p->next)
    {
        if(!visited2[p->adj])
        {
            DFSAL(G,p->adj);
        }
    }
    return ;
}
int main()
{
    ALGraph G;
    int n,m;
    printf("Please input the number of the Vex:");
    scanf("%d",&n);
    printf("Please input the number of the Arc:");
    scanf("%d",&m);
    for(int i=0;i<n;i++)
    {
        printf("Please input the %dth Vex:",i);
        scanf("%d",&G.ver[i].data);
        G.ver[i].First=NULL;
    }
    int in,out;
    for(int i=0;i<m;i++)
    {
        printf("Please input the in:");
        scanf("%d",&in);
        printf("Please input the out:");
        scanf("%d",&out);
        ArcNode *p,*q;
        p=(ArcNode*)malloc(sizeof(ArcNode));
        p->adj=out;
        if(!G.ver[in].First)
        {
            G.ver[in].First=p;
            p->next=NULL;
        }
        else
        {
            p->next=G.ver[in].First;
            G.ver[in].First=p;
        }
        q=(ArcNode*)malloc(sizeof(ArcNode));
        q->adj=in;
        if(!G.ver[out].First)
        {
            G.ver[out].First=q;
            q->next=NULL;
        }
        else
        {
            q->next=G.ver[out].First;
            G.ver[out].First=q;
        }
    }
    printf("The DFS is:\n");
    DFSAL(G,0);
    printf("The BFS is:\n");
    BFSAL(G,0);
    return 0;
}

DFS和BFS各有优劣，应当根据实际情况选择最适合的搜索算法