图之深度优先搜索（DFS）

  我们先看一下深度优先搜索的定义，然后，通过举例，自己思考，一定可以自己写出来，下边代码供参考。

定义：深度优先搜索 从一条路径的起始顶点开始追溯到达最后一个顶点，然后回溯继续追溯下一条路径，直到最后一个顶点，如此N次，直到没有路径为止。

      例子：

A(C,F,D)->C(B,D)->B(0),每次遍历都要给他们做标记，以确定他们已被遍历到，到这一步，可以看到B已经没有邻接点了，所以，退回到C，

C(D)->D(0),D退回到A，

 A(F)->F(G)->G(E)->E(0),此时遍历完成。

看代码：

#include<stdio.h>
#include<stdlib.h>
#include <malloc.h>
#include <string.h>
#define MAX 10
#define nLENGTH(a)  (sizeof(a)/sizeof(a[0]))
#define eLENGTH(a) ( sizeof(a) / sizeof(char) )/ ( sizeof(a[0]) / sizeof(char) )
typedef struct _graph
{
    char vexs[MAX];       // 顶点集合
    int vexnum;           // 顶点数
    int edgnum;           // 边数
    int matrix[MAX][MAX]; // 邻接矩阵
}Graph, *PGraph; 
//指向节点的位置
int point_node(PGraph g,char c)
{
	for(int i=0;i<g->vexnum;i++)
	{
		if(g->vexs[i]==c)
		{
			return i;
		}
	}
	return -1;
}
PGraph create_graph(char b[][2],char a[],int n,int e)
{
	char c1,c2; //边的2个顶点
	PGraph g; //矩阵
	g=(PGraph)malloc(sizeof(Graph));
	//memset()第一个参数 是地址，第二个参数是开辟空间的初始值，第三个参数是开辟空间的大小
	memset(g, 0, sizeof(Graph));
	printf("顶点个数:\n");//顶点数
	g->vexnum=n;
	printf("%d\n",g->vexnum);
	printf("边个数:\n");//边数
	g->edgnum=e;
	printf("%d\n",g->edgnum);
	//初始化顶点
	for(int j=0;j<g->vexnum;j++)
	{
		g->vexs[j]=a[j];
	}
	for(int i=0;i<g->edgnum;i++)
	{
		int p1,p2;
		c1=b[i][0];
		c2=b[i][1];
		p1=point_node(g, c1);
		p2=point_node(g, c2);
		if (p1==-1 || p2==-1)
        {
            printf("input error: invalid edge!\n");
            free(g);
            continue;
        }
		g->matrix[p1][p2]=1;
		g->matrix[p2][p1]=1;
		
	}
	return g;
}
//返回与v相邻的第一个顶点
int first_node(PGraph g,int v)
{
	int i;
	for(i=0;i<g->vexnum;i++)
	{
		if(g->matrix[v][i]!=0)
			return i;
	}
	return -1;
}
//返回与v相邻的下一个顶点
int next_node(PGraph g,int v,int w)
{
	int i;
	for(i=w+1;i<g->vexnum;i++)
	{
		if(g->matrix[v][i]!=0)
			return i;
	}
	return -1;

}
//深度优先搜索的递归实现
void DFS(PGraph g,int i,int a[])
{
	a[i]=1;
	printf("%c\t", g->vexs[i]);
	for(int w=first_node( g,i);w>=0;w=next_node(g,i,w)) //当相邻顶点全都被访问过，结束循环w=-1;
	{
		if(!a[w])
		{
			DFS(g,w,a);
		}
	}

}
//深度优先搜索遍历图
void DFSTraverse(PGraph g) 
{
	int i;
	int visit[MAX]={0}; //存放节点，若访问过，标记1，没有访问过，标记0；
	for(i=0;i<g->vexnum;i++)
	{
		if(!visit[i])
		{
			 DFS(g, i, visit);
		}
	}

}
//测试
int main()
{
	int i,j;
	PGraph gp;
	//测试用例

	char a[]={'A', 'B', 'C', 'D', 'E', 'F', 'G'};
	char b[][2]={
        {'A', 'C'}, 
        {'A', 'D'}, 
        {'A', 'F'}, 
        {'B', 'C'}, 
        {'C', 'D'}, 
        {'E', 'G'}, 
        {'F', 'G'}}; 

	//测试用例

	int n=nLENGTH(a);
	int e=eLENGTH(b);
	gp=create_graph(b,a,n,e);

	//打印矩阵
	for (i = 0; i < gp->vexnum; i++)
    {
        for (j = 0; j < gp->vexnum; j++)
            printf("%d ", gp->matrix[i][j]);
        printf("\n");
    }
	//深度优先搜索
	printf("深度优先搜索:\n");
	DFSTraverse(gp);
	return 0;
}