有序链表转换二叉搜索树

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定的有序链表： [-10, -3, 0, 5, 9],

一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：

     0
    / \
  -3   9
  /    /
-10   5

解题思路：
我想到的是每一次分治，然后分支的中间节点是根节点，左右分别是左右子树。所以重点就是要得到链表的中间节点
1. 我们可以从顶向下，即直接遍历整个链表，用数组存起来，这样就知道每一个中间节点
2. 可以自底向上，当我们知道链表的长度之后，我们可以根据长度来递归，根据递归的特性，首先肯定是得到左子树的连接，然后才是右子树。

我的code：由于存储整个数组，空间复杂度在O(n),由于需要遍历整个链表，时间复杂度为O(n)

class Solution {
public:

    TreeNode* backthrough(vector<ListNode*> &lnode,int l,int r)
    {
        if(l==r)
        {
            TreeNode* tnode = new TreeNode(lnode[l]->val);
            return tnode;
        }

        int m=l+(r-l+1)/2;
        TreeNode* left=NULL;
        TreeNode* right=NULL;
        if(m-1>=l)
            left=backthrough(lnode,l,m-1);
        if(m+1<=r)
            right=backthrough(lnode,m+1,r);
        TreeNode* mnode = new TreeNode(lnode[m]->val);
        mnode->left=left;
        mnode->right=right;
        return mnode;
    };


    TreeNode* sortedListToBST(ListNode* head) {
        if(!head)
            return NULL;
        vector<ListNode*> lnode;
        while(head)
        {
            lnode.push_back(head);
            head=head->next;
        }
        return backthrough(lnode,0,lnode.size()-1);

    }
};

直接遍历得到长度：时间复杂度就是遍历整个链表O(n),空间复杂度为递归的树的高度O(logn):

var h *ListNode

func sortedListToBST(head *ListNode) *TreeNode {
	if head == nil {
		return nil
	}
	length := 0
	h = head
	for head != nil {
		length++
		head = head.Next
	}
	return buildBST(0, length-1)
}
func buildBST(start, end int) *TreeNode {
	if start > end {
		return nil
	}
	mid := (start + end) >> 1
	left := buildBST(start, mid-1)
	root := &TreeNode{Val: h.Val}
	h = h.Next
	root.Left = left
	root.Right = buildBST(mid+1, end)
	return root
}