使用递归和非递归方法实现二叉树的三种遍历

• 前序遍历：每个树的遍历顺序为：根节点→左节点→右节点。上图的前序遍历输出为：FCADBEHGM
• 中序遍历：每个树的遍历顺序为：左节点→根节点→右节点。上图的前序遍历输出为：ACBDFHEMG
• 后序遍历：每个树的遍历顺序为：左节点→右节点→根节点。上图的前序遍历输出为：ABDCHMGEF

1.前序遍历

• 递归法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private List<Integer> res = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        //中 ——> 左 ——> 右
        preorder(root);
        return res;
    }
    
    private void preorder(TreeNode node){
        if(node == null) return;
        res.add(node.val);
        preorder(node.left);
        preorder(node.right);
    }
}

• 非递归法
  创建一个栈，用来储存遍历的轨迹：
  1.如果栈不为空则储存当前栈顶元素的值，并弹栈；
  2.如果栈顶元素存在右儿子，将右儿子压入；
  3.如果栈顶元素有左儿子，将左儿子压入
  4.重复1直至栈为空

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            if(cur != null){
                res.add(cur.val);
                stack.push(cur);
                cur = cur.left;
            }else{
                cur = stack.pop();
                cur = cur.right;
            }
        }
        return res;
    }
}

2.中序遍历

• 递归法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private List<Integer> res = new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        inorder(root);
        return res;
    }
    
    public void inorder(TreeNode node){
        if(node == null) return;
        inorder(node.left);
        res.add(node.val);
        inorder(node.right);
    }
}

• 非递归法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            //压栈
            if(cur != null){
                stack.push(cur);
                cur = cur.left;
            }else{
                //左边已经存完，弹栈
                cur = stack.pop();
                res.add(cur.val);
                cur = cur.right;
            }
        }
        return res;
    }
}

3.后续遍历

• 递归法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    private List<Integer> res = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
        //左右中
        postorder(root);
        return res;
    }
    
    private void postorder(TreeNode node){
        if(node == null) return;
        postorder(node.left);
        postorder(node.right);
        res.add(node.val);
    }
}

• 非递归法
  使用栈来记录遍历轨迹，并使用一个变量来储存上一次方法的元素，当当前元素左右儿子为空或当前元素已经在上一轮访问过（即上一次方法访问的元素为当前访问元素的节点），则栈顶元素出栈

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;
        stack.push(root);
        
        while(!stack.isEmpty()){
            TreeNode cur = stack.peek();
            if((cur.left == null && cur.right == null)
              || (pre != null && (cur.right == pre || cur.left == pre))){
                res.add(cur.val);
                pre = cur;
                stack.pop();
            }else{
                if(cur.right != null) stack.add(cur.right);
                if(cur.left != null) stack.add(cur.left);
            }
        }
        
        return res;
    }
}