/**********************二叉樹*************************/

    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }

    /**
     * 前 中 后序遍歷
     *
     * @param node
     */
    public void preOrder(TreeNode node) {
        if (node != null) {
            System.out.println(node.val);
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    public static void preOrder2(TreeNode biTree) {//非遞歸實現
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (biTree != null || !stack.isEmpty()) {
            while (biTree != null) {
                System.out.println(biTree.val);
                stack.push(biTree);
                biTree = biTree.left;
            }
            if (!stack.isEmpty()) {
                biTree = stack.pop();
                biTree = biTree.right;
            }
        }
    }

    public static void midOrder(TreeNode node) {
        if (node != null) {
            midOrder(node.left);
            System.out.println(node.val);
            midOrder(node.right);
        }
    }

    /**
     * 中序遍歷非遞歸實現
     *
     * @param biTree
     */
    public static void midOrder2(TreeNode biTree) {
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (biTree != null || !stack.isEmpty()) {
            while (biTree != null) {
                stack.push(biTree);
                biTree = biTree.left;
            }
            if (!stack.isEmpty()) {
                biTree = stack.pop();
                System.out.println(biTree.val);
                biTree = biTree.right;
            }
        }
    }

    public void afterOrder(TreeNode node) {
        if (node != null) {
            afterOrder(node.left);
            afterOrder(node.right);
            System.out.println(node.val);
        }
    }

    /**
     * 后序遍歷非遞歸實現
     *
     * @param biTree
     */
    public static void postOrder2(TreeNode biTree) {
        int left = 1;//在輔助棧里表示左節點
        int right = 2;//在輔助棧里表示右節點
        Stack<TreeNode> stack = new Stack<TreeNode>();
        Stack<Integer> stack2 = new Stack<Integer>();//輔助棧，用來判斷子節點返回父節點時處于左節點還是右節點。

        while (biTree != null || !stack.empty()) {
            while (biTree != null) {//將節點壓入棧1，并在棧2將節點標記為左節點
                stack.push(biTree);
                stack2.push(left);
                biTree = biTree.left;
            }

            while (!stack.empty() && stack2.peek() == right) {//如果是從右子節點返回父節點，則任務完成，將兩個棧的棧頂彈出
                stack2.pop();
                System.out.println(stack.pop().val);
            }

            if (!stack.empty() && stack2.peek() == left) {//如果是從左子節點返回父節點，則將標記改為右子節點
                stack2.pop();
                stack2.push(right);
                biTree = stack.peek().right;
            }

        }
    }

    /**
     * 右試圖，層序遍歷，size問題
     *
     * @param root
     * @return
     */
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (null == root) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode cur = queue.poll();
                if (i == (size - 1)) {
                    res.add(cur.val);
                }
                if (cur.left != null) {
                    queue.add(cur.left);
                }

                if (cur.right != null) {
                    queue.add(cur.right);
                }
            }
        }

        return res;
    }

    /**
     * 以數組形式生成一棵完全二叉樹
     */
    public static void createTree() {
        TreeNode[] node = new TreeNode[10];
        for (int i = 0; i < 10; i++) {
            node[i] = new TreeNode(i);
        }
        for (int i = 0; i < 10; i++) {
            if (i * 2 + 1 < 10)
                node[i].left = node[i * 2 + 1];
            if (i * 2 + 2 < 10)
                node[i].right = node[i * 2 + 2];
        }

        for (int i = 0; i < 10; i++) {
            System.out.println(node[i].val);
        }
    }