力扣LeetCode #109 有序链表转换二叉搜索树（SortedListToBST）

- 题目描述

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

来源：LeetCode

- 示例

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

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

       0
     /   \
   -3   9
  /     /
-10   5

- 思路分析

• 方法1：类似于二分查找，先找出当前链表的中间节点作为根节点，然后再二分，递归查找左边的根节点和右边的根节点即可。代码见下面。
• 方法2：用两个指针，快指针和慢指针，当快指针走两步时，慢指针走一步，这样当快指针走到结尾时，慢指针指的就是中间节点。

- 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) {
        int length = 0;
        if(head == null) return null;
        ListNode saveH = head;
        while(head != null) {
            length++;
            head = head.next;
        }  //求出链表的长度
        return bs(saveH, length);   
    }

    public TreeNode bs(ListNode saveH, int length) {
    	//base case
        if(length == 0) return null;
        if(length == 1) return new TreeNode(saveH.val);
        ListNode head1 = saveH;  //保存前半段链表的头节点
        ListNode head2; //保存后半段链表的头节点
        TreeNode root = new TreeNode();   //当前链表转化的二叉搜索树的根节点，即链表的中间节点
        int mid = length%2 == 0 ? length/2 : length/2+1;  //为了保证平衡性，当长度为奇数时，mid = length/2+1;
        int count = 1;
        while(count != mid && saveH != null) {
            saveH = saveH.next;
            count++;
        }   //此时saveH指向中间的节点
        root.val = saveH.val;
        head2 = saveH.next;  //后半段链表的头节点是中间节点的下一个
        root.left = bs(head1, count-1);  //递归得到左子树
        root.right = bs(head2, length - mid);  //递归得到右子树
        return root;
    }
}