将整数数组转换为二叉树答案

【问题标题】：convert integer array into a binary tree将整数数组转换为二叉树
【发布时间】：2014-11-12 16:26:28
【问题描述】：

我已经可以在 java 中使用以下算法将数组转换为二叉树：

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

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

public TreeNode arrayToTree(Integer[] input){
    TreeNode root = createTreeNode(input,1);
    return root;
}

private TreeNode createTreeNode(Integer[] input, int index){
    if(index<=input.length){
        Integer value = input[index-1];
        if(value!=null){
            TreeNode t = new TreeNode(value);
            t.left = createTreeNode(input, index*2);
            t.right = createTreeNode(input, index*2+1);
            return t;
        }
    }
    return null;
}

当输入为 {1,null,2,null,null,3} 时，我得到以下树：

但是我认为输入 {1,null,2,3} 足够清晰，可以定义像上面这样的树。

有什么好主意可以避免输入数组中定义的冗余 nulls？

【问题讨论】：

一定要用递归吗？
空值不是冗余的。如果你不指定树的形状和缺失的节点，没有程序可以猜到它们。
@Herokiller，即使没有递归也欢迎任何更好的想法。
@user1146450 然后你可以使用队列添加树节点
@YvesDaoust 当父级为NULL 时它们是多余的。有一些编码使用了这个事实。

标签： java algorithm binary-tree

【解决方案1】：

这是一个 java-monster，它通过调试的可能性解决了任务


import java.util.*;

public class TreeCreator {

    public static void main(String[] args) {
        Integer[] tree = new Integer[]{1, null, 2, 3};
        TreeCreator tr = new TreeCreator();
        TreeNode treeNode = tr.fromArray(tree);
        List<Integer> list = tr.postorderTraversal(treeNode);
        list.forEach(System.out::println); // postOrder is 3 2 1

    }

    public TreeNode fromArray(Integer[] tree) {
        if (tree.length == 0) return null;
        TreeNode root = new TreeNode(tree[0]);
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        for (int i = 1; i < tree.length; i++) {
            TreeNode node = q.peek();
            if (node.left == null) {
                node.left = new TreeNode(tree[i]);
                if (tree[i] != null) q.add(node.left);
            } else if (node.right == null) {
                node.right = new TreeNode(tree[i]);
                if (tree[i] != null) q.add(node.right);
                q.remove();
            }
        }
        return root;
    }

    private static class TreeNode {
        Integer val;
        TreeNode left;
        TreeNode right;

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

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> l = new ArrayList<>();
        if (root == null) return l;
        funcPostOrder(root, l);
        return l;
    }

    private void funcPostOrder(TreeNode c, List<Integer> l) {
        if (c.left != null && c.left.val != null) {
            funcPostOrder(c.left, l);
        }
        if (c.right != null) {
            funcPostOrder(c.right, l);
        }
        l.add(c.val);
    }
}

更有趣的例子是

Integer[] tree = new Integer[]{5,4,8,11,null,13,4,7,2,null,null,null,1};

【讨论】：

这是不正确的，使用 {1, null,2, 3} 在 fromArray 中给出空指针异常

【解决方案2】：

如果你按顺序阅读这棵树，你会发现1, -, 2, 3, -。只需使用相同的顺序构造树，而不是在index*2 和index*2+1 处查找字符串，而是从左到右查找。（如果你愿意，你可以丢弃最后的空值）。

对于更“复杂”的示例：

       1
     /   \
   2       3
    \     / \
     4   5   6
          7   8

1, 2, -, 4, 3, 5, -, 7, 6, -, 8

【讨论】：

【解决方案3】：

这应该可以解决问题。

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

TreeNode() {
}

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

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

static TreeNode arrayToTree(Integer array[]) {
    return arrayToTree(array, 0);
}

static TreeNode arrayToTree(Integer array[], int index) {
    if (index >= array.length)
        return null;
    if (array[index] == null)
        return null;
    return new TreeNode(array[index], arrayToTree(array, index * 2 + 1), arrayToTree(array, index * 2 + 2));
}

【讨论】：