二叉树前序、中序、后序遍历递归的循环优化

LeetCode上题目:

https://leetcode.cn/problems/binary-tree-postorder-traversal/

1.前序遍历：节点遍历顺序为 中、左、右。

如图结构二叉树，输出顺序如图中1,2,3所示。

 

 递归是最容易想到的方式。

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> r = new ArrayList<>();
        rs(root,r);
        return r;
    }

    void rs(TreeNode n,List<Integer> r){
        if(n == null) return;
        r.add(n.val);
        if(n.left !=null) rs(n.left,r);
        if(n.right !=null) rs(n.right,r);
    }

但递归深度过深可能出现Stack Overflow，而且反复的进行出栈入栈也影响效率，可以用栈模拟递归。

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> r = new ArrayList<>();
        if(root == null) return r;
        Stack<TreeNode> s = new Stack<>();
        s.push(root);
        while(!s.isEmpty()){
            TreeNode n = s.pop();
            r.add(n.val);
            if(n.right != null) s.push(n.right);
            if(n.left != null) s.push(n.left);
        }
        return r;
    }

两者按照完全相同的顺序访问了二叉树的各个节点，只是一个用的递归，一个用的循环。

 

2.中序遍历 ： 如图结构二叉树，输出顺序如图中1,2,3所示。

LeetCode 题目： https://leetcode.cn/problems/binary-tree-inorder-traversal/

递归式：

    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> r = new ArrayList<>();
        rs(root,r);
        return r;
    }

    void rs(TreeNode n,List<Integer> r){
        if(n == null) return;
        if(n.left !=null) rs(n.left,r);
        r.add(n.val);
        if(n.right !=null) rs(n.right,r);
    }

 

循环式：

public List<Integer> inorderTraversal(TreeNode root) {

    List<Integer> r = new ArrayList<>();

    if(null == root) return r;

    Stack<TreeNode> s = new Stack<>();

    TreeNode cur = root;

    while(!s.isEmpty() || cur != null){

        while(cur != null){

            s.push(cur);

            cur = cur.left;

        }

        TreeNode n = s.pop();

        r.add(n.val);

        if(n.right != null)

            cur = n.right;

    }

    return r;

}

 

 

3.后序遍历：  如图结构二叉树，输出顺序如图中1,2,3所示。

 

 LeetCode后序： https://leetcode.cn/problems/binary-tree-postorder-traversal/

 递归式：

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> r = new ArrayList<>();
        rs(root,r);
        return r;
    }

    void rs(TreeNode n,List<Integer> r){
        if(n == null) return;
        if(n.left !=null) rs(n.left,r);
        if(n.right !=null) rs(n.right,r);
        r.add(n.val);
    }

 

循环式：

    public List<Integer> postorderTraversal(TreeNode root) {
        if(root == null) return new ArrayList<>();
        Stack<TreeNode> s1 = new Stack();
        Stack<TreeNode> s2 = new Stack();
        s1.push(root);
        while(!s1.isEmpty()){
            TreeNode n = s1.pop();
            s2.push(n);
            if(n.left != null)
                s1.push(n.left);
            if(n.right != null)
                s1.push(n.right);
        }
        List<Integer> r = new ArrayList<>();
        while(!s2.isEmpty())
            r.add(s2.pop().val);    
               
        return r;
    }