leetcode刷题总结之BFS与DFS

前言：
此篇文章是当时刚刷题的时候写的，基本上都是按别人的思路过渡到自己这里的，现在刷了几个月的题，关于BFS与DFS算法题也做了不少，套路什么的也实用过了，今日（2019/11/12）更新与总结一下，供以后复习用。如有不妥之处，欢迎大家批评指出。

---

广度优先搜索（BFS）：主要用于树的层序遍历或图的最短路径寻找，主要使用队列queue来完成。

①树的层序遍历：使用队列保存未被检测的结点，结点按照宽度优先的次序被访问和进出队。比如：你的眼镜掉在地上以后，你趴在地板上找，你总先摸离你最近的一圈，如果没有在摸离你更远的一圈。模板如下：

/*二叉树的层序遍历：广度优先搜索*/
vector<vector<int>> levelOrder(TreeNode* root)
 {
    vector<vector<int>> result; 
    if(nullptr==root)return result;
    queue<TreeNode *> qt;
    qt.push(root);
        
    while(!qt.empty())
    {
        vector<int> temp;
        int qLen=qt.size();//每一层节点个数
        for(int i=0;i<qLen;++i)//当前层的所有节点出队列，节点值存储在临时数组中，下一层的所有节点全部进队列中
        {
            TreeNode* node=qt.front();qt.pop();
            temp.push_back(node->val);
            //单个节点的左右节点进队列
            if(node->left)qt.push(node->left);
            if(node->right)qt.push(node->right);
        }
        result.push_back(temp);//当前层的节点存储在二维数组中
    }
    return result;//返回二维数组
}

②有向无环图的最短路径查找：由于有向无环图的某个节点的next节点可能会与另一个节点的next节点重复，所以我们需要记录已访问过的节点，模板如下：

//根节点与目标节点之间的最短路径长度
int BFS(Node root, Node target) {
    Queue<Node> queue;  // 用来存放节点的队列
    Set<Node> used;     // 用来存放已经使用过的节点
    int step = 0;       // 步长
    
    //1:初始化
    add root to queue;
    add root to used;
    
    //2:开始进行BFS
    while (queue is not empty) {
        step = step + 1;
        
        //队列中已经存放的节点个数
        int size = queue.size();
        for (int i = 0; i < size; ++i) {
            Node cur = the first node in queue;
            return step if cur is target;
            for (Node next : the neighbors of cur) {
                if (next is not in used) {
                    add next to queue;
                    add next to used;
                }
            }
            remove the first node from queue;
        }
    }
    return -1;          // there is no path from root to target
}

---

深度优先搜索（DFS）：一直往深处走，直到找到解或者走不下去为止，主要用于树的遍历（前序遍历，中序遍历，后序遍历）或者图的搜索问题或者回溯算法问题。

①树的遍历：一直向叶子节点遍历，直至遇到叶子节点表示此根节点到这个叶子节点的路径已经访问完，需要访问根节点到下一个叶子节点的路径。（当然遍历顺序主要取决于遍历的方式，比如前序遍历（根左右）、后序遍历（左根右）、后序遍历（左右根））比如：走迷宫问题，当我们需要某个分叉路口时，我们需要选一个路口进行选择，若沿着这个路口我们遇到死胡同，我们需要返回到最近的一个分叉路口，然后选择下一个路口，这点和回溯很像（因为回溯也是运用深度优先优先搜索来找到最优解或者所有可行解的）。
1）二叉树的前序遍历：递归版和用栈stack实现的迭代版
2）二叉树的中序遍历：递归版和用栈stack实现的迭代版
3）二叉树的后序遍历：递归版和用栈stack实现的迭代版
4）N叉树的前序遍历：递归版和用栈stack实现的迭代版
5）N叉树的后序遍历：递归版和用栈stack实现的迭代版

②图的搜索问题：上面我们使用了BFS来解决图的最短路径问题，同时我们也可以使用DFS来实现图的最短路径寻找。在这里我们分别提供递归版模板和用stack的迭代版模板：

递归版模板如下：

boolean DFS(Node cur, Node target, Set<Node> visited) {
    return true if cur is target;
    for (next : each neighbor of cur) {
        if (next is not in visited) {
            add next to visted;
            return true if DFS(next, target, visited) == true;
        }
    }
    return false;
}

迭代版模板如下：

boolean DFS(int root, int target) {
    Set<Node> visited;
    Stack<Node> s;
    add root to s;
    while (s is not empty) {
        Node cur = the top element in s;
        return true if cur is target;
        for (Node next : the neighbors of cur) {
            if (next is not in visited) {
                add next to s;
                add next to visited;
            }
        }
        remove cur from s;
    }
    return false;
}

③回溯法：回溯法使用DFS的策略来寻找所有可行解或者最优解，也就是回溯法的所有解可以构成一个解空间树或者解空间图，所以对于这个解空间树或图，我们就使用DFS策略了，算法模板如下：

//choicelist:表示可以进行选择的列表,相当于树中可选用左节点还是右结点
//track:表示为决策路径,相当于在树中为根节点到某个叶子节点的路径
//result:表示存放根节点到所有叶子节点的所有路径
backtrack(choicelist,track,result)
{
	if(track is ok)result.push(track);
	else{
		for choice in choicelist:
			//choose过程:选择一个choice加入track,相当于在树中选择一个节点加入路径
			backtrack(choices,track,result);//进入下一步决策
			//unchoose过程:从track中撤销上面的选择,相当于在树中移除上一次选择的节点
	}
}

---

应用与风险：

• 1）DFS多用于连通性问题因为其运行思想与人脑的思维很相似，故解决连通性问题更自然。
• 2）BFS多用于解决最短路问题，其运行过程中需要储存每一层的信息，所以其运行时需要储存的信息量较大，如果人脑也可储存大量信息的话，理论上人脑也可运行BFS。
• 3）多数情况运行BFS所需的内存会大于DFS需要的内存(DFS一次访问一条路，BFS一次访问多条路)
• 4）风险：DFS容易爆栈(栈不易”控制”)，BFS通过控制队列可以很好解决”爆队列”风险。