二叉树遍历-栈实现

非递归方式实现二叉树的遍历，借助栈或者队列辅助完成。

public class MyBinaryTree {
    public static class TreeNode {
        private int data;
        private TreeNode left;
        private TreeNode right;

        public TreeNode(int data) {
            this.data = data;
        }
    }

    public static void main(String[] args) {
        MyBinaryTree myBinaryTree = new MyBinaryTree();
        LinkedList linkedList = new LinkedList(Arrays.asList(3, 2, 9, null, null, 10, null, null, 8, null, 4));
        TreeNode treeNode = myBinaryTree.createTreeNode(linkedList);
        myBinaryTree.preOrderTraversal(treeNode);
        System.out.println();
        myBinaryTree.inOrderTraversal(treeNode);
        System.out.println();
        myBinaryTree.postOrderTraversal(treeNode);
        System.out.println();
        myBinaryTree.levelOrderTraversal(treeNode);
    }

    public TreeNode createTreeNode(LinkedList<Integer> linkedList) {
        //链表转二叉树，这里按照前序遍历的方式构建二叉树
        TreeNode treeNode = null;
        if (linkedList == null || linkedList.isEmpty()) {
            return null;
        }
        Integer data = linkedList.removeFirst();
        //3, 2, 9, null, null, 10, null, null, 8, null, 4
        if (data != null) {
            treeNode = new TreeNode(data);
            treeNode.left = createTreeNode(linkedList);
            treeNode.right = createTreeNode(linkedList);
        }

        return treeNode;
    }

    public void preOrderTraversal(TreeNode root) {
        //前序遍历 顶点、左孩子、右孩子
        //遍历顺序就是入栈顺序
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = root;
        while (treeNode != null || !stack.isEmpty()) {
            while (treeNode != null) {
                System.out.print(treeNode.data + " ");
                stack.push(treeNode);
                treeNode = treeNode.left;
            }

            if (!stack.isEmpty()) {
                treeNode = stack.pop();
                treeNode = treeNode.right;
            }
        }
    }

    public void inOrderTraversal(TreeNode root) {
        //中序遍历 左孩子、顶点、右孩子
        //遍历顺序就是出栈顺序
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = root;
        while (treeNode != null || !stack.isEmpty()) {
            while (treeNode != null) {
                stack.push(treeNode);
                treeNode = treeNode.left;
            }

            if (!stack.isEmpty()) {
                treeNode = stack.pop();
                System.out.print(treeNode.data + " ");
                treeNode = treeNode.right;
            }
        }
    }

    public void postOrderTraversal(TreeNode root) {
        //后序遍历 左孩子、右孩子、顶点
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = root;
        //记录最后一次被访问的节点
        TreeNode preNode = null;

        while (treeNode != null || !stack.isEmpty()) {
            while (treeNode != null) {
                //找到左侧节点并入栈
                stack.push(treeNode);
                treeNode = treeNode.left;
            }

            if (!stack.isEmpty()) {
                treeNode = stack.peek();
                if (treeNode.right == null || treeNode.right == preNode) {
                    //当前节点的右侧节点不存在或者右侧节点被访问过
                    treeNode = stack.pop();
                    System.out.print(treeNode.data + " ");
                    //记录最后一次被访问的节点
                    preNode = treeNode;
                    //继续回溯
                    treeNode = null;
                } else {
                    //右侧节点存在则先访问右侧节点
                    treeNode = treeNode.right;
                }
            }
        }
    }

    public void levelOrderTraversal(TreeNode root) {
        //层序遍历,使用到了队列辅助
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            System.out.print(node.data + " ");
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }
}