Leetcode-Convert Sorted List to BST.

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

Solution:

 /**
  * Definition for singly-linked list.
  * public class ListNode {
  *     int val;
  *     ListNode next;
  *     ListNode(int x) { val = x; next = null; }
  * }
  */
 /**
  * Definition for binary tree
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public TreeNode sortedListToBST(ListNode head) {
         if (head==null)
             return null;

         ListNode end = head;
         while (end.next!=null){
             end = end.next;
         }
         TreeNode root = sortedListToBSTRecur(head,end);

         return root;
     }

     //Convert the list from head to end into BST, return the root node
     public TreeNode sortedListToBSTRecur(ListNode head, ListNode end){
         //If only one node.
         if (head==end){
             TreeNode root = new TreeNode(head.val);
             return root;
         }

         //If only two node.
         if (head.next==end){
             TreeNode root = new TreeNode(head.val);
             TreeNode child = new TreeNode(end.val);
             root.right = child;
             return root;
         }

         //Otherwise, count the number of node in the list, find out the median one,
         //and convert the left list and right list to BST.
         int nodeNum = 1;
         ListNode curNode = head;
         while (curNode!=end){
             curNode = curNode.next;
             nodeNum++;
         }
         int mid = nodeNum/2+nodeNum%2;
         ListNode median = null;
         ListNode pre = null;
         curNode = head;
         //NOTE: we only need to move (mid-1) steps to move curNode to the median one.
         for (int i=0;i<mid-1;i++){
             pre = curNode;
             curNode = curNode.next;
         }
         median = curNode;
         TreeNode root = new TreeNode(median.val);
         TreeNode leftChild = sortedListToBSTRecur(head,pre);
         TreeNode rightChild = sortedListToBSTRecur(median.next,end);
         root.left = leftChild;
         root.right = rightChild;
         return root;
     }
 }

For a list from head to end, we find out the median node and use recursion method to convert its left list and right list to BST, and then connect the left subtree and right subtree to the median node.