深度优先搜索（DFS）和广度优先搜索（BFS）

深度优先搜索（DFS）

1.访问顶点v；
2.依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；
3.若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止

广度优先搜索（BFS）

首先将根节点放入队列中。
从队列中取出第一个节点，并检验它是否为目标。如果找到目标，则结束搜寻并回传结果。否则将它所有尚未检验过的直接子节点加入队列中。
若队列为空，表示整张图都检查过了——亦即图中没有欲搜寻的目标。结束搜寻并回传“找不到目标”。
重复步骤2。

广度优先遍历

• 采用非递归实现
• 需要辅助数据结构：队列

 public void levelOrderTraversal(){ 
                  if(root==null){ 
                     System.out.println("empty tree"); 
                      return; 
                  } 
                  ArrayDeque<TreeNode> queue=new ArrayDeque<TreeNode>(); 
                  queue.add(root); 
                  while(queue.isEmpty()==false){ 
                      TreeNode node=queue.remove(); 
                      System.out.print(node.value+" ");
                      if(node.left!=null){ 
                            queue.add(node.left);
                       }
                     if(node.right!=null){ 
                           queue.add(node.right); 
                      } 
                  }
                 System.out.print("\n");
       }

遍历顺序

例题

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：
二叉树：[3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
[3],
[9,20],
[15,7]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root==null){
            return res;
        }
        Queue<TreeNode> node = new LinkedList<>();
        node.add(root);
        while (!node.isEmpty()){
            ArrayList<Integer> integers = new ArrayList<>();
            int size = node.size();
            for (int i = 0; i < size; i++) {
                TreeNode node1 = node.remove();
                integers.add(node1.val);
                if(node1.left!=null){
                    node.add(node1.left);
                }
                if (node1.right != null) {
                    node.add(node1.right);
                }   
            }
            res.add(integers);
        }
        return res;
    }
}

102. 二叉树的层序遍历
     给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

示例：
二叉树：[3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

[
[3],
[9,20],
[15,7]
]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-level-order-traversal

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root==null){
            return res;
        }
        Queue<TreeNode> node = new LinkedList<>();
        node.add(root);
        while (!node.isEmpty()){
            ArrayList<Integer> integers = new ArrayList<>();
            int size = node.size();
            for (int i = 0; i < size; i++) {
                TreeNode node1 = node.remove();
                integers.add(node1.val);
                if(node1.left!=null){
                    node.add(node1.left);
                }
                if (node1.right != null) {
                    node.add(node1.right);
                }   
            }
            res.add(integers);
        }
        return res;
    }
}

515. 在每个树行中找最大值
     您需要在二叉树的每一行中找到最大的值。

示例：

输入:

      1
     / \
    3   2
   / \   \  
  5   3   9 

输出: [1, 3, 9]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        ArrayList<Integer> integers = new ArrayList<>();
        if(root==null){
            return integers;
        }
        LinkedList<TreeNode> node = new LinkedList<>();
        int cnt =1;
        int max=Integer.MIN_VALUE;
        node.add(root);

        while (!node.isEmpty()){
            while (cnt>0) {
                cnt--;
                TreeNode remove = node.remove();
                max = max > remove.val ? max: remove.val;
                if (remove.left != null) {
                    node.add(remove.left);
                }
                if (remove.right != null) {
                    node.add(remove.right);
                }
            }
            integers.add(max);
            max=Integer.MIN_VALUE;
            cnt=node.size();
        }
        return integers;
    }
}

433. 最小基因变化
     一条基因序列由一个带有8个字符的字符串表示，其中每个字符都属于 “A”, “C”, “G”, "T"中的任意一个。

假设我们要调查一个基因序列的变化。一次基因变化意味着这个基因序列中的一个字符发生了变化。

例如，基因序列由"AACCGGTT" 变化至 “AACCGGTA” 即发生了一次基因变化。

与此同时，每一次基因变化的结果，都需要是一个合法的基因串，即该结果属于一个基因库。

现在给定3个参数 — start, end, bank，分别代表起始基因序列，目标基因序列及基因库，请找出能够使起始基因序列变化为目标基因序列所需的最少变化次数。如果无法实现目标变化，请返回 -1。

注意:

起始基因序列默认是合法的，但是它并不一定会出现在基因库中。
所有的目标基因序列必须是合法的。
假定起始基因序列与目标基因序列是不一样的。
示例 1:

start: “AACCGGTT”
end: “AACCGGTA”
bank: [“AACCGGTA”]

返回值: 1
示例 2:

start: “AACCGGTT”
end: “AAACGGTA”
bank: [“AACCGGTA”, “AACCGCTA”, “AAACGGTA”]

返回值: 2
示例 3:

start: “AAAAACCC”
end: “AACCCCCC”
bank: [“AAAACCCC”, “AAACCCCC”, “AACCCCCC”]

返回值: 3

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-genetic-mutation
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    int min = Integer.MAX_VALUE;

    public int minMutation(String start, String end, String[] bank) {
        dfs(new HashSet<String>(), 0, start, end, bank);
        return (min == Integer.MAX_VALUE) ? -1 : min;
    }

    private void dfs(HashSet<String> integers, int i, String start, String end, String[] bank) {
        if (start.equals(end)) {
            min = Math.min(i, min);
        }
        for (String s : bank) {
            int diff = 0;
            for (int j = 0; j < s.length(); j++){
                if (start.charAt(j) != s.charAt(j))
                    if (++diff > 1) break;
            }
            if (diff == 1 && !integers.contains(s)) {
                integers.add(s);
                dfs(integers, i + 1, s, end, bank);
                integers.remove(s);
            }
        }
    }
}