<广度优先搜素 BFS>和<深度优先搜索 DFS>

<Breadth First Search>

广度优先搜素(宽度优先搜索)

每出队列一个,都把他连通的节点调入队列

这种算法,最多就是应用在迷宫上面,因为他是一种盲目的探索算法,相当于每走一步,就分析自己的上下左右能不能走.

下面用C/C++写了个迷宫算法,迷宫没设置好,可以研究下.

#include<iostream>
#include <queue>
using namespace std;

int n=10;
int visit[10][10]={0};
int stepArr[4][2] = {{-1,0},{1,0},{0,-1},{0,1}}; //表示上下左右4个方向
int mazeArr[10][10];

struct Node
{
 int x;
 int y;
 int step;
 Node(int x1,int y1,int step1):x(x1),y(y1),step(step1){}  //冒号是指将x,y,step的值分别传递给x1,y1,step~
};

int BFS()
{
 Node node(0,0,0);
 queue<Node> q;
 while( !q.empty() ) 
	  q.pop();                           //清空刚创造的队列

 q.push(node);
 while( !q.empty() )
 {
  node=q.front();                          //获取队头;
  q.pop();

  if(node.x==n-1 && node.y==n-1)
  {
   return node.step;
  }

  visit [node.x][node.y]=1;
  for(int i=0;i<4;i++)
  {
   int x=node.x+stepArr[i][0];
   int y=node.y+stepArr[i][1];
   if(x>=0 && y>=0 && x<n && y<n && visit[x][y]==0 && mazeArr[x][y]==0)
   {
    visit[x][y]=1;
    Node next(x,y,node.step+1);
    q.push(next);
   }
  }

 }
return-1;
}

int main()
{
    int step=0;
    for(int i=0;i<10;i++)
	{
	 for(int j=0;j<10;j++)
		 {
                     mazeArr[i][j]=rand()%2;
		     cout<<mazeArr[i][j]<<"  ";
		 }
		 cout<<endl;
	}
	cout<<endl;
    step=BFS();
	printf("%d\n",step);
	return 0;
}

<Depth First Search>

深度优先搜素

树的话有点像先序遍历,图的话则是往一个方向不断延伸.

他也是一种穷举法.虽然成功的路劲不一定最短,但是记住的路线可以很少.

区别

BFS:每一步计算每个方向的路径可能性.

DFS:把每条路都算出来,不行的就行一条路.