Implementation of leetcode BFS code framework
Learning experience:
 There is such a sentence in the algorithm sketch. The operation of binary tree can derive a lot of algorithm ideas. More and more questions are brushed, and more and more experience will be gained
 There are also two forms of binary tree traversal, DFS and BFS. DFS includes three forms of traversal before, during and after sequence, and BFS only has hierarchical traversal,
 Hierarchical traversal is divided into types. Different data structures are used to derive different traversal sequences. You can do 32 questions in sword finger offer to specific operation queues
 There is also a certain correlation between DFS and BFS target operations, but that is to add the pending data to the container, and then get the corresponding data from the container for processing. BFS is the queue and DFS is the stack
 Another way of thinking, if this container is changed arbitrarily, there will be various search algorithms. If it is placed in a heap, a minimum spanning tree will be generated, and if it is placed in a random container, it will be more fun, and so on
DFS code framework idea:
 Create a core data structure queue and a visit set to avoid going back many times
 Add the starting point to the queue and set visit to true
 Enter the queue, take out the starting point, spread the path, and judge when the end point is reached,
 Add the queue adjacent to the node to the queue and update the required extreme value
The code framework is as follows:
int BFS(Node start,Node target){ Queue<node> queue;//Core data structure Set<Node> visited;//Avoid going back queue.offer(start);//Add starting point to queue visited.add(start); int step = 0;//Record the number of diffusion steps while(q not empty){ int sz = queue.size(); //Spread all nodes in the current queue around for (int i = 0; i < sz; i++) { Node cur = queue.poll(); //The judgment time has reached the end if (cur is target){ return step; } //Add adjacent nodes of cur to the queue for (Node x : cur.adj()){ if (x not in visited){ queue.offer(x); visited.add(x) } } } //Focus and update the steps here step++; } }
leetcode question 111 minimum depth of binary tree
Experience:

Before doing this problem, I did the problem of finding the maximum depth of binary tree. I thought in the same way, but the error did not take into account that the left or right child nodes of the root node are null

The core framework of bfs is not difficult to understand, which is to abstract some problems into a graph, start from one point and spread around,

The main difference between BFS and DFS is that the relative path found by BFS must be the shortest, but the cost is that the spatial complexity is much larger than that of DFS,

Why can BFS find the shortest distance? Can't DFS?
First, look at the logic of BFS. Every time depth is added, all nodes in the queue will take a step forward, which ensures that the number of steps taken is the least when reaching the destination for the first time.
Can DFS not find the shortest path? In fact, it is OK, but relatively speaking, the time complexity will be much higher. DFS actually walks through all paths by means of recursive stack records. It must be necessary to compare all tree branches in the binary tree with the search network to find out how long the shortest path is
With the help of queues, BFS can go one step at a time and go hand in hand. It can find the shortest distance without traversing the whole tree

lass Solution { public int minDepth(TreeNode root) { //I'm just bored. Why can't I do these problems? I'm really angry! //Binary tree is actually a very simple data structure. Breadth first is that the data structures of applications are different, and depth first is the queue of applications if (root == null){ return 0; } Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root); int depth = 1; while(!queue.isEmpty()){ int sz = queue.size(); for(int i = 0;i < sz;i++){ TreeNode curnode = queue.poll(); if (curnode.right == null && curnode.left == null){ return depth; } if (curnode.left != null){ queue.offer(curnode.left); } if (curnode.right != null){ queue.offer(curnode.right); } } depth++; } return depth; } }
leetcode question 752, open the turntable lock
Idea:
1. The difficulty of this problem is that it cannot appear deadends，How to calculate the shortest path, 2. We don't care about all the restrictions, no matter deadend and target If you were asked to design an algorithm and enumerate all password combinations, what would you do 3. If you only need to turn the lock, there are several possibilities. There are four positions in total. Each position can turn up or down, that is, there are eight possibilities, 4. Starting from 0000, you can cite 1000 9000 0100 0900 in one turn ...These eight kinds of passwords, and then use the password as the basis. After each password is turned, list all the possibilities 5. If you think about it carefully, you can abstract out a picture. Each node has eight adjacent nodes, which allows you to find the shortest distance. Isn't that typical BFS Then the framework can be used in the factory
class Solution { public int openLock(String[] deadends, String target) { //Store the death password we need to skip HashSet<String> deads = new HashSet<>(); for (String deadend : deadends) { deads.add(deadend); } // Check the memo to see if we have added this string HashSet<String> memo = new HashSet<>(); //Using the data structure of queue to build a bfs algorithm framework Queue<String> queue = new LinkedList<>(); //Add the actual password we turn queue.offer("0000"); memo.add("0000"); //Breadth first traversal search from the starting point int step = 0; while (!queue.isEmpty()) { int sz = queue.size(); //Spread all nodes in the current queue around for (int i = 0; i < sz; i++) { String curStr = queue.poll(); //The judgment passed our death code if (deads.contains(curStr)) { continue; } //Judge when you have reached the end if (curStr.equals(target)) { return step; } //Starting from the traversed node, add the queue for (int j = 0; j < 4; j++) { String up = turnUp(curStr, j); if(!memo.contains(up)){ queue.offer(up); memo.add(up); } String down = turnDown(curStr, j); if (!memo.contains(down)) { queue.offer(down); memo.add(down); } } } //Add steps here step++; } return 1; } //First write the method of turning upward public String turnUp(String str,int j){ char[] chars = str.toCharArray(); if (chars[j] == '9'){ chars[j] = '0'; }else{ chars[j] += 1; } return new String(chars); } public String turnDown(String str,int j){ char[] chars = str.toCharArray(); if (chars[j] == '0'){ chars[j] = '9'; }else{ chars[j] = 1; } return new String(chars); } }