JAVA：二叉树的遍历方式总结：深度优先遍历、广度优先遍历+前中后序遍历的递归、迭代法实现

1.二叉树的主要遍历方式

（1）深度优先遍历：遍历时往树的深处遍历，遇到叶子节点就返回。可以用递归法或迭代法实现。一般用递归来模拟往深处遍历的过程。

        进一步可以分为前序遍历、中序遍历和后序遍历。

前序遍历：先遍历中间节点，然后左节点，最后右节点。（中左右）

同理，中序遍历：左中右；后序遍历：左右中。

判断技巧是：中间节点在的位置就是遍历的顺序。比如中左右，中间节点在前，就是前序；左中右，中间节点在中间，就是中序；左右中，中间在最后，就是后序遍历。

 比如这棵二叉树：

前序遍历： [ 1，2，3，4，5，6，7 ]

中序遍历： [ 4，2，5，1，6，3，7 ]

后序遍历： [ 4，5，2，6，7，3，1 ]

（2）广度优先遍历：从根节点开始，一层一层地往下遍历。一般用迭代法实现。

2.实现代码

 节点类的定义：

public class TreeNode {
    int val;
  	TreeNode left;
  	TreeNode right;
  	TreeNode() {}
  	TreeNode(int val) { this.val = val; }
  	TreeNode(int val, TreeNode left, TreeNode right) {
    		this.val = val;
    		this.left = left;
    		this.right = right;
  	}
}

（1）深度优先遍历

①递归法 

前序遍历：思路：遇到空节点就退出本层递归函数，然后依此处理中间节点、左节点和右节点。中间节点直接加入结果集，然后依次向左、右递归。

public List<Integer> preOrderReverse(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        preOrder(root, (ArrayList<Integer>) res);
        return res;
    }

    void preOrder(TreeNode root, ArrayList<Integer> res){
        if(root==null){
            return;    //遇到空节点，返回
        }
        res.add(root.val);           // 中：节点加入结果数组
        preOrder(root.left, res);    // 左：遍历当前节点的左节点
        preOrder(root.right, res);   // 右：遍历当前节点的右节点
    }

中序、后序遍历同理，只需把中间节点的处理逻辑分别放在左右节点处理逻辑的中间和后面。

②迭代法

前序遍历/后序遍历：迭代法实现前序和后序遍历代码相似。需要借助栈来实现：前序遍历，右节点先入栈，左节点后入栈（先入后出，所以跟遍历顺序相反）。

public List<Integer> preOrderReverse2(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root==null){
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();    
        stack.push(root);   //根节点先入栈
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            res.add(node.val);    // 中：节点值加入结果集
            if (node.right!=null) {
                stack.push(node.right);    //左： 右节点入栈
            }
            if(node.left!=null){
                stack.push(node.left);     //右：左节点入栈
            }
        }
        return res;
        }

中序遍历：中序遍历的迭代法需要借用指针的遍历访问节点，借助栈处理节点上的元素。

public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root==null){
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = new TreeNode();
        cur = root;    // 初始化指针：指向根节点
        while(!stack.isEmpty() || cur!=null){
            if(cur!=null){    
                stack.push(cur);
                cur = cur.left;    // 左：向左边的叶子节点迭代
            }else{
                cur = stack.pop();
                res.add(cur.val);  // 中：加入结果集
                cur = cur.right;   // 右： 向右边的叶子节点迭代
            }
        }
        return res;

（2）广度优先遍历

借助队列实现。队列中存放的是每层的元素，每对队列进行完一次遍历，相当于遍历了二叉树的一层元素，遍历的过程中每次都将当前遍历到的节点的左右子节点加入队列，所以在遍历完本层节点后，队列中的元素就是下一层的节点。

public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root==null){
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);        // 根节点先加入队列
        while (!queue.isEmpty()){
            int n = queue.size();    //队列中的元素数：等于本层的元素个数
            List<Integer> temp = new ArrayList<>();    //temp存放本层遍历的元素
            for(int i=0; i<n; i++){
                TreeNode node = queue.poll();
                temp.add(node.val);    // 本层遍历到的元素的值加入temp
                if(node.left!=null){
                    queue.add(node.left);    // 左节点加入队列
                }
                if (node.right!=null){
                    queue.add(node.right);   // 右节点加入队列
                }
            }
            res.add(temp);
        }
        return res;