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.

Analyse: the core idea of this problem is the same as Convert Sorted Array to Binary Search Tree. For a list, it's hard to access the elements randomly, we have to compute the list's length and sequencely locate a specific element. 

Trial 1: Construct a function s.t. for a given index, it returns find its corresponding ListNode.

NA: TIME LIMITED. 

/**
 * 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:
    TreeNode* sortedListToBST(ListNode* head) {
        if(!head) return NULL;
        
        int len = 0; //length of the list
        ListNode* move = head;
        while(move){
            move = move->next;
            len++;
        }
        return construct(head, 0, len - 1);
    }
    
    TreeNode* construct(ListNode* head, int low, int high){
        if(low > high) return NULL;
        
        int mid = (low + high) / 2;
        ListNode* targetListNode = nodeAtIndex(head, mid);
        TreeNode* root = new TreeNode(targetListNode->val);
        if(low == high) return root;
        
        root->left = construct(head, low, mid - 1);
        root->right = construct(head, mid + 1, high);
        
        return root;
    }
    
    ListNode* nodeAtIndex(ListNode* head, int index){
        if(index < 0 || !head) return NULL;
        
        ListNode* move = head;
        int count = 0; //index of the first node in the list is 0
        while(count != index){
            move = move->next;
            count++;
        }
        return move;
    }
};

I found a similiar solution in http://www.cnblogs.com/remlostime/archive/2012/10/29/2744805.html. But it improved the locating process. Thus it AC.

Trial 2: Then I wanna be opportunistic. I pushed every value in the list into a vector and tried to use the original code I wrote before. HAHAHA 

Runtime: 32ms. 

/**
 * 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:
    TreeNode* sortedListToBST(ListNode* head) {
        if(!head) return NULL;
        
        vector<int> vec; //convert this question to a simpler one ^_^
        ListNode* move = head;
        while(move){
            vec.push_back(move->val);
            move = move->next;
        }
        
        return convert(vec, 0, vec.size() - 1);
    }
    TreeNode* convert(vector<int>& nums, int low, int high){
        if(low > high) return NULL;
        
        int mid = (low + high) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        if(low == high) return root;
        
        root->left = convert(nums, low, mid - 1);
        root->right = convert(nums, mid + 1, high);
        
        return root;
    }
};

Trial 3: A recursion solution evolved from trail 1. First find the mid node, then recursively do the left and right part.

Runtime: 28ms.

/**
 * 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:
    TreeNode* sortedListToBST(ListNode* head) {
        if(!head) return NULL;
        
        int len = 0; //length of the list
        ListNode* move = head;
        while(move){
            move = move->next;
            len++;
        }
        return construct(head, 0, len - 1);
    }
    
    TreeNode* construct(ListNode* &head, int low, int high){
        if(low > high) return NULL;
        
        int mid = (low + high) / 2;
        TreeNode* leftSubtree = construct(head, low, mid - 1);
        TreeNode* root = new TreeNode(head->val);
        root->left = leftSubtree;
        head = head->next; //the right subtree follows the current mid node.
        TreeNode* rightSubtree = construct(head, mid + 1, high);
        root->right = rightSubtree;
        
        return root;
    }
};