[Leetcode]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.

/**
* Definition for singly-linked list.
* struct ListNode {
*     int val;
*     ListNode *next;
*     ListNode(int x) : val(x), next(NULL) {}
* };
*/
/**
* Definition for a binary tree node.
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
/*alorithm: divide and conquere
two pointer
1->2->3->4->5 //f:3,s = 5
1->2->3->4 //f:3 , s = 4
*/
TreeNode* sortedListToBST(ListNode* head) {
ListNode* first = head,*second = head;
ListNode* ftail = NULL;
while(second&&second->next){
second = second->next;
if(second->next)second = second->next;
ftail = first;
first = first->next;
}
TreeNode* root = NULL;
if(first){
root = new TreeNode(first->val);
if(ftail)ftail->next = NULL;
root->left = ftail == NULL?NULL:sortedListToBST(head);
root->right = sortedListToBST(first->next);
}
return root;
}
};

class Solution {
public:
int getCount(ListNode* head){
int count = 0;
while(head){
count++;
head = head->next;
}
return count;
}
//[start,end)
TreeNode* sortedListToBSTSub(ListNode* &head,int start,int end){
if(start >= end)return NULL;
int m = start + (end-start)/2;
TreeNode* l,*r,*root;
l = sortedListToBSTSub(head,start,m);
root = new TreeNode(head->val);
head = head->next;
r = sortedListToBSTSub(head,m+1,end);
root->left = l;
root->right = r;
return root;
}
TreeNode* sortedListToBST(ListNode* head) {
int n = getCount(head);
return sortedListToBSTSub(head,0,n);
}
};