【博乐科技笔试题】通过二叉搜索树的后序遍历输出其先序遍历

public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode() {}
    public TreeNode(int val) { this.val = val; }
    public TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

public static void main(String[] args) {
    int[] xx=printResult(new int[]{3,6,5,9,8,11,13,12,10});
    for (int x:xx) {
        System.out.print(x+",");
    }
}

//根据二叉搜索树的后序遍历，输出其先序遍历
public static int[] printResult (int[] arr) {
    // write code here
    int[] hx=new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        hx[i]=arr[i];
    }
    Arrays.sort(arr);//arr变成中序遍历了
    TreeNode root=build(arr,hx);
    List<List<Integer>> re=traverseByLevel.levelTraverse2(root);
    int[] xx=new int[arr.length];
    int i=0;
    for (List<Integer> l:re) {
        for (int n:l) {
            xx[i++]=n;
        }
    }
    return xx;
}

//根据后序遍历和中序遍历构造二叉树
public static TreeNode build(int[] zx,int[] hx){
    if (zx.length<=1){
        TreeNode re=new TreeNode();
        re.val=zx[0];
        return zx.length==0?null:re;
    }
    int len=zx.length;
    TreeNode root=new TreeNode();
    root.val=hx[len-1];
    int mid=0;//得到根节点在中序数组中的位置
    for (int i = 0; i < len; i++) {
        if (zx[i]==hx[len-1]){
            mid=i;
        }
    }
    int[] zxleft=new int[mid];
    int[] hxleft=new int[mid];
    for (int i = 0; i < mid; i++) {
        zxleft[i]=zx[i];
        hxleft[i]=hx[i];
    }
    int[] zxright=new int[len-mid-1];
    int[] hxright=new int[len-mid-1];
    for (int i = mid+1; i < len; i++) {
        zxright[i-mid-1]=zx[i];
        hxright[i-mid-1]=hx[i-1];
    }
    root.left=build(zxleft,hxleft);
    root.right=build(zxright,hxright);
    return root;
}

static List<List<Integer>> res = new LinkedList<>();

//递归实现二叉树的层序遍历
public static List<List<Integer>> levelTraverse2(TreeNode root) {
    if (root==null){
        return null;
    }
    List<TreeNode> levelNodes=new LinkedList<>();
    levelNodes.add(root);//第一层
    traverse(levelNodes);
    return res;
}
private static void traverse(List<TreeNode> levelNodes){
    if (levelNodes.isEmpty()){
        return;
    }
    //存储当前层的节点的值
    List<Integer> nodesValue=new LinkedList<>();
    //下一层的节点列表
    List<TreeNode> nextLevelNodes=new LinkedList<>();
    for (TreeNode n:levelNodes) {
        nodesValue.add(n.val);
        if (n.left!=null){
            nextLevelNodes.add(n.left);
        }
        if (n.right!=null){
            nextLevelNodes.add(n.right);
        }
    }
    // 前序位置添加结果，可以得到自顶向下的层序遍历
    res.add(nodesValue);
    traverse(nextLevelNodes);
    // 后序位置添加结果，可以得到自底向上的层序遍历结果
    // res.add(nodesValue);
}