【leetcode-二叉树遍历】将有序数组/链表转换为二叉搜索树

将有序数组转换为二叉搜索树

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。
高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。

示例 1：

输入：nums = [-10,-3,0,5,9]
输出：[0,-3,9,-10,null,5]

解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：

示例 2：

输入：nums = [1,3]
输出：[3,1]
解释：[1,3] 和 [3,1] 都是高度平衡二叉搜索树。

中序遍历

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

    public TreeNode sortedArrayToBST(int[] nums, int start, int end) {
        if (start > end)
            return null;
        int mid = (start + end) / 2;  // 中间位置左边的数字
        // int mid = (start + end + 1) / 2;  中间位置右边的数字
        return new TreeNode(nums[mid], sortedArrayToBST(nums, start, mid - 1), sortedArrayToBST(nums, mid + 1, end));
    }
}

将有序链表转换为二叉搜索树

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:
给定的有序链表： [-10, -3, 0, 5, 9],
一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：

将链表转换为数组

class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        List<Integer> nums = new ArrayList<>();
        while (head != null) {
            nums.add(head.val);
            head = head.next;
        }
        return sortedArrayToBST(nums, 0, nums.size() - 1);
    }

    public TreeNode sortedArrayToBST(List<Integer> nums, int start, int end) {
        if (start > end)
            return null;
        // int mid = (start + end) / 2;  // 中间位置左边的数字
        int mid = (start + end + 1) / 2; // 中间位置右边的数字
        return new TreeNode(nums.get(mid), sortedArrayToBST(nums, start, mid - 1), sortedArrayToBST(nums, mid + 1, end));
    }
}

快慢指针找中位数

class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        return sortedListToBST(head, null);
    }

    public TreeNode sortedListToBST(ListNode left, ListNode right) {
        if (left == right)
            return null;
        ListNode mid = getMedian(left, right);
        return new TreeNode(mid.val, sortedListToBST(left, mid), sortedListToBST(mid.next, right));
    }

    public ListNode getMedian(ListNode left, ListNode right) {
        ListNode fast = left;
        ListNode slow = left;
        while (fast != right && fast.next != right) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
}

中序遍历优化

class Solution {
    ListNode globalHead;
    public TreeNode sortedListToBST(ListNode head) {
        globalHead = head;
        int length = 0;
        while (head != null) {
            ++length;
            head = head.next;
        }
        return sortedListToBST(0, length - 1);
    }

    public TreeNode sortedListToBST(int left, int right) {
        if (left > right)
            return null;
        int mid = (left + right + 1) / 2;
        TreeNode root = new TreeNode();
        root.left = sortedListToBST(left, mid - 1);
        root.val = globalHead.val;
        globalHead = globalHead.next;
        root.right = sortedListToBST(mid + 1, right);
        return root;
    }
}