/**

 * Definition for binary tree

 * struct TreeNode {

 *     int val;

 *     TreeNode *left;

 *     TreeNode *right;

 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}

 * };

 */

class Solution {

public:

    TreeNode *sortedArrayToBST(vector<int> &num) {

        return sortedArrayToBST(, num.size()-, num);

    }

    TreeNode *sortedArrayToBST(int left, int right, vector<int> &num){

        if (left > right)

            return NULL;

        int mid = (left + right)/ + (left + right)% ;

        TreeNode *root = new TreeNode(num[mid]);

        root->left = sortedArrayToBST(left, mid-, num);

        root->right = sortedArrayToBST(mid+, right, num);

        return root;

    }

};

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

 *     ListNode(int x) : val(x), next(NULL) {}

 * };

 */

/**

 * Definition for binary tree

 * 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> num;

        if (head == NULL)

            return NULL;

        while (head){

            num.push_back(head->val);

            head = head->next;

        }

        return sortListToBST(, num.size()-, num);

    }

    TreeNode *sortListToBST(int start, int end, vector<int> &num){

        if (start > end)

            return NULL;

        int mid = (end + start)/ + (end + start)%;

        TreeNode *root = new TreeNode(num[mid]);

        root->left = sortListToBST(start, mid-, num);

        root->right = sortListToBST(mid+, end, num);

        return root;

    }

};