109. Convert Sorted List to Binary Search Tree

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Example:

Given the sorted linked list: [-10,-3,0,5,9],

One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

      0
     / \
   -3   9
   /   /
 -10  5

/**
* Definition for singly-linked list.
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode(int x) { val = x; }
* }
*/
/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/

class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        if(head==null)
            return null;

        List<TreeNode> treeNodeList = new ArrayList<>();
        while(head!=null){
            treeNodeList.add(new TreeNode(head.val));
            head = head.next;
        }
        return sortListToBSTHelper(treeNodeList,0,treeNodeList.size()-1);
    }

    public TreeNode sortListToBSTHelper(List<TreeNode> list, int from,int end){
        if(end==from)
            return list.get(end);
        else if(end<from)
            return null;
            
        int middle = from+ ((end-from)>>1);
        
        TreeNode leftTree = sortListToBSTHelper(list, from, middle-1);
        TreeNode rightTree = sortListToBSTHelper(list, middle+1, end);

        list.get(middle).left =  leftTree;
        list.get(middle).right =  rightTree;

        return list.get(middle);
    }

}

递归循环，最好排除middle点处理，这样思路清晰。

因为是排好序的链表，从中间取根节点能保证平衡二叉搜索树。