leetcode中的数组是怎么转成二叉树的？

在Leetcode中，经常有数组表示的二叉树。一般来讲，二叉树节点的数组下标，应该满足：

cur=n  //当前节点的下标是n
left=2n+1  //左子树的下标是2n+1
right=2n+2 //右子树的下标是2n+2

但是leetcode中的表示方法，并不符合上面的规律。例如：
94题：二叉树的中序遍历 的示例1：

数字2的下标是2，按照left=2n+1，数字2的左子树的下标应该是5，但是很明显，给出的数组总共才4个元素。这个示例在多道题目中，重复出现。

Leetcode官方给出了一篇说明：LeetCode 序列化二叉树的格式。

现在的关键问题是，怎么通过Integer数组[1,null,2,3]得到上图所示的二叉树了？

上代码，每行的注释写的很清楚了。

    public static TreeNode arrayToTreeNode(Integer[] array) {
        if (array.length == 0) { //为0，返回空
            return null;
        }
        TreeNode root = new TreeNode(array[0]); //生成根节点
        Queue<TreeNode> queue = new LinkedList<>(); //新建队列
        queue.add(root); //根节点进入队列
        boolean isLeft = true;
        for (int i = 1; i < array.length; i++) { //i从1开始，第1个元素是左子树
            TreeNode node = queue.peek(); //取出队列最前面那个节点
            if (isLeft) { //添加左子树
                if (array[i] != null) { //如果是null，什么也不做
                    node.left = new TreeNode(array[i]); //根节点的左子树
                    queue.offer(node.left); //进入队列
                }
                isLeft = false; //下一轮循环处理右子树
            } else { //添加右子树
                if (array[i] != null) { //如果是null，什么也不做
                    node.right = new TreeNode(array[i]);
                    queue.offer(node.right);
                }
                queue.poll(); //右子树添加完成之后，说明当前节点已经添加完毕，可以移除队列了
                isLeft = true;
            }
        }
        return root;
    }

完整测试代码：

import java.util.LinkedList;
import java.util.Queue;

public class ArrayToBinaryTree {
    static 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;
        }
    }

    public static void main(String[] args) {
        Integer[] array = {1,null,2, 3};
//        Integer[] array = {1, 2,3,null,4,null,null,5,6,null,7};
        show(arrayToTreeNode(array));
    }


    public static TreeNode arrayToTreeNode(Integer[] array) {
        if (array.length == 0) { //为0，返回空
            return null;
        }
        TreeNode root = new TreeNode(array[0]); //生成根节点
        Queue<TreeNode> queue = new LinkedList<>(); //新建队列
        queue.add(root); //根节点进入队列
        boolean isLeft = true;
        for (int i = 1; i < array.length; i++) { //i从1开始，第1个元素是左子树
            TreeNode node = queue.peek(); //取出队列最前面那个节点
            if (isLeft) { //添加左子树
                if (array[i] != null) { //如果是null，什么也不做
                    node.left = new TreeNode(array[i]); //根节点的左子树
                    queue.offer(node.left); //进入队列
                }
                isLeft = false; //下一轮循环处理右子树
            } else { //添加右子树
                if (array[i] != null) { //如果是null，什么也不做
                    node.right = new TreeNode(array[i]);
                    queue.offer(node.right);
                }
                queue.poll(); //右子树添加完成之后，说明当前节点已经添加完毕，可以移除队列了
                isLeft = true;
            }
        }
        return root;
    }


    // 用于获得树的层数
    private static int getTreeDepth(TreeNode root) {
        return root == null ? 0 : (1 + Math.max(getTreeDepth(root.left), getTreeDepth(root.right)));
    }

    private static void writeArray(TreeNode currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
        // 保证输入的树不为空
        if (currNode == null) return;
        // 先将当前节点保存到二维数组中
        res[rowIndex][columnIndex] = String.valueOf(currNode.val);

        // 计算当前位于树的第几层
        int currLevel = ((rowIndex + 1) / 2);
        // 若到了最后一层，则返回
        if (currLevel == treeDepth) return;
        // 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
        int gap = treeDepth - currLevel - 1;

        // 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
        if (currNode.left != null) {
            res[rowIndex + 1][columnIndex - gap] = "/";
            writeArray(currNode.left, rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
        }

        // 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
        if (currNode.right != null) {
            res[rowIndex + 1][columnIndex + gap] = "\\";
            writeArray(currNode.right, rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
        }
    }


    public static void show(TreeNode root) {
        if (root == null){
            System.out.println("EMPTY!");
            return;
        }
        // 得到树的深度
        int treeDepth = getTreeDepth(root);

        // 最后一行的宽度为2的（n - 1）次方乘3，再加1
        // 作为整个二维数组的宽度
        int arrayHeight = treeDepth * 2 - 1;
        int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
        // 用一个字符串数组来存储每个位置应显示的元素
        String[][] res = new String[arrayHeight][arrayWidth];
        // 对数组进行初始化，默认为一个空格
        for (int i = 0; i < arrayHeight; i++) {
            for (int j = 0; j < arrayWidth; j++) {
                res[i][j] = " ";
            }
        }

        // 从根节点开始，递归处理整个树
        // res[0][(arrayWidth + 1)/ 2] = (char)(root.val + '0');
        writeArray(root, 0, arrayWidth / 2, res, treeDepth);

        // 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
        for (String[] line : res) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < line.length; i++) {
                sb.append(line[i]);
                if (line[i].length() > 1 && i <= line.length - 1) {
                    i += line[i].length() > 4 ? 2 : line[i].length() - 1;
                }
            }
            System.out.println(sb.toString());
        }
    }
}

输入为[1,null,2,3]的时候，运行效果：

输入为[1, 2, 3,null, 4,null,null,5,6,null,7]，期望效果是：

实际运行效果：

完美！