二叉树的前中后序遍历（java递归、迭代分别实现）

代码实现（递归）

递归算法的三个要素：

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

以前序遍历为例：**

1. 确定递归函数的参数和返回值：因为要打印出前序遍历节点的数值，所以参数里需要传入List在放节点的数值，除了这一点就不需要在处理什么数据了也不需要有返回值，所以递归函数返回类型就是void，代码如下：

void preOrder(TreeNode root, ArrayList<Integer> list)

​ 2. 确定终止条件：在递归的过程中，如何算是递归结束了呢，当然是当前遍历的节点是空了，那么本层递归就 要结束了，所以如果当前遍历的这个节点是空，就直接return，代码如下：

if (root == null) {return;}

3. 确定单层递归的逻辑：前序遍历是中左右的循序，所以在单层递归的逻辑，是要先取中节点的数值，代码如下：

result.add(root.val);       //中
preOrder(root.left, list);	//左
preOrder(root.right, list);	//右

完整代码：

前序遍历：

/**
 * Definition for a binary tree node.
 * 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;
 *     }
 * }
 */
class Solution {
    ArrayList<Integer> preOrderReverse(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        preOrder(root, list);
        return list;
    }

    void preOrder(TreeNode root, ArrayList<Integer> list) {
        if (root == null) {
            return;
        }
        result.add(root.val);       //中
		preOrder(root.left, list);	//左
		preOrder(root.right, list);	//右
    }
}

其他两种，只要交换一下顺序就行了

中序遍历（左中右）

后序遍历（左右中）

代码实现（迭代）

前序遍历

前序遍历是中左右，每次先处理的是中间节点，那么先将跟节点放入栈中，然后将右孩子加入栈，再加入左孩子。

为什么要先加入 右孩子，再加入左孩子呢？ 因为这样出栈的时候才是中左右的顺序。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.right != null){
                stack.push(node.right);
            }
            if (node.left != null){
                stack.push(node.left);
            }
        }
        return result;
    }
}

后序遍历

// 后序遍历顺序 左-右-中 入栈顺序：中-左-右 出栈顺序：中-右-左， 最后翻转结果
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.left != null){
                stack.push(node.left);
            }
            if (node.right != null){
                stack.push(node.right);
            }
        }
        Collections.reverse(result);
        return result;
    }
}

中序遍历

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList<>();
        if(root==null)return result;
        Deque<TreeNode> deque = new ArrayDeque<>(); //这里不需要将root添加到deque里
        TreeNode cur=root;
        while(cur!=null||!deque.isEmpty()){
            if(cur!=null){
                deque.push(cur);
                cur=cur.left;
            }else{
                cur=deque.poll();
                result.add(cur.val);
                cur=cur.right;
            }
        }
        return result;
    }
}

层次遍历

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> resList=new ArrayList<>();
        if(root==null)return resList;
        Queue<TreeNode> queue =new LinkedList<>();//频繁插入，用LinkedList
        queue.add(root);

        while(!queue.isEmpty()){
            List<Integer> list =new ArrayList<>();
            int len=queue.size();
            while(len>0){
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left!=null) queue.add(node.left);
                if(node.right!=null) queue.add(node.right);
                len--;
            }
            resList.add(list);
        }
        return resList;
    }
}