图搜索算法（深度优先、广度优先）
一、图论
教学的一个分支，它以图为研究对象。
图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个事物间具有这种关系。
图的结构
非线性结构
有n个直接前驱，n个直接后继
图的组成
由两部分组成，一部分叫点的集合，另一部分叫边的集合
图的分类
1）无向图：图中的边是节点的无序对（即两节点不分谁是起始点，谁是终止点），则称此图为无向图。通常用圆括号表示无向边。
2）有向图：图中的边是节点的有序树，则称此图为有向图。有向边又称为弧，通常用尖括号表示一条有向边。
弧头：弧的终止节点
弧尾：弧的开始节点
3）有向完全图与无向完全图。在图中的任意一个点，和其它所有的点都有边连接。
二、深度优先
深度优先规则
沿着一个固定的方向进行行走，到了岔路口才又一次选择方向，如果碰到了死胡同退回上一个岔路口重新选择方向，走过的路就不会再重新走，一次走一个岔路口
注意：因为方向设定不一样，可能最终找到路径是不一样的
代码示例
#include
#include
using namespace std;
//1. 地图的大小
#define MAP_ROW 10
#define MAP_COL 10
//2. 坐标点
struct Point
{
int row,col;
};
//3. 方向
enum PathDir
{
p_up,p_left,p_down,p_right
};
//4. 辅助数组中的路径点
struct PathData
{
int val;//原始数组路经点信息
bool isFind;//路径点是否已经访问过
PathDir dir;//路径点行进方向
};
//---探路判断---
bool isMove(PathData arr[][MAP_COL],int row,int col)
{
//1. 越界
if (row<0 || row > MAP_ROW || col<0 || col>MAP_COL)
return false;
//2. 没有障碍物，且没有被访问
if (arr[row][col].val==0 && arr[row][col].isFind==false)
return true;
//3. 可能已访问，可能是障碍
return false;
}
int main()
{
//5. 准备二维数组
int arr[MAP_ROW][MAP_COL] = {
{1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 },
{1 ,0 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,1 },
{1 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,1 },
{1 ,1 ,1 ,0 ,1 ,0 ,1 ,1 ,1 ,1 },
{1 ,0 ,1 ,0 ,1 ,0 ,0 ,0 ,1 ,1 },
{1 ,0 ,0 ,0 ,1 ,1 ,0 ,1 ,1 ,1 },
{1 ,1 ,0 ,1 ,1 ,1 ,0 ,0 ,1 ,1 },
{1 ,1 ,0 ,1 ,1 ,1 ,1 ,0 ,0 ,1 },
{1 ,0 ,0 ,0 ,1 ,1 ,1 ,1 ,0 ,1 },
{1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 }
};
//6. 准备辅助数组表示地图
PathData pathArr[MAP_ROW][MAP_COL];
//7. 初始化辅助数组
for (int i = 0; i < MAP_ROW; i++)
{
for (int j = 0; j < MAP_COL; j++)
{
pathArr[i][j].val = arr[i][j];//路径点信息
pathArr[i][j].isFind = false;//每个位置都还没被访问
pathArr[i][j].dir = p_up;//自定义方向先向上
}
}
//8. 准备起点和终点
Point begPoint = {1,1};
Point endPoint = {8,8};
//9. 准备容器保存路径点
stack ms;
ms.push(begPoint);
//10. 辅助坐标点，用来查询后续节点
Point currPoint = begPoint;
//11. 开始寻路
while (true)
{
switch (pathArr[currPoint.row][currPoint.col].dir)
{
case p_up:
//第一步：先改变方向（下一个方向）
pathArr[currPoint.row][currPoint.col].dir = p_left;
//第二步：探索下一个路径点
if (isMove(pathArr,currPoint.row-1,currPoint.col))
{
//第三步：改变当前路径点已访问
pathArr[currPoint.row][currPoint.col].isFind = true;
//第四步：下一路径点入栈
Point tempPoint = {currPoint.row-1,currPoint.col};
ms.push(tempPoint);
//第五步：下一路径点改为当前路径点
currPoint = tempPoint;
}
break;
case p_left:
pathArr[currPoint.row][currPoint.col].dir = p_down;
if (isMove(pathArr,currPoint.row,currPoint.col-1))
{
pathArr[currPoint.row][currPoint.col].isFind = true;
Point tempPoint = {currPoint.row,currPoint.col-1};
ms.push(tempPoint);
currPoint = tempPoint;
}
break;
case p_down:
pathArr[currPoint.row][currPoint.col].dir = p_right;
if (isMove(pathArr,currPoint.row+1,currPoint.col))
{
pathArr[currPoint.row][currPoint.col].isFind = true;
Point tempPoint = {currPoint.row+1,currPoint.col};
ms.push(tempPoint);
currPoint = tempPoint;
}
break;
case p_right:
//这是最后一个方向
if (isMove(pathArr,currPoint.row,currPoint.col+1))
{
pathArr[currPoint.row][currPoint.col].isFind = true;
Point tempPoint = {currPoint.row,currPoint.col+1};
ms.push(tempPoint);
currPoint = tempPoint;
}
//下一路径点不能走（死胡同）
else
{
//第一步：改变当前路径点已访问
Point tempPoint = ms.top();
pathArr[tempPoint.row][tempPoint.col].isFind = true;
//第二步：退栈，找到上一个路径点
ms.pop();
//第三步：上一路径点改为当前路径点（若栈不为空）
if (!ms.empty())
{
currPoint = ms.top();
}
}
break;
}
//结束条件一：找到路
if (currPoint.row==endPoint.row && currPoint.col==endPoint.col)
{
break;
}
//结束条件二：没有路（容器为空）
if (ms.empty())
{
break;
}
}
//12. 寻路终止，打印路径
while (!ms.empty())
{
//第一步：打印栈顶元素
Point tempPoint = ms.top();
printf("row==%d---col==%d\n",tempPoint.row,tempPoint.col);
//第二步：退栈
ms.pop();
}
return 0;
} 三、广度优先
广度优先规则
1）走直线，不能走斜线
2）理解为树的层次次序
3）如果有路，必然找到最短路径
4）需要遍历所有可通行的节点，如果地图比较大，开销就比较大
搜索过程图示
代码示例
#include
#include
using namespace std;
//1. 地图的大小
#define MAP_ROW 4
#define MAP_COL 6
//2. 坐标点
struct Point
{
int row,col;
};
//3. 方向
enum PathDir
{
p_up,p_left,p_down,p_right
};
//4. 辅助数组中的路径点
struct PathData
{
int val;
bool isFind;
PathDir dir;
};
//5.树形结构的节点
struct PathNode
{
Point pos;
PathNode *parentNode;
vector childNode;
};
//---探路判断---
bool isFind(PathData arr[][MAP_COL],Point pos)
{
//1. 越界
if (pos.row<0 || pos.row>=MAP_ROW || pos.col<0 || pos.col>=MAP_COL)
return false;
//2. 没有障碍物，且没有被访问
if (arr[pos.row][pos.col].val==0 && arr[pos.row][pos.col].isFind==false)
return true;
//3. 可能已访问，可能是障碍
return false;
}
//---清空树形节点---
void clearNode(PathNode *& root)//注意引用！！！
{
if (root)
{
//第一步：循环子次序
for (int i = 0; i < (int)root->childNode.size(); i++)
{
//第二步：递归节点的子节点
clearNode(root->childNode[i]);
}
//第三步：清除节点
delete root;
root = nullptr;
}
}
int main()
{
//6. 准备二维数组
int arr[MAP_ROW][MAP_COL] = {
{0 ,0 ,0 ,0 ,0 ,0 },
{0 ,0 ,0 ,0 ,0 ,0 },
{0 ,0 ,0 ,0 ,0 ,0 },
{0 ,0 ,0 ,0 ,0 ,0 }
};
//7. 准备辅助数组表示地图
PathData pathArr[MAP_ROW][MAP_COL];
//8. 初始化辅助数组
for (int i = 0; i < MAP_ROW; i++)
{
for (int j = 0; j < MAP_COL; j++)
{
pathArr[i][j].val = arr[i][j];//路径点信息
pathArr[i][j].isFind = false;//每个位置都还没被访问
pathArr[i][j].dir = p_up;//自定义方向先向上
}
}
//9. 准备起点和终点
Point begPoint = {1,1};
Point endPoint = {3,5};
//10. 开辟根节点
PathNode *pRoot = new PathNode;
pRoot->pos = begPoint;
pRoot->parentNode = nullptr;
//11. 根节点已访问
pathArr[begPoint.row][begPoint.col].isFind = true;
//12. 准备两个辅助数组，保存树形结构中父子次序的节点
vector currList;//当前搜索的父次序
vector tempList;//当前搜索的父次序的子次序
//13. 将根节点插入当前搜索父次序
currList.push_back(pRoot);
//14. 开始寻路
while (true)
{
//第一步：循环父次序
for (int i = 0; i < (int)currList.size(); i++)
{
//第二步：循环方向
for (int j = 0; j < 4; j++)
{
Point tempPoint = currList[i]->pos;
switch (j)
{
case p_up:
tempPoint.row--;
break;
case p_left:
tempPoint.col--;
break;
case p_down:
tempPoint.row++;
break;
case p_right:
tempPoint.col++;
break;
}
//第三步：探索下一个路径点
if (isFind(pathArr,tempPoint))
{
//第四步：改变当前路径点已访问
pathArr[tempPoint.row][tempPoint.col].isFind = true;
//第五步：开辟树形节点
PathNode *tempNode = new PathNode;
tempNode->pos = tempPoint;
//第六步：关联父子关系
tempNode->parentNode = currList[i];
currList[i]->childNode.push_back(tempNode);
//第七步：将下一路径点插入子次序
tempList.push_back(tempNode);
//---寻路终止，打印路径---
if (tempPoint.row==endPoint.row &&
tempPoint.col==endPoint.col)
{
PathNode *pNode = tempNode;
while (pNode)
{
printf("row==%d---col==%d\n",
pNode->pos.row,pNode->pos.col);
//父节点遍历打印路径
pNode = pNode->parentNode;
}
goto OVERTAB;//跳出循环
}
}
}
}
//结束条件：没有路
if (tempList.empty())
{
break;
}
//把子次序赋值给父次序
currList = tempList;
tempList.clear();//记得清空
}
OVERTAB:
//清空根节点（使用goto跳转语句，清空堆内存）
clearNode(pRoot);
return 0;
}