力扣构建二叉树的算法

1、背景

        力扣相信大家都很熟悉，练习算法时大部分人都会选择该网站刷题。但是力扣的调试功能需要开通会员，为了方便调试，我写了一个算法用于构建二叉树，经多次测试，与力扣构建树的方法一致，如下：

public class TreeNode {
    public TreeNode left;
    public TreeNode right;
    public Integer val;
    public TreeNode() {
        
    }
    public TreeNode(int val) {
        this.val = val;
    }
   /**
     * 构造树
     * @param nums 树节点列表
     * @return 树的根节点
     */
    public static TreeNode makeTree(Integer[] nums) {
        if (nums.length == 0 || nums[0] == null) {
            return null;
        }
        TreeNode root = new TreeNode(nums[0]);
        TreeNode cur;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int j = 1;
        while(!queue.isEmpty() && j < nums.length) {
            int size = queue.size();
            for(int i = 0; i < size; i++) {
                cur = queue.poll();
                if(j < nums.length && nums[j] != null) {
                    cur.left = new TreeNode(nums[j]);
                    queue.offer(cur.left);
                }
                j++;
                if(j < nums.length && nums[j] != null) {
                    cur.right = new TreeNode(nums[j]);
                    queue.offer(cur.right);
                }
                j++;
            }
        }
        return root;
    }
｝

2、算法的问题

        这个算法可以应对力扣中的树用例的，但是今天在刷题时却发现了这个算法似乎没有办法准确构建所有树，刷的题目是：剑指 Offer 37. 序列化二叉树

        题解如下：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if (root != null) {
            queue.offer(root);
        }
        StringBuffer s = new StringBuffer();
        while (!queue.isEmpty()) {
            root = queue.poll();
            if (root != null) {
                s.append(root.val);
                s.append(',');
                queue.offer(root.left);
                queue.offer(root.right);
            }else {
                s.append(" ,");
            }
        }
        return s.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data.length() == 0) {
            return null;
        }
        String[] ss = data.split(",");
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode root = new TreeNode(Integer.valueOf(ss[0]));
        queue.offer(root);
        TreeNode cur;
        int i = 0;
        while (!queue.isEmpty()) {
            for (int j = queue.size(); j > 0; j--) {
                cur = queue.poll();
                int child = i * 2 + 1;
                if (!" ".equals(ss[child])) {
                    cur.left = new TreeNode(Integer.valueOf(ss[child]));
                    queue.offer(cur.left);
                }
                if (!" ".equals(ss[++child])) {
                    cur.right = new TreeNode(Integer.valueOf(ss[child]));
                    queue.offer(cur.right);
                }
                ++i;
            }
        }
        return root;
    }
}

// Your Codec object will be instantiated and called as such:
// Codec codec = new Codec();
// codec.deserialize(codec.serialize(root));

测试是可以通过的 

但是这里有一个问题，代码中用于确定节点在数组中下标的变量是i，可以通过该下标运算获取当前节点的左右节点在数组中的位置，问题就出在这个i身上，i是向右移动一个单位，倘若i移动后指向的是一个空节点呢？具体如下：

树：[1,null,2,null,null,4,5]

按照规则，该数组所形成的树应该如下：

 这样的话，在获取节点2的子节点时，i = 1，获取到的将会是下标为3和4两个节点，但这两个节点在数组中为空，此时由于队列为空，跳出循环，那么4和5两个节点呢？使用力扣可视化工具，发现力扣构建的树如下：

少了两个节点，怪不得能通过所有用例，用博主构建树的算法也是得到上面的树，这样的话，上面构建树的算法应对力扣的用例是没有问题，但是如果要用于构建上面的例子树，那么就会出现问题。

难道力扣的构建算法就这么不合理吗？当然不是！影响树生成的，除了算法以外，那就是用例了。

显然是输入的用例格式出现了问题，将用例改成这个形式：[1,null,3,4,5]

树就正常构建出来了！

 这说明力扣的测试用例对于为空的节点的子节点是不进行输入的，空节点的子节点的位置由后续节点补上！