树 - 根据有序链表构造平衡的二叉查找树

1.题目

LeetCode: 109. 有序链表转换二叉搜索树

【medium】

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定的有序链表： [-10, -3, 0, 5, 9],

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

      0
     / \
   -3   9
   /   /
 -10  5

2.解题

方法一：递归法

由于我们需要构造一个平衡二叉搜索树，所以二叉树的左子树和右子树的节点个数应该最多相差1，所以根节点必须为链表的中间节点，当链表节点个数为奇数时，为中间节点，偶数时，中间唯二的节点均可作为中间节点。所以我们需要一个专门查找中间节点的函数getMid()，同时，为了递归方便，设置左端点为left，右端点为right，并且left为链表的首节点，right为链表尾节点的下一个节点即为null。

java:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        return toBST(head, null);
    }

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

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

时间复杂度：O(nlogn)，其中 n 是链表的长度。

设长度为 n 的链表构造二叉搜索树的时间为 T(n)，递推式为 T(n) = 2 T(n/2) + O(n)，根据主定理，T(n)=O(nlogn)。

空间复杂度：O(logn)，这里只计算除了返回答案之外的空间。平衡二叉树的高度为 O(logn)，即为递归过程中栈的最大深度，也就是需要的空间。

方法二：分治 + 优化的中序遍历

方法一中，由于每次新建一个节点都要查找中间节点，占用很大的时间复杂度，所以进行优化。由于单向链表是按从小到大的顺序排列的，而一个平衡二叉搜索树的中序遍历的结果即为链表的顺序，所以在递归构建二叉树的时候可以先暂时新建一个节点而不给它填充数字，等到遍历到该节点时再去填充。

java：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    ListNode globeHead;
    public TreeNode sortedListToBST(ListNode head) {
        globeHead = head;
        int length = 0;
        while (head != null) {
            length++;
            head = head.next;
        }
        return toBST(0, length - 1);
    }

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