笔试-深搜、广搜算法突破
提到深搜、广搜,大家一般就会说深搜用栈或递归,广搜用队列。
但是其实我认为应该先考虑一下,是搜的对象是什么,是树、还是图
当然无论是图的深搜、还是树的深搜,其基本理念都是一致的
- 深搜:尽可能沿着每个分支深入到节点的尽头,然后回溯以探索未访问的节点。
- 广搜:首先访问离起始节点最近的节点,然后逐层向外扩展。
树的搜索
树的深搜
大家都知道树的遍历前、中、后序遍历,可以用栈或者递归,其实这就是树的深搜了
class Solution {
public:
void traversal(TreeNode* cur, vector<int>& vec) {
if (cur == NULL) return;
vec.push_back(cur->val); // 中
traversal(cur->left, vec); // 左
traversal(cur->right, vec); // 右
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> result;
traversal(root, result);
return result;
}
};
树的广搜
其实就是树的层序遍历了,使用队列,一层一层的进行遍历
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> que;
if (root != NULL) que.push(root);
vector<vector<int>> result;
while (!que.empty()) {
int size = que.size();
vector<int> vec;
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
vec.push_back(node->val);
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
result.push_back(vec);
}
return result;
}
};
图的搜索
图的深搜
参考代码随想录
可一个方向去搜,不到黄河不回头,直到遇到绝境了,搜不下去了,再换方向(换方向的过程就涉及到了回溯)。
实现方式:
- 递归方式:利用递归函数实现DFS。
- 迭代方式:利用栈实现DFS。
深搜三部曲:
- 确认递归函数,参数
vector<vector<int>> result; // 保存符合条件的所有路径
vector<int> path; // 起点到终点的路径
void dfs (图,目前搜索的节点)
- 确认终止条件
if (终止条件) {
存放结果;
return;
}
- 处理目前搜索节点出发的路径
for (选择:本节点所连接的其他节点) {
处理节点;
dfs(图,选择的节点); // 递归
回溯,撤销处理结果
}
最终模版
void dfs(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择:本节点所连接的其他节点) {
处理节点;
dfs(图,选择的节点); // 递归
回溯,撤销处理结果
}
}
图的广搜
参考代码随想录
先把本节点所连接的所有节点遍历一遍,走到下一个节点的时候,再把连接节点的所有节点遍历一遍,搜索方向更像是广度,四面八方的搜索过程。
实现步骤:
- 容器:需要一个容器,能保存我们要遍历过的元素就可以,那么用队列,还是用栈,甚至用数组,都是可以的。用队列的话,就是保证每一圈都是一个方向去转,例如统一顺时针或者逆时针;如果用栈的话,就是第一圈顺时针遍历,第二圈逆时针遍历,第三圈有顺时针遍历。
- 方向数组:创建方向元素,来向四面八方扩展
代码与树的层次遍历类似
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 表示四个方向
// grid 是地图,也就是一个二维数组
// visited标记访问过的节点,不要重复访问
// x,y 表示开始搜索节点的下标
void bfs(vector<vector<char>>& grid, vector<vector<bool>>& visited, int x, int y) {
queue<pair<int, int>> que; // 定义队列
que.push({x, y}); // 起始节点加入队列
visited[x][y] = true; // 只要加入队列,立刻标记为访问过的节点
while(!que.empty()) { // 开始遍历队列里的元素
pair<int ,int> cur = que.front(); que.pop(); // 从队列取元素
int curx = cur.first;
int cury = cur.second; // 当前节点坐标
for (int i = 0; i < 4; i++) { // 开始想当前节点的四个方向左右上下去遍历
int nextx = curx + dir[i][0];
int nexty = cury + dir[i][1]; // 获取周边四个方向的坐标
if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue; // 坐标越界了,直接跳过
if (!visited[nextx][nexty]) { // 如果节点没被访问过
que.push({nextx, nexty}); // 队列添加该节点为下一轮要遍历的节点
visited[nextx][nexty] = true; // 只要加入队列立刻标记,避免重复访问
}
}
}
}
比较
- DFS:
优点:比较容易实现,适用于寻找路径或连通分量。
缺点:可能会消耗大量栈空间(递归实现),对某些图(如无穷路径)可能导致栈溢出。 - BFS:
优点:保证找到最短路径(无权图),空间复杂度相对稳定。
缺点:可能会消耗大量内存(需要存储队列中的所有节点)。
这两种算法可以根据具体问题的需求选择使用,而它们在不同情况下有各自的优劣。