BFS(广度优先搜索)这里用来两种方法存储路径,1.同map大小的数组来存储路径2.通过生成反向树状结构存储路径

1.数组存储路径，代码如下：

的#include <iostream的>

#include <queue>
#include <cstdlib>
using namespace std;
结构点//点的结构体
{
point（int x，int y）：x（x），y​​（y）{} //带参构造
点（）{}; //无参构造
point＆operator =（point＆a）//重载=
{
x = ax;
y = ay;
返回*这个;
}
点运算符+（point＆a）//重载+
{
点t
tx = x + ax;
ty = y + ay;
返回t
}
bool operator ==（point＆a）//重载==
{
return（x == ax）&&（y == ay）;
}
int x;
int y
};
int main（）
{
无符号索引= 0;
int arr [] [10] = {1,1,0,1,1,1,1,1,1,1，
                   1，0，0，0，0，0，0，0，1，1，
                      1，1，1，0，0，0，0，0，0，0，
                   1，1，0，0，0，1，1，0，0，0，
                   1，1，1，1，0，1，1，1，1，0，
                   1，1，1，1，0，1，0，0，0，0，
                   1，1，1，1，0，1，0，1，1，1，
                   1，1，1，1，0，1，0，1，1，1，
                   1，1，1，1，0，0，0，1，1，1，
                   1，1，1，1，1，1，1，1，1};
bool isfind [10] [10];
memset（isfind，false，sizeof（bool）* 100）;
点开始（0，2）;
点终点（8，4）;
点树[10] [10];
memset（tree，0，sizeof（point）* 100）;
点det [4] = {{0,1}，{1,0}，{0，-1}，{-1,0}};
我的
点电流;
if（！（Begin == End））
{
My.push（开始）;
isfind [Begin.x] [Begin.y] = true;
而（真）
{
if（！My.empty（））
{
Current = My.front（）;
My.pop（）;
}
其他
{
cout <<“查找失败”<< endl;
打破;
}
for（unsigned i = 0; i <4; ++ i）
{
点a =当前+ det [i];
if（End ==（Current + det [i]）&&（Current + det [i]）。x> = 0 &&（Current + det [i]）y> = 0 &&！arr [（Current + det [ i]）x] [（Current + det [i]）。y]）
{
tree [（Current + det [i]）。x] [（Current + det [i]）。y] .x = Current.x;
tree [（Current + det [i]）。x] [（Current + det [i]）。y] .y = Current.y;
电流=电流+ det [i];
打破;
}
其他if（！isfind [（Current + det [i]）。x] [（Current + det [i]）。y] &&！arr [（Current + det [i]）。x] [（Current + det [ I]）。Y]）
{
if（（Current + det [i]）。x> = 0 &&（Current + det [i]）。y> = 0）
{
tree [（Current + det [i]）。x] [（Current + det [i]）。y] .x = Current.x;
tree [（Current + det [i]）。x] [（Current + det [i]）。y] .y = Current.y;
}
My.push（（当前+ det [i]））;
isfind [（Current + det [i]）。x] [（Current + det [i]）。y] = true;
}
}
if（Current == End）
{
cout <<“查找成功”<< endl;
int x，y;
x = End.x;
y =结束
而（真）
{
cout << x <<“\ t”<< y << endl;
if（x == Begin.x && y == Begin.y）
打破;
int m = tree [x] [y] .x;
int n = tree [x] [y] .y;
x = m;
y = n;
}
打破;
}
}
}
的getchar（）;
返回0;

}

2.树状结构存储路径代码如下：

#include <iostream>
#include <queue>
#include <cstdlib>
#include <vector>
using namespace std;
结构点//点的结构体
{
point（int x，int y）：x（x），y​​（y）{} //带参构造
点（）{}; //无参构造
point＆operator =（point＆a）//重载=
{
x = ax;
y = ay;
返回*这个;
}
点运算符+（point＆a）//重载+
{
点t
tx = x + ax;
ty = y + ay;
返回t
}
bool operator ==（point＆a）//重载==
{
return（x == ax）&&（y == ay）;
}
int x;
int y
点* pnext;
};
struct pnode //用来存储路径，通过它生成反向树状路径结构
{
点节点;
pnode * parentnode;
};
int main（）
{
无符号索引= 0;
int arr [] [10] = {{1，1，0，0，0，0，0，0，0，0}
                      {1，1，0，0，1，1，1，1，1，0}，
                      {1,1,1,0,0,0,0,1,1,0}，
                      {1,1,0,0,0,0,0,1,1,0}，
                      {1,1,0,0,1,1,0,0,1,0}，
                      {1,1,0,1,0,0,0,1,1,0}，
                      {1，1，0，1，0，1，1，1，1，0}，
                      {1,1,1,1,0,0,0,1,1,0}，
                      {1，1，0，1，0，1，1，1，1，0}，
                      {1，1，0，1，0，0，0，0，0，0}};
bool isfind [10] [10]; //用来不走回头路
memset（isfind，false，sizeof（bool）* 100）; //初始化为false
点开始（9,9）;
点结束（0,2）;
点det [4] = {{0,1}，{1，0}，{0，-1}，{-1，0}}; //四个方向
队列<pnode *>我的; //关键用来层次遍历，也可以用两个向量来实现类似的思想
pnode * Current; //设置当前节点
pnode * PNEW; //生成新的节点
pnew = new pnode
pnew-> node = Begin;
pnew-> parentnode = NULL;
向量<pnode *> ptemp; //用来保存所有节点指针，方便后期删除内存泄漏
ptemp.push_back（PNEW）; //压入起点
if（！（Begin == End））//如果起点终点系统不进入
{
My.push（PNEW）;
isfind [Begin.x] [Begin.y] = true;
而（真）
{
if（！My.empty（））
{
Current = My.front（）;
My.pop（）;
}
其他
{
cout <<“查找失败”<< endl;
打破;
}
for（unsigned i = 0; i <4; ++ i）
{
if（End ==（Current - > node + det [i]）&&（Current-> node + det [i]）x> = 0 &&（Current-> node + det [i]）y> = 0 && ！arr [（Current-> node + det [i]）。x] [（Current-> node + det [i]）。y]）
{
pnew = new pnode
pnew-> node =（Current-> node + det [i]）;
pnew-> parentnode = Current;
Current = pnew;
ptemp.push_back（PNEW）;
打破;
}
其他if（！isfind [（Current-> node + det [i]）。x] [（Current-> node + det [i]）y] &&！arr [（Current-> node + det [i]） .x] [（Current-> node + det [i]）。y] &&（（Current-> node + det [i]）x> = 0 &&（Current-> node + det [i] > = 0））
{
pnew = new pnode
pnew-> node =（Current-> node + det [i]）;
pnew-> parentnode = Current;
ptemp.push_back（PNEW）;
My.push（PNEW）;
isfind [（Current-> node + det [i]）。x] [（Current-> node + det [i]）y] = true;
}
}
if（Current-> node == End）
{
cout <<“查找成功”<< endl;
int i = 0;
而（当前）
{
cout << Current-> node.x <<“\ t”<< Current-> node.y << endl;
Current = Current-> parentnode;
我++;
}
cout <<“数量为：”<< i << endl;
打破;
}
}
}
for（unsigned i = 0; i <ptemp.size（）; ++ i）//删除所有节点
删除ptemp [i];
的getchar（）;
返回0;
}

3.能返回最短的所有路径的代码如下:

bool playGame::BFS(InitializeMap &arr)//广度寻路
{
unsigned index = 0;
bool ** isfind = new bool* [size];
for (unsigned i = 0; i < size; ++i)
{
isfind[i] = new bool [size];
}
for (unsigned i = 0; i < size; ++i)
{
for (unsigned j = 0; j < size; ++j)
isfind[i][j] = false;
}
queue<pnode*>  My;//关键用来层次遍历,也可以用两个vector来实现类似的思想
pnode* Current;//设置当前节点
pnode*pnew;//生成新的节点
pnew = new pnode;
pnew->node = Begin;
pnew->parentnode = NULL;
vector<pnode*> ptemp;//用来保存所有节点指针,方便后期删防止内存泄漏
vector<pnode*> Pch;
ptemp.push_back(pnew);//压入起点
int curent = 1;
int temp=0   ;
int j = 0;
if (!(Begin == End))//如果起点终点系统不进入
{
bool T = true;
My.push(pnew);
while (true)
{
for (int m = 0; m < curent; ++m)
{
if (!My.empty())
{
Current = My.front();
My.pop();
}
else
{
for (unsigned i = 0; i < ptemp.size(); ++i)//删除所有节点
delete ptemp[i];
Clear(isfind);
return false;
}
for (unsigned i = 0; i < 4; ++i)
{
  if (End == (Current->node + det[i]))
{
pnew = new pnode;
pnew->node = (Current->node + det[i]);
pnew->parentnode = Current;
ptemp.push_back(pnew);
Pch.push_back(pnew);
if (T)
T = false;
break;
}
else if (((Current->node + det[i]).x < size && (Current->node + det[i]).y < size) && ((Current->node + det[i]).x >= 0 
&& (Current->node + det[i]).y >= 0) && !isfind[(Current->node + det[i]).x][(Current->node + det[i]).y] && !arr[(Current->node + det[i]).x][(Current->node + det[i]).y])
{
pnew = new pnode;
pnew->node = (Current->node + det[i]);
pnew->parentnode = Current;
ptemp.push_back(pnew);
My.push(pnew);
if (T)
      temp++;
}
}
isfind[Current->node .x][Current->node.y] = true;
}
if (!T)
{
point temp;
for (int i = 0; i < Pch.size(); ++i)
{
while (Pch[i])
{
temp.x = Pch[i]->node.x;
temp.y = Pch[i]->node.y;
pointpatch.push_back(temp);
Pch[i] = Pch[i]->parentnode;
}
if (DisposePatch(arr) < 3)
{
Clear(isfind);
Pch.clear();
for (unsigned i = 0; i < ptemp.size(); ++i)//删除所有节点
delete ptemp[i];
return true;
}
}
Pch.clear();
for (unsigned i = 0; i < ptemp.size(); ++i)//删除所有节点
delete ptemp[i];
return false;
}
else
{
curent = temp;
temp = 0;
}
}
}
Clear(isfind);
for (unsigned i = 0; i < ptemp.size(); ++i)//删除所有节点
delete ptemp[i];
return false;
}