LeetCode-Convert Sorted List to Binary Search Tree

LeetCode第109题Convert Sorted List to Bianry 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.

题目大意：

给定一个升序排列的单链表，将其转换成一个高度平衡的BST（二叉搜索树）。

其中高度平衡的BST定义为：每个节点的两个子节点高度差不大于1。

解题思路：

此题和该题（待补充））类似，不同之处在于待转换的数据结构，一个为数组，一个为链表，但大体思路相似。

题目中明确说明链表为升序，因此它与最终的二叉搜索树的中序遍历是相同的。因此链表中间位置的数字就应该是二叉搜索树的根，中间位置左半部分的中间位置的数字为根的左孩子，中间位置右半部分的中间位置为根的右孩子，依次类推......（很明显的递归）。

代码：

/**
 * 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) {
        TreeNode* root = NULL;
        helper(root, head, NULL);
        return root;
    }
    
    void helper(TreeNode* & root, ListNode* head, ListNode* tail){
        ListNode* m = head;
        ListNode* f = head;
        while(f != tail && f->next != tail){
            m = m->next;
            f = f->next->next;
        }
        if(m != tail){
            root = new TreeNode(m->val);
            helper(root->left, head, m);
            helper(root->right, m->next, tail);
        }
    }
    
    /*
    //返回链表指定部分的中间
    ListNode* middle(ListNode* head, ListNode* tail){
        ListNode* fast = head;
        slow = head;
        while(fast != tail && fast->next != tail){
            fast = fast->next->next;
            slow = slow->next;
        }
        
        return slow;
    }*/
};