108、有序陣列轉換為二叉搜尋樹

基本思想：

尋找切割點，分割點為當前節點，然後遞迴左區間和右區間

具體實現：

1、確定返回值以及引數

返回值：需要用遞迴的返回值來構造節點的左右孩子

引數：傳入陣列，左下標和右下標用來運算元組

定義左閉右閉區間，分割過程也堅持左閉右閉

2、遞迴終止條件

區間left>right的時候，是空節點

3、單層遞迴邏輯

（1）取了中間位置int mid = left + (right - left) / 2;

開始以中間位置的元素構造節點TreeNode root = new TreeNode(nums[mid]);

（2）接著劃分區間，root的左孩子接住下一層左區間的構造節點，右孩子接觸下一層右孩子構造的節點

（3）最後返回root節點

程式碼：

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        TreeNode root = traversal(nums, 0, nums.length - 1);
        return root;
    }

    // 左閉右閉區間[left, right)
    private TreeNode traversal(int[] nums, int left, int right) {
        if (left > right) return
 
 null;

        int mid = left + ((right - left) / 2);
        TreeNode root = new TreeNode(nums[mid]);
        root.left = traversal(nums, left, mid - 1);
        root.right = traversal(nums, mid + 1, right);
        return root;
    }

迭代

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        
 
if (nums.length == 0) return null;

        //根節點初始化
        TreeNode root = new TreeNode(-1);
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        Queue<Integer> leftQueue = new LinkedList<>();
        Queue<Integer> rightQueue = new LinkedList<>();

        // 根節點入佇列
        nodeQueue.offer(root);
        // 0為左區間下表初始位置
        leftQueue.offer(0);
        // nums.size() - 1為右區間下表初始位置
        rightQueue.offer(nums.length - 1);

        while (!nodeQueue.isEmpty()) {
            TreeNode currNode = nodeQueue.poll();
            int left = leftQueue.poll();
            int right = rightQueue.poll();
            int mid = left + ((right - left) >> 1);

            // 將mid對應的元素給中間節點
            currNode.val = nums[mid];

            // 處理左區間
            if (left <= mid - 1) {
                currNode.left = new TreeNode(-1);
                nodeQueue.offer(currNode.left);
                leftQueue.offer(left);
                rightQueue.offer(mid - 1);
            }

            // 處理右區間
            if (right >= mid + 1) {
                currNode.right = new TreeNode(-1);
                nodeQueue.offer(currNode.right);
                leftQueue.offer(mid + 1);
                rightQueue.offer(right);
            }
        }
        return root;
    }
}