树-树的遍历（DFS、BFS、先序、中序、后序）

树的遍历方式

树的遍历方式总体分为两类：深度优先搜索（DFS）、广度优先搜索（BFS），其实这两种方式主要是图的遍历方式，但是树可以被抽象为简单的图，所以这两种方式也可以作为树的遍历方式。

• 常见的DFS：先序遍历、中序遍历、后序遍历
• 常见的BFS：层序遍历（按层遍历）
  

深度优先搜索

深度优先搜索（DFS）简单来说就是沿着每一个分支路径遍历直到不能再深入为止，也就是到达了叶节点。如果到达叶节点，那我们就向上回溯，回到叶节点之前的那一个节点，接着遍历该节点未被访问过的子节点。一直重复这个过程直到所有的节点把遍历完。

以上图为例，我们走一下整体的遍历流程：

• 首先访问A节点，接着我们访问A的子节点B节点
• B节点访问之后，我们在访问B的子节点D节点
• D节点没有子节点，所以我们向上回溯，访问B节点
• 发现B节点的的子节点E未被访问，那么我们访问E节点
• E节点有子节点I节点，我们访问E节点的子节点I
• I节点为叶节点，没有子节点，所以我们向上回溯到E节点
• E节点的所有节点都被访问过了，继续回溯到上一个节点B
• B节点的所有子节点也都被访问过了，继续回溯到A节点，发现A的子节点C未被访问，访问C
• 重复上述过程，知道所有的节点被访问…

实现这个过程的时候有一个关键点，我们可以设置一个visited[]数组，长度为节点的个数，初始值为0，如果被访问了将其对应下标位置的visited[index]设置为1，防止重复访问，陷入死循环。

实现方式

深度优先搜索（DFS）的实现方式主要有两种：

1. 递归实现
2. 迭代实现（依靠栈数据结构）

递归实现

/*
此处的返回值并没有什么含义，大家可以根据自己的需求自行修改，代码是根据下面所示的二叉树写的。
*/
   3
   / \
  9  20
    /  \
   15   7
public int depthTraversal(TreeNode root)
 {
      if(root == null) return -1;
      System.out.print(root.val + " ");
      depthTraversal(root.left);
      depthTraversal(root.right);
      return 0;

  }
运行结果：3 9 20 15 7 

迭代实现

首先我们要知道栈这种数据结构是先进后出，所以我们入栈的时候要先压入最右的节点，然后依次从右往左压入节点，这样就能保证出栈的时候首先访问左节点。
具体的步骤如下：

1. 首先我们将节点A压入栈中，stack(A)
2. 然后我们将A出栈，同时将A的子节点从右到左压入栈中，此时B在栈的顶部，stack(B,C)
3. 然后将B节点弹出，同时将B的子节点E，D压入栈中，此时D在栈的顶部，stack（D,E,C）
4. 然后将D节点弹出，没有子节点压入,此时E在栈的顶部，stack（E，C）
5. 然后将E节点弹出，同时将E的子节点I压入，stack（I,C）
6. 重复上述过程，直到栈空，最终遍历完成

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/

public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> lists=new ArrayList<Integer>();
        if(root==null)
            return lists;
        Stack<TreeNode> stack=new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode tree=stack.pop();　　　　　　//先往栈中压入右节点，再压左节点，这样出栈就是先左节点后右节点了。
            if(tree.right!=null)
                stack.push(tree.right);
            if(tree.left!=null)
                stack.push(tree.left);
            lists.add(tree.val);
        }
        return lists;
    }
}
    3
   / \
  9  20
    /  \
   15   7
结果：3 9 20 15 7 

广度优先搜索

广度优先搜索就是层序遍历，顾名思义就是按照树的层次结构一层一层遍历，访问完一层我们就进入下一层，且每个节点只能访问一遍。上图按照广度优先搜索方式的结果为：A,B,C,D,E,F,G,H,I(假设每层节点从左到右访问)。

实现方式

广度优先搜索的实现方式主要有两种：

1. 递归实现
2. 迭代实现（依靠队列数据结构）

递归实现

public class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        DFS(root, 0);
        return res;
    }

    private void BFS(TreeNode root, int level) {
        //递归终止条件
        if (root == null) {
            return;
        }
        if (level >= res.size()) {
            //如果是新的一层,就创建
            res.add(new ArrayList<>());
        }
        //添加当前的元素
        res.get(level).add(root.val);
        //遍历左节点
        DFS(root.left, level + 1);
        //遍历又节点
        DFS(root.right, level + 1);
    }
}

广度优先搜索使用递归的方式较为繁琐，可以直接使用迭代的方式。

迭代实现

通过迭代实现树的层序遍历，需要借助数据结构队列先进先出的特性。我们以上图为例进行分析。
具体实现步骤
我们通过数组res[]来保存出队的元素

• 首先将节点A插入队列，队列中有元素A，queue(A)
• 接着将A出队，将A存入数组，同时将A的左右节点依次插入队列，queue(B,C)
• 然后将B出队，存入数组，同时将B的左右节点依次插入队列，queue(C,D,E)
• 然后将C出队，存入数组，同时将C的左右子节点依次插入队列，queue(D,E,F,G,H)
• 重复上述过程，直到队列为空，res中保存了树层序遍历的结果。

public List<Integer> levelOrder(TreeNode root) {
        Queue<TreeNode > queue = new LinkedList<>();
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        queue.add(root);
        while (!queue.isEmpty())
        {
            ListNode node = queue.poll();
            res.add(node.val);
            if(node.left != null) queue.add(node.left);
            if(node.right != null) queue.add(node.right);
            
        }
        return res;
    }