二叉树创建+遍历 java基础

// An highlighted block
package mavenTest;


import java.util.Arrays;
import java.util.LinkedList;
import java.util.Stack;

public class Tree {

    public static void main(String[] args) {
        LinkedList<Integer> inputList = new LinkedList<>(Arrays.asList(new Integer[]{3, 2, 7, null, null, 10, null, null, 8, null, 4}));
        TreeNode treeNode = createTree(inputList);
        System.out.println("前序遍历");
        preOrderTraveral(treeNode);
        System.out.println("中序遍历");
        inOrderTraveral(treeNode);
        System.out.println("后序遍历");
        postOrderTraveral(treeNode);
        System.out.println("非递归前序遍历");
        preOrderTraveralWithStack(treeNode);
    }

    /**
     * 创建
     *
     * @param inputList
     * @return
     */
    public static TreeNode createTree(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.leftChildren = createTree(inputList);
            node.rightChildren = createTree(inputList);
        }
        return node;
    }

    /**
     * entity
     */
    private static class TreeNode {
        int data;
        TreeNode leftChildren;
        TreeNode rightChildren;

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

    /**
     * 前序遍历s
     *
     * @param node
     */
    public static void preOrderTraveral(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.println(node.data);
        preOrderTraveral(node.leftChildren);
        preOrderTraveral(node.rightChildren);
    }

    /**
     * 中序遍历
     *
     * @param node
     */
    public static void inOrderTraveral(TreeNode node) {
        if (node == null) {
            return;
        }
        inOrderTraveral(node.leftChildren);
        System.out.println(node.data);
        inOrderTraveral(node.rightChildren);
    }

    /**
     * 后序遍历
     *
     * @param node
     */
    public static void postOrderTraveral(TreeNode node) {
        if (node == null) {
            return;
        }
        postOrderTraveral(node.leftChildren);
        postOrderTraveral(node.rightChildren);
        System.out.println(node.data);
    }

    /**
     * 二叉树非递归前序排列
     *
     * @param node
     */
    public static void preOrderTraveralWithStack(TreeNode node) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode treeNode = node;
        while (treeNode != null || !stack.isEmpty()) {
            while (treeNode != null) {
                System.out.println(treeNode.data);
                stack.push(treeNode);
                treeNode = treeNode.leftChildren;
            }
            if (!stack.isEmpty()) {
                treeNode = stack.pop();
                treeNode = treeNode.rightChildren;
            }
        }
    }
}