Java之树的遍历（非递归）

package niuke;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}

public class Tree_2 {
    //前序遍历的非递归实现
    public ArrayList<Integer> preOrder(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.empty()){
            TreeNode treeroot = stack.pop();
            list.add(treeroot.val);
            if(treeroot.right!=null){
                stack.push(treeroot.right);
            }
            if(treeroot.left!=null){
                stack.push(treeroot.left);
            }
        }
        return list;
    }
    //后序遍历的非递归实现
    public ArrayList<Integer> postOrder(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p =root;
        TreeNode pre= root;
        while(p!=null||!stack.isEmpty()){
            while(p!=null){
                stack.push(p);
                p= p.left;
            }
            if(!stack.isEmpty()){
                TreeNode treeroot = stack.peek().right;
                if(treeroot==null||treeroot==pre){
                    p= stack.pop();
                    list.add(p.val);
                    pre=p;
                    p=null;
                }
                else{
                    p=treeroot;
                }
            }
        }


        return list;
    }
    //中序遍历的非递归实现
    public ArrayList<Integer> inOrder(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while(p!=null || !stack.isEmpty()){
            while(p!=null){
                stack.push(p);
                p= p.left;
            }
            if(!stack.empty()){
                TreeNode treeroot = stack.pop();

                list.add(treeroot.val);
                p=treeroot.right;
            }
        }

        return list;


    }
    //层序遍历的非递归实现
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if(root==null){
            return list;
        }
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode treeroot = queue.poll();

            if(treeroot.left!=null){

                queue.offer(treeroot.left);
            }
            if(treeroot.right!=null){

                queue.offer(treeroot.right);
            }
            list.add(treeroot.val);

        }
        return list;
    }
    public static void main(String[] args) {
        TreeNode a = new TreeNode(0);
        TreeNode b = new TreeNode(1);
        TreeNode c = new TreeNode(2);
        TreeNode d = new TreeNode(3);
        TreeNode e = new TreeNode(4);
        TreeNode f = new TreeNode(5);
        TreeNode g = new TreeNode(6);
        a.left=b;
        a.right=c;
        b.left=d;
        b.right=e;
        c.left=f;
        c.right=g;
        Tree_2 t = new Tree_2();
        ArrayList<Integer> list = new ArrayList<>();
//      list=t.PrintFromTopToBottom(a);
//      list= t.preOrder(a);
        list = t.postOrder(a);
//      list= t.inOrder(a);
        for(Integer item:list)
            System.out.println(item);
    }
}