BFS - 20190206

1.二叉树 BFS

2.拓扑排序  重点 BFS

3.棋盘上的宽搜  BFS

图的遍历

层级遍历，由点及面，拓扑排序，简单图的最短路径

如果题目问最短路径：可能是BFS或者DP， 最长路径：DFS

queue 的数组实现

1.二叉树的BFS

https://www.lintcode.com/problem/binary-tree-level-order-traversal/description

 /**
  * Definition of TreeNode:
  * public class TreeNode {
  *     public int val;
  *     public TreeNode left, right;
  *     public TreeNode(int val) {
  *         this.val = val;
  *         this.left = this.right = null;
  *     }
  * }
  */

 public class Solution {
     /**
      * @param root: A Tree
      * @return: Level order a list of lists of integer
      */
     public List<List<Integer>> levelOrder(TreeNode root) {
         // write your code here
         List<List<Integer>> results = new ArrayList<>();
         if(root == null){
             return results;
         }
         //interface offer(add) poll(pop)
         Queue<TreeNode> queue = new LinkedList<>();
         //put start node into queue
         queue.offer(root);

         while(!queue.isEmpty()){
             //lever x->x+1
             ArrayList<Integer> currentLevel = new ArrayList();
             int size = queue.size();
             for(int i =0; i<size;i++){
                 TreeNode head = queue.poll();
                 currentLevel.add(head.val);
                 if(head.left != null){
                     queue.offer(head.left);
                 }
                 if(head.right != null){
                     queue.offer(head.right);
                 }
             }
             results.add(currentLevel);
         }

         return results;

     }
 }

queue, offer 和 add的区别

序列化：

xml json thrift(by facebook) protobuf(by google)

序列化算法设计时需要考虑的因素:压缩率 thrift protobuf是为了更快的传输数据和节省存储空间而设计的

可读性：如json

https://www.lintcode.com/problem/graph-valid-tree/description

 public class Solution {
     /**
      * @param n: An integer
      * @param edges: a list of undirected edges
      * @return: true if it's a valid tree, or false
      */
     public boolean validTree(int n, int[][] edges) {
         // write your code here
         if(n==0){
             return false;
         }

         if(edges.length != n-1){
             return false;
         }
         //adjacent lists
         Map<Integer,Set<Integer>> graph = initializeGraph(n,edges);

         Queue<Integer> queue = new LinkedList<>();
         Set<Integer> hash = new HashSet<>();

         queue.offer(0);
         hash.add(0);

         while(!queue.isEmpty()){
             int node = queue.poll();
             for(Integer neigh:graph.get(node)){
                 if(hash.contains(neigh)){
                     continue;
                 }
                 hash.add(neigh);
                 queue.offer(neigh);
             }
         }
         return hash.size()==n;

     }

     private Map<Integer,Set<Integer>> initializeGraph(int n,int[][]edges){
         Map<Integer,Set<Integer>> graph = new HashMap<>();
         for(int i=0;i<n;i++){
             graph.put(i,new HashSet<>());
         }
         for(int i =0;i<edges.length;i++){
             int u = edges[i][0];
             int v = edges[i][1];
             graph.get(u).add(v);
             graph.get(v).add(u);
         }
         return graph;
     }
 }