109 Convert Sorted List to Binary Search Tree [Leetcode]

题目内容：

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

思路：
只要知道了链表的中间节点，就可以把问题分解为子问题，中间节点是当前的根节点，左边的排序链表构成左子树，右边的构成右子树。
用了两种方法
1. 一种是将节点都放入数组中，用数组在O(1)时间获取中间数；
2. 另一种是用双指针找中间节点。

代码：
数组：

/**
 * 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) {
        vector<int> vec;
        while(head != NULL) {
            vec.push_back(head->val);
            head = head->next;
        }
        return buildBST(vec, 0, vec.size()-1);
    }

    TreeNode* buildBST(vector<int> &nums, int start, int end) {
        if(start > end)
            return NULL;

        if(start == end) {
            TreeNode *node = new TreeNode(nums[start]);
            return node;
        }

        int mid = (start + end)/2;
        TreeNode *root = new TreeNode(nums[mid]);
        root->left = buildBST(nums, start, mid-1);
        root->right = buildBST(nums, mid+1, end);
    }
};

双指针：

/**
 * 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) {
        return sortedListToBST(head, NULL);
    }

    TreeNode* sortedListToBST(ListNode *start, ListNode *end) {
        if(start == NULL || start == end)
            return NULL;
        if(start->next == end) {
            TreeNode *root = new TreeNode(start->val);
            return root;
        }

        ListNode *mid(getMid(start, end));
        TreeNode *root = new TreeNode(mid->val);
        root->left = sortedListToBST(start, mid);
        if(mid != NULL)
            root->right = sortedListToBST(mid->next, end);
        return root;
    }

    // return the mid node of list, end is excluded
    ListNode* getMid(ListNode *start, ListNode *end) {
        if(start == end)
            return start;

        ListNode *one(start), *two(start->next);
        while(two != end) {
            one = one->next;
            two = two->next;
            if(two == end)
                break;
            two = two->next;
        }
        return one;
    }
};