深度优先搜索及广度优先搜索

一.深度优先搜索。

1.主要思想：首先以一个未被访问过的顶点作为起始顶点，沿当前顶点走到未被访问顶点，当没有未被访问顶点时，返回上一个顶点，继续访问别的顶点，直到所有的顶点都被访问过。

2：主要通过循环及递归来实现。

A：输出数n的全排列

#include<stdio.h> //以123->132为例 
int a[10],book[10],n;//此处设n为3 
void dfs(int step)
{
	int i;
	if(step==n+1)//当step=n+1时，表示以完成一种排列，返回到函数实参的下一条语句
	{
		for(i=1;i<=n;i++)
		{
			printf("%d",a[i]);//第一次排列完成123 
		}
		printf("\t");
		return;//返回到book[3]=0; 
	}
	for(i=1;i<=n;i++)
	{
		if(book[i]==0)
		{
			a[step]=i;
			book[i]=1;
			dfs(step+1); 
			book[i]=0;//book[3]=0;注意此处step已经变为3 
		}
	}
	return; //返回到 step=2;则book[2]=0;再完成未完成的循环可得a[step=2]=3; 
}
int main(void)
{
	scanf("%d",&n);
	dfs(1);
	return 0;
}

B：寻找最短路径

输入两个坐标A,B，找出A坐标到B坐标的最短路径

#include<stdio.h>
int n,m,p,q,min=99999999;
int a[51][51],book[51][51];//book用来标记走过的路程 
void dfs(int x,int y,int step)
{
	int next[4][2]
	{
		{0,1},
		{1,0},
		{0,-1},
		{-1,0},
	};
	int tx,ty,i;
	if(x==p&&y==q)
	{
		if(min>step)
			min=step;
		return;
	}
	for(i=0;i<=3;i++)
	{
		tx=x+next[i][0];
		ty=y+next[i][1];
		if(tx<1||tx>n||ty<1||ty>m)//判断是否越界
		{
			continue; //当出界时会将循环走完返回原位置，然后返回上一个调用继续往下走。 
		}
		if(a[tx][ty]==0&&book[tx][ty]==0)
		{
			book[tx][ty]=1;
			dfs(tx,ty,step+1);
			book[tx][ty]=0;
		}
	}
	return;
}
int main(void)
{
	int i,j,startx,starty;
	scanf("%d%d",&n,&m);
	for(i=1;i<=n;i++)
		for(j=1;j<=m;j++)
		{
			scanf("%d",&a[i][j]);
		}
		scanf("%d%d%d%d",&startx,&starty,&p,&q);
		book[startx][starty]=1;
		dfs(startx,starty,0);
		printf("%d",min);}

二.广度优先搜索

1.主要思想：首先以一个未被访问过的顶点作为起始顶点，访问其所有相邻的顶点，然后对每个相邻的顶点，再访问它们相邻的未被访问过的顶点，直到所有的顶点都被访问过。

2：主要通过队列对顶点进行入队，当顶点的所有相邻顶点都被访问过时，该顶点出队。

A:采用深度优先搜索解决最短路径问题

#include<stdio.h>
struct node
{
	int x;//横坐标 
	int y;//纵坐标 
	int s;//步数 
};
int main(void)
{
	struct node que[2501];
	int a[51][51]={0},book[51][51]={0};
	int next[4][2]
	{
		{0,1},
		{1,0},
		{0,-1},
		{-1,0},
	};
	int head,tail;
	int i,j,k,n,m,startx,starty,p,q,tx,ty,flag;
	scanf("%d%d",&n,&m);
	for(i=1;i<=n;i++)
		for(j=1;j<=m;j++)
		scanf("%d",&a[i][j]);
	scanf("%d%d%d%d",&startx,&starty,&p,&q);
	head=1;
	tail=1;
	que[tail].x=startx;
	que[tail].y=starty;
	que[tail].s=0;
	tail++;
	book[startx][starty]=1;
	flag=0;//用来标记是否到达目的点
	while(head<tail)
	{
		for(k=0;k<=3;k++)
		{
			tx=que[head].x+next[k][0];
			ty=que[head].y+next[k][1];
			if(tx<1||tx>n||ty<1||ty>m)
			{
				continue;
			}
			if(a[tx][ty]==0&&book[tx][ty]==0)
			{
				book[tx][ty]=1;
				que[tail].x=tx;
				que[tail].y=ty;
				que[tail].s=que[head].s+1;
				tail++;
			}
			if(tx==p&&ty==q)
			{
				flag=1;
				break;
			}
		} 
		if(flag==1)
			break;
		head++;//当所有点都走完后队头再前进 
	} 
	printf("%d",que[tail-1].s); 

} 

在学习的过程中发现其实无论深度还是广度时间复杂度都是相当的高，（每一个节点都得遍历一遍又能低到哪去？），虽然数据结构才刚刚入门，但是真的可以感觉到算法的魅力