LeetCoode—**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.

我想如果只是表示成二叉树，没有什么难度，但是如果是表示为平衡二叉树那么可能就有难度了

要求左右子树的高度是均衡的

先给出自己的解法，很low，就是现将节点都保存在vector里面，在选用mid进行递归创建

时间，空间复杂度O(n)

/**
 * 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当中
        vector<TreeNode*> NodeList;
        if(head == NULL)
        {
            return NULL;
        }
        TreeNode * phead = new TreeNode(head->val);
        NodeList.push_back(phead);
        while(head->next != NULL)
        {
            head = head->next;
            TreeNode * node = new TreeNode(head->val);
            NodeList.push_back(node);
            
        }
        return BST(0,NodeList.size()-1,NodeList);//<表示初始值，和结束的值
    }
    TreeNode *BST(int start,int end,vector<TreeNode*> NodeList)
    {
        if(start == end)
        {
            return NodeList[start];
        }
        if((start+1) == end)//<按数值增大的方向排序，那么直接放在右孩子的位置
        {
            NodeList[start]->right = NodeList[end];
            return NodeList[start];
        }
        int Mid = (start+end)/2;
        TreeNode *root = NodeList[Mid];
        root->left = BST(start,Mid-1,NodeList);
        root->right = BST(Mid+1,end,NodeList);
        return root;
    }
};

下面是标准答案，时间复杂度就是O(N),空间复杂度为O(1)

但是在整个子树的递归过程中本人表示还是很绕啊

TreeNode *sortedListToBST(ListNode *head)  
{  
    int len = 0;  
       ListNode * node = head;  
       while (node != NULL)  
       {  
           node = node->next;  
           len++;  
       }  
       return buildTree(head, 0, len-1);  
   }  
     
   TreeNode *buildTree(ListNode *&node, int start, int end)  
   {  
       if (start > end) return NULL;  
       int mid = start + (end - start)/2;  
       TreeNode *left = buildTree(node, start, mid-1);  
       TreeNode *root = new TreeNode(node->val);    //<返回的时候表明上一层中start == mid,所以这个点为mid点  
       root->left = left;  
       node = node->next;  
       root->right = buildTree(node, mid+1, end);  
       return root;  
   }