二叉树非递归遍历实现（Java）

首先理解一下二叉树节点结构。left指向左节点，right指向右节点，val为节点中的值。

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int x) {
        val = x;
    }

}

先序遍历

    //非递归先序遍历（需一个辅助栈，顺序为根——右——左）
    public static void preOrder(TreeNode root){
        if (root==null) return;
        ArrayDeque<TreeNode> stack = new ArrayDeque<>();
        stack.addLast(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pollLast();
            System.out.print(node.val+" ");
            if (node.right!=null) stack.addLast(node.right);
            if (node.left!=null) stack.addLast(node.left);
        }

    }

中序遍历

    //非递归中序遍历（先把左边界的所有节点入栈，然后弹出栈顶节点，若栈顶节点有右节点则将右节点的所有左边界节点入栈，再弹出，周而复始)
    public static void inOrder(TreeNode root){
        if (root==null) return;
        ArrayDeque<TreeNode> stack = new ArrayDeque<>();
        while (root!=null || !stack.isEmpty()){
            if (root!=null){
                stack.addLast(root);
                root=root.left;
            }else {
                root=stack.pollLast();
                System.out.print(root.val+" ");
                root=root.right;
            }

        }

    }

后续遍历

    //非递归后续遍历(需要两个辅助栈，第一个辅助站顺序未根——左——右)
    public static void reverseOrder(TreeNode root){
        if (root==null) return;
        ArrayDeque<TreeNode> stack = new ArrayDeque<>();
        ArrayDeque<Integer> res = new ArrayDeque<>();
        stack.addLast(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pollLast();
            res.addLast(node.val);
            if (node.left!=null) stack.addLast(node.left);
            if (node.right!=null) stack.addLast(node.right);
        }
        while (!res.isEmpty()){
            System.out.print(res.pollLast()+" ");
        }
    }

层序遍历（每一层都分开输出）

    //非递归层序遍历
    public static void levelOrder(TreeNode root){
        List<List<Integer>> res= new ArrayList<>();
        Queue<TreeNode>q1=new ArrayDeque<TreeNode>();
        q1.add(root);
        while (!q1.isEmpty()) {
            int size=q1.size();
            List<Integer> value=new ArrayList<Integer>();
            for(int i=0;i<size;i++)
            {
                TreeNode pNode=q1.poll();
                if(pNode.left!=null)
                    q1.add(pNode.left);
                if(pNode.right!=null)
                    q1.add(pNode.right);
                value.add(pNode.val);
            }
            res.add(value);
        }
        System.out.println(res.toString());
    }

最后分享一道题目，是基于层序遍历来做的：求出一棵树的最大宽度，即处于同一层节点 的最大数量。只需在层序遍历中加入一个变量wideCount用于统计即可。

    //计算最大宽度
    public static void maxWide(TreeNode root){
        int wideCount=Integer.MIN_VALUE;
        Queue<TreeNode>q1=new ArrayDeque<TreeNode>();
        q1.add(root);
        while (!q1.isEmpty()) {
            int size=q1.size();
            List<Integer> value=new ArrayList<Integer>();
            for(int i=0;i<size;i++)
            {
                TreeNode pNode=q1.poll();
                if(pNode.left!=null)
                    q1.add(pNode.left);
                if(pNode.right!=null)
                    q1.add(pNode.right);
                value.add(pNode.val);
            }
            wideCount = Math.max(wideCount, value.size());
        }
        System.out.println(wideCount);
    }

}

下面这个是主函数，主函数中构造了一个二叉树[1,2,3,4,5,6,7]用于测试。

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left= new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left=new TreeNode(4);
        root.left.right=new TreeNode(5);
        root.right.left=new TreeNode(6);
        root.right.right =new TreeNode(7);
        //下面分别是四种遍历
        preOrder(root);
        System.out.println("");
        inOrder(root);
        System.out.println("");
        reverseOrder(root);
        System.out.println("");
        levelOrder(root);

        System.out.println("二叉树的最大宽度");
        maxWide(root);
    }

  输出结果：