Leetcode binary-tree-postorder 二叉树后续遍历

题目描述

 

Given a binary tree, return the postorder traversal of its nodes' values.

For example:
Given binary tree{1,#,2,3},

   1
    \
     2
    /
   3

 

return[3,2,1].

Note: Recursive solution is trivial, could you do it iteratively?

题目要求使用非递归（迭代）的方式来解决该问题。

解法一：递归（>_<）

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.ArrayList;
public class Solution {
    private ArrayList<Integer> result;
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        result = new ArrayList<Integer>();
        preorder(root);
        return result;
    }
    private void preorder(TreeNode root)
    {
        if(root!=null)
        {
            preorder(root.left);
            preorder(root.right);
            result.add(root.val);
        }
    }
}

解法二：非递归

使用两个栈进行处理，方法简单，代码易懂。>_<

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.Stack;
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> result = new ArrayList();
        if(root == null)
            return result;
        Stack<TreeNode> stack1 = new Stack();
        Stack<TreeNode> stack2 = new Stack();
        stack1.push(root);
        TreeNode tmpNode = null;
        while(!stack1.isEmpty()){
            tmpNode = stack1.pop();
            if(tmpNode.left!=null)
                stack1.push(tmpNode.left);
            if(tmpNode.right!=null)
                stack1.push(tmpNode.right);
            stack2.push(tmpNode);
        }
        while(!stack2.isEmpty()){
            result.add(stack2.pop().val);
        }
        return result;
    }
}

stack2中存放的是后序遍历输出的整个顺序。stack1中先入跟然后入左和入右，这样stack1先pop跟，然后pop右，接着pop左；正好Stack2先入跟，右，左，故，stack2循环pop的时候就是【左右跟】的形式

解法3：

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 **/
 import java.util.ArrayList;
 import java.util.Stack;
import java.util.LinkedList;
public class Solution {
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> result = new LinkedList<Integer>();
        if(root == null)
            return new ArrayList(result);
        Stack<TreeNode> stack = new Stack();
        TreeNode tmpNode = root;
        while(!stack.isEmpty() || tmpNode!=null)
        {
            if(tmpNode!=null)
            {
                stack.push(tmpNode);
                result.addFirst(tmpNode.val);
                tmpNode = tmpNode.right;
            }else
            {
                tmpNode = stack.pop().left;
            }
        }
        return new ArrayList(result);
    }
}

该方法类似于方法二。代码中使用LinkedList，该数据结构的实现是基于链表的，所以有addFirst()方法，反之，基于数组实现的ArrayList则没有该方法，两者之间可以通过构造方法进行转换。

解法4：

该方法类似于方法2，使用一个链表和一个栈，类似于根，后，前的输出方式。但是dayin为前后跟的形式。

代码如下

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Stack;
public class Solution {
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> list = new LinkedList();
        if(root == null)
            return new ArrayList(list);
        Stack<TreeNode> stack = new Stack();
        stack.push(root);
        TreeNode tmpNode = null;
        while(!stack.isEmpty()){
            tmpNode = stack.pop();
            list.addFirst(tmpNode.val);
            if(tmpNode.left!=null)
                stack.push(tmpNode.left);
            if(tmpNode.right!=null)
                stack.push(tmpNode.right);
        }
        return new ArrayList(list);
    }
}