Java算法将顺序存储的二叉树转换为抽象对象存储的二叉树

代码如下：

package com.test.pub;

public class TreeNode {

    private Integer val;
    private TreeNode left;
    private TreeNode right;

    public Integer getVal() {
        return val;
    }

    public void setVal(Integer val) {
        this.val = val;
    }

    public TreeNode getLeft() {
        return left;
    }

    public void setLeft(TreeNode left) {
        this.left = left;
    }

    public TreeNode getRight() {
        return right;
    }

    public void setRight(TreeNode right) {
        this.right = right;
    }

    public TreeNode(Integer val) {
        this.val = val;
    }

    public TreeNode() {
        this.val = val;
    }
}

package com.test;

import com.test.pub.TreeNode;

public class TreeStoreTest {

    public static void main(String[] args) {

        // 顺序存储的树
        Integer[] treeArr = new Integer[]{5, 3, 1, null, 7, 9, null, null, null, 3, 1, 15, 17, null, null};
        // 抽象对象存储的树
        TreeNode root = treeArrToTreeRoot(treeArr);
//        System.out.println(root.getLeft().getRight().getVal());
//        System.out.println(root.getRight().getLeft().getLeft().getVal());
//        System.out.println(root.getRight().getRight().getRight().getVal());
        showTreeRec(root);

        System.out.println("-------------------------------------------------");

        Integer[] treeArr2 = new Integer[]{5};
        TreeNode root2 = treeArrToTreeRoot(treeArr2);
        showTreeRec(root2);

    }

    // 深度优先遍历
    public static void showTreeRec(TreeNode node) {

        System.out.println(node.getVal());
        if (node.getLeft() != null) {
            showTreeRec(node.getLeft());
        }
        if (node.getRight() != null) {
            showTreeRec(node.getRight());
        }
        return;
    }

    public static TreeNode treeArrToTreeRoot(Integer[] treeArr) {

        return treeArrToTreeRootHelper(treeArr, 1, new TreeNode());
    }

    // i为节点在树节点数组的序号
    public static TreeNode treeArrToTreeRootHelper(Integer[] treeArr, int i, TreeNode node) {

        node.setVal(treeArr[i-1]);
        // 检测左边节点是否在树节点数组中有值
        if (i*2 <= treeArr.length) {
            node.setLeft(new TreeNode(treeArr[i*2-1]));
        }
        // 检测右边节点是否在树节点数组中有值
        if (i*2+1 <= treeArr.length) {
            node.setRight(new TreeNode(treeArr[i*2]));
        }

        if (node.getLeft() != null) {
            // 创建左下节点
            treeArrToTreeRootHelper(treeArr, i * 2, node.getLeft());
        }
        if (node.getRight() != null) {
            // 创建右下节点
            treeArrToTreeRootHelper(treeArr, i * 2 + 1, node.getRight());
        }

        return node;
    }
}

运行结果(粗糙了点哈)：