二叉树的先序、中序和后序的递归非递归方法

先说递归方法，递归方法就是根据二叉树的特征，通过调用左子树和右子树的顺序来决定 遍历的顺序：

public List<Integer> preorderTraversal(TreeNode root) {
        
        
        // write your code here
        ArrayList<Integer> l = new ArrayList<Integer>();
        method(root,l);
        return l;
    }
    public void method(TreeNode root,ArrayList<Integer> l){
        if(root == null)
            return;
        else{
            l.add(root.val);//改变此行的位置，即可实现三种遍历效果
            method(root.left,l);
            method(root.right,l);
        }

    } 

 

非递归方法，通过栈的调用，来实现对二叉树各个节点的遍历访问：

//先序
public List<Integer> preorderTraversal(TreeNode root) {
        
        
        // write your code here

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

        if (root == null) {
            return rt;
        }

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = root;

        while (p != null || !stack.empty()) {

            while (p != null) {
                rt.add(p.val);
                stack.push(p);
                p = p.left;
            }

            if (!stack.empty()) {
                p = stack.pop();
                p = p.right;
            }
        }

        return rt;
    }

//后序非递归 
public class PostTreeNode {
        TreeNode node;
        boolean first;
    }

    public List<Integer> postorderTraversal(TreeNode root) {

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

        if (root == null) {
            return rt;
        }

        Stack<PostTreeNode> stack = new Stack<PostTreeNode>();
        TreeNode p = root;
        PostTreeNode t;

        while (p != null || !stack.empty()) {

            while (p != null) {

                // 新建一个结点，这个结点包含一个布尔值first
                // 用来判断是否是第一次入栈
                PostTreeNode post = new PostTreeNode();
                post.node = p;
                post.first = true;
                stack.push(post);
                p = p.left;
            }

            if (!stack.empty()) {

                t = stack.pop();

                // 如果结点第一次出栈，再次入栈，将first置为false
                if (t.first == true) {
                    t.first = false;
                    stack.push(t);
                    p = t.node.right;
                } else {
                    rt.add(t.node.val);
                    p = null;
                }
            }
        }

        return rt;
    }

 

//中序非递归
    public List<Integer> inorderTraversal(TreeNode root){
        ArrayList<Integer> l = new ArrayList<Integer>();
        Stack<TreeNode> s =  new Stack<TreeNode>();
        while(root!=null||!s.empty()){
            if(root!=null){
                s.push(root);
                root = root.left;
            }
            else{
                root = s.pop();
                l.add(root.val);
                root = root.right;
            }
        }
        return l;
    }