【LeetCode - Java】108. 将有序数组转换为二叉搜索树 （简单）

1. 题目描述

2. 解题思路

有序数组转换为二叉搜索树，且需要高度平衡，那么最好的一个切入点就是取数组的中间位置元素作为新建节点的值，如此递归下去便可以得到高度平衡的二叉搜索树。

还是那句话，递归有点简单不够过瘾，因此用迭代来整整看。相对递归而言迭代就比较麻烦了，同样需要使用广度优先搜索的概念逐层处理，这时候同样需要一个队列结构，先进先出，但要注意的是，需要存储的不仅仅是数组，还需要存储一个节点，不然我不知道我应该处理谁，这里也没办法像递归那样可以自然选择，因此还需要增加一个队列结构用于存储节点。另外因为一个数组对应一个节点，因此判断边界条件时候只需要任取其中一个队列长度判断即可。

3. 代码实现

3.1 递归

public TreeNode sortedArrayToBST(int[] nums) {
        if (nums.length == 0)
            return new TreeNode();
        int length = nums.length;
        int mid = length / 2;
        TreeNode treeNode = new TreeNode(nums[mid]);
        if (mid != 0) {
            int[] small = new int[length / 2];
            System.arraycopy(nums, 0, small, 0, mid);
            treeNode.left = sortedArrayToBST(small);
        }
        if (length - mid - 1 != 0) {
            int[] big = new int[length - mid - 1];
            System.arraycopy(nums, mid + 1, big, 0, length - mid - 1);
            treeNode.right = sortedArrayToBST(big);
        }
        return treeNode;
    }

这个代码的写法会导致内存消耗偏高的，因为需要多存储了几个数组，若采用新建一个函数用于迭代，只传递数组的地址和指针位置的写法内存消耗会有更好的表现，详细可以参照官解。

3.2 迭代

public TreeNode sortedArrayToBST(int[] nums) {
        TreeNode root = new TreeNode();
        LinkedList<int[]> integers = new LinkedList<>();
        LinkedList<TreeNode> treeNodes = new LinkedList<>();
        integers.add(nums);
        treeNodes.add(root);
        while (!integers.isEmpty()) {
            int size = integers.size();
            for (int i = 0; i < size; i++) {
                int[] num = integers.removeFirst();
                int length = num.length;
                if (length != 0) {
                    int mid = length / 2;
                    TreeNode treeNode = treeNodes.removeFirst();
                    treeNode.val = num[mid];
                    if (mid> 0) {
                        treeNode.left = new TreeNode();
                        treeNodes.add(treeNode.left);
                        int[] small = new int[mid];
                        System.arraycopy(num, 0, small, 0, mid);
                        integers.add(small);
                    }
                    if (length - mid - 1 > 0) {
                        treeNode.right = new TreeNode();
                        treeNodes.add(treeNode.right);
                        int[] big = new int[length - mid - 1];
                        System.arraycopy(num, mid + 1, big, 0, length - mid - 1);
                        integers.add(big);
                    }
                }
            }
        }
        return root;
    }

3.3 对比

无论是递归还是迭代，都需要对每一个节点进行处理，因此他们的时间复杂度都是O(n)，而在空间复杂度中，栈的高度其实是相当于对应二叉搜索树的深度的，即O(log n)，在迭代中，队列的长度取决于同一层当中的最大节点数，即约为n/2，此外需要两个队列用于存储，因此其空间复杂度应该是O(2*n/2)=O(n)。