二叉树的遍历

二叉树的遍历

public class TreeNode {
    Integer value;
    TreeNode leftChild;
    TreeNode rightChild;

    public TreeNode(Integer data) {
        this.value = data;
    }

    /**
     * 构建二叉树
     */
    public static TreeNode createBinaryTree(LinkedList<Integer> inputList) {
        TreeNode node = null;
        if (inputList == null || inputList.isEmpty()) {
            return null;
        }
        Integer data = inputList.removeFirst();
        if (data != null) {
            node = new TreeNode(data);
            node.leftChild = createBinaryTree(inputList);
            node.rightChild = createBinaryTree(inputList);
        }
        return node;
    }

    /**
     * 先序遍历
     */
    public static void preOrderTraver(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.println(node.value);
        preOrderTraver(node.leftChild);
        preOrderTraver(node.rightChild);
    }

    /**
     * 先序遍历（迭代）
     * 出栈顺序是迭代
     */
    public static void preOrderTraverIt(TreeNode node) {
        if (node == null) {
            return;
        }
        LinkedList<TreeNode> linkedList = new LinkedList<>();
        linkedList.push(node);
        while (!linkedList.isEmpty()) {
            node = linkedList.poll();
            System.out.println(node.value);
            if (node.rightChild != null) {
                linkedList.push(node.rightChild);
            }
            if (node.leftChild != null) {
                linkedList.push(node.leftChild);
            }
        }

    }


    /**
     * 先序遍历
     * 入栈顺序是迭代
     */
    public static void preOrderTraveralWithStack(TreeNode root) {
        if (root == null) {
            return;
        }

        TreeNode node = root;
        LinkedList<TreeNode> linkedList = new LinkedList<>();
        while (node != null || !linkedList.isEmpty()) {
            while (node != null) {
                System.out.println(node.value);
                linkedList.push(node);
                node = node.leftChild;
            }

            if (!linkedList.isEmpty()) {
                node = linkedList.poll();
                node = node.rightChild;
            }

        }
    }


    /**
     * 中序遍历
     */
    public static void inOrderTraver(TreeNode node) {
        if (node == null) {
            return;
        }
        inOrderTraver(node.leftChild);
        System.out.println(node.value);
        inOrderTraver(node.rightChild);
    }

    /**
     * 中序遍历（迭代）
     * 出栈顺序是迭代
     */
    public static void inOrderTraverIt(TreeNode node) {
        if (node == null) {
            return;
        }

        LinkedList<TreeNode> linkedList = new LinkedList<>();
        while (node != null || !linkedList.isEmpty()) {
            while (node != null) {
                linkedList.push(node);
                node = node.leftChild;
            }

            if (!linkedList.isEmpty()) {
                node = linkedList.poll();
                System.out.println(node.value);
                node = node.rightChild;
            }
        }

    }

    /**
     * 后续遍历
     */
    public static void postOrderTraver(TreeNode node) {
        if (node == null) {
            return;
        }
        postOrderTraver(node.leftChild);
        postOrderTraver(node.rightChild);
        System.out.println(node.value);
    }


    /**
     * 后续遍历迭代
     * 双栈
     */
    public static void postOrderTraverIt(TreeNode node) {
        if (node == null) {
            return;
        }

        LinkedList<TreeNode> linkedList = new LinkedList<>();
        LinkedList<TreeNode> retLinkedList = new LinkedList<>();
        linkedList.push(node);

        while (!linkedList.isEmpty()) {
            node = linkedList.poll();
            retLinkedList.push(node);
            if (node.leftChild != null) {
                linkedList.push(node.leftChild);
            }
            if (node.rightChild != null) {
                linkedList.push(node.rightChild);
            }
        }

        while (!retLinkedList.isEmpty()) {
            System.out.println(retLinkedList.pop().value);
        }
    }
    /**
     * 层序遍历
     */
    public static void  levelOrderTraversal() {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            root = queue.poll();
            System.out.println(root.value);
            if (root.leftChild != null) {
                queue.offer(root.leftChild);
            }
            if (root.rightChild != null) {
                queue.offer(root.rightChild);
            }
        }
    }
    /**
     * 后序遍历迭代
     * 单栈
     */
    public static void postOrderTraverIt2(TreeNode node) {
        if (node == null) {
            return;
        }

        TreeNode curr = node;
        TreeNode lastVisit = node;
        LinkedList<TreeNode> linkedList = new LinkedList<>();
        while (curr != null || !linkedList.isEmpty()) {
            if (curr != null) {
                linkedList.push(curr);
                curr = curr.leftChild;
            } else {
                TreeNode peekNode = linkedList.peek();
                if (peekNode.rightChild != null && peekNode.rightChild != lastVisit) {
                    linkedList.push(peekNode.rightChild);
                } else {
                    TreeNode popNode = linkedList.pop();
                    System.out.println(popNode.value);
                    lastVisit = popNode;
                }
            }
        }
    }



     /**
     * 层序遍历
     */
    public static void  levelOrderTraversal(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            root = queue.poll();
            System.out.println(root.value);
            if (root.leftChild != null) {
                queue.offer(root.leftChild);
            }
            if (root.rightChild != null) {
                queue.offer(root.rightChild);
            }
        }
    }


    public static void main(String[] args) {
        LinkedList<Integer> inputList = new LinkedList<>(Arrays.
                asList(new Integer[]{3, 2, 9, null, null, 10, null, null, 8, null, 4}));

        TreeNode treeNode = createBinaryTree(inputList);

        System.out.println("前序遍历: ");
//        preOrderTraver(treeNode);
        System.out.println("前序遍历迭代: ");
        preOrderTraveralWithStack(treeNode);

        System.out.println("中序遍历：");
        inOrderTraver(treeNode);
        System.out.println("中序遍历：");
        inOrderTraverIt(treeNode);

        System.out.println("后序遍历：");
        postOrderTraver(treeNode);
        System.out.println("后序遍历迭代");
        postOrderTraverIt2(treeNode);

        System.out.println("层序遍历：");
        levelOrderTraversal(treeNode);
    }
}