109 将有序数组转换为二叉搜索平衡树 递归法

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

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

示例:

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

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

  0
 / \

-3 9
/ /
-10 5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-sorted-list-to-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * 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>nums=changeToVector(head);
        return sortedListToBSTHelper(nums);
    }
    
    
    TreeNode* sortedListToBSTHelper(vector<int> nums)
    {
    	if(nums.size()==0)
    		return NULL;
    		
    	if(nums.size()==1)
    	{
    		TreeNode* root=new TreeNode(nums[0]);
    		return root;
		}
    	
    	int middle=nums.size()/2;
    	TreeNode *root=new TreeNode(nums[middle]);
		
    	vector<int> left(nums.begin(),nums.begin()+middle),right(nums.begin()+middle+1,nums.end());
    	//一种初始化容器方法，注意它的区间是[,)   所以是 left(nums.begin(),nums.begin()+middle)
    	//而不是left(nums.begin(),nums.begin()+middle-1)
		//那为什么nums.end()不用+1呢？因为nums.end()函数返回的就是数组最后一个指针+1个空间。。。。 
    	root->left=sortedListToBSTHelper(left);
    	root->right=sortedListToBSTHelper(right);
		return root;
	}
    
    vector<int> changeToVector(ListNode* root)
	{
        vector<int>nums;
		if(root==NULL)
			return nums;
		while(root!=NULL)
		{
			nums.push_back(root->val);
			root=root->next;	
		}	
		return nums;
	} 
    
};

法二

这是我一开始想的方法，，但是不知道为什么要么栈溢出要么超时，，，，

class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if(head==nullptr) return nullptr;
        if(head->next == nullptr) return new TreeNode(head->val);
        ListNode *start = new ListNode(0);//对于什么时候new一个空间什么时候不需要
		//结合下面个人的理解就是当需要返回一个节点得时候，这个节点必须有空间
		//下面类似于slow fast这样的指针只需要指向链表进行移动判断即可，所以不需要new 
        start ->next=head;
        ListNode *fast = start, *slow = start, *slow_pre = nullptr;
        fun(&fast,&slow,&slow_pre);
        if(slow_pre==nullptr)
            return NULL;
        TreeNode *root = new TreeNode(slow->val);//比如这个root需要返回，就需要创建 
        slow_pre->next = nullptr;
        root->left = sortedListToBST(start->next);
        root->right = sortedListToBST(slow->next);
        return root;
    }
    
    void fun(ListNode **fast,ListNode **slow,ListNode **slow_pre)//传入指针得地址才可以赋值 
    {
        while((*fast)!=nullptr&&(*fast)->next!=nullptr){
            *fast = (*fast)->next->next;
            *slow_pre = *slow;
            *slow = (*slow)->next;
        }
    }
};