写一个java的二叉树的非递归先、中、后序的遍历代码

java非递归先、中、后序遍历二叉树

代码逻辑这三个都是差不多。只是在读取顺序上有一点差别。后序遍历要额外的搞一个栈进行结果倒序。

以下为代码的逻辑（以先序遍历为例子）：

沿着根的左孩纸，依次入栈，直到左孩纸为空。出栈一个元素访问，若其右孩纸为空，继续出栈一个元素。若其右孩纸不空，则重复上述逻辑。直到栈和遍历指针全为空。

以下为代码实现部分。（附手写的二叉树。）

用到的工具类为：import java.util.Stack;

二叉树的节点：

//二叉树的节点
class Lnode{
    //构造方法初始化并将左右孩纸置空
    Lnode(){
        l = null;
        r = null;
    }
    //左孩纸
    Lnode l;
    //右孩纸
    Lnode r;
    //存储数据
    int data;
}

手写一颗二叉树（原谅我菜）：

//手写一颗二叉树
    public static Lnode bi_tree(){
        Lnode root = new Lnode();
        root.data = 0;
        root.l = new Lnode();
        root.l.data = 1;
        root.l.l = new Lnode();
        root.l.l.data = 3;
        root.l.r = new Lnode();
        root.l.r.data = 4;
        root.r = new Lnode();
        root.r.data = 2;
        root.r.l = new Lnode();
        root.r.l.data = 5;
        root.r.r = new Lnode();
        root.r.r.data = 6;
        return root;
    }

先序遍历：

//先序遍历二叉树
    public static void prepreOrder(Lnode root){
        //将根节点赋给遍历指针
        Lnode p = root;
        //生成一个存储节点的栈
        Stack<Lnode> s = new Stack<Lnode>();
        //当遍历指针和栈全不空时开始循环，全为空时代表二叉树节点全部遍历结束
        while(p!=null || !s.empty()){
            //当遍历指针沿着做孩子寻找，直到为空停止循环
            while(p!=null){
                //先序遍历的位置
                System.out.println(p.data);
                s.push(p);
                p = p.l;
            }
            //当遍历指针找到左孩纸为空的节点时，出栈一个元素赋给遍历指针
            if(!s.empty()){
                p = s.pop();
                p = p.r;
            }
        }
    }

中序遍历（使用逻辑和先序遍历很相似，只有遍历数据的位置不同）

//中序遍历二叉树
    public static void inOrder(Lnode root){
        //将根节点赋给遍历指针
        Lnode p = root;
        //生成一个存储节点的栈
        Stack<Lnode> s = new Stack<Lnode>();
        //当遍历指针和栈全不空时开始循环，全为空时代表二叉树节点全部遍历结束
        while(p!=null || !s.empty()){
            while(p!=null){
                s.push(p);
                p = p.l;
            }
            //当遍历指针找到左孩纸为空的节点时，出栈一个元素赋给遍历指针
            if(!s.empty()){
                p = s.pop();
                //中序遍历的位置
                System.out.println(p.data);
                p = p.r;
            }
        }
    }

后序遍历（后序遍历就是把中序的结果用栈进行倒序）

//后序遍历
    public static void postOrder(Lnode root){
        //将根节点赋给遍历指针
        Lnode p = root;
        //生成一个存储节点的栈
        Stack<Lnode> s = new Stack<Lnode>();
        //弄个栈将中序的结果倒序就可以得到后序遍历的结果
        Stack<Integer> cache = new Stack<Integer>();
        //当遍历指针和栈全不空时开始循环，全为空时代表二叉树节点全部遍历结束
        while(p!=null || !s.empty()){
            while(p!=null){
                s.push(p);
                p = p.l;
            }
            //当遍历指针找到左孩纸为空的节点时，出栈一个元素赋给遍历指针
            if(!s.empty()){
                p = s.pop();
                //后序遍历的位置
                cache.push(p.data);
                p = p.r;
            }
        }
        //逐个出栈，直到栈空
        while(!cache.empty()){
            System.out.println(cache.pop());
        }
    }

测试代码（main）：

public static void main(String[] args) {
        Lnode root = bi_tree();
        System.out.println("--------先序遍历结果--------");
        System.out.print("[");
        preOrder(root);
        System.out.print("]");
        System.out.println();
        System.out.println("--------------------------");
        System.out.println("--------中序遍历结果--------");
        System.out.print("[");
        inOrder(root);
        System.out.print("]");
        System.out.println();
        System.out.println("--------------------------");
        System.out.println("--------后序遍历结果--------");
        System.out.print("[");
        postOrder(root);
        System.out.print("]");
        System.out.println();
        System.out.println("--------------------------");
    }

结果：

请尊敬的读者多批评，初学者比较菜。望见谅！！！谢谢