Convert Sorted List to Binary Search Tree&&Convert Sorted Array to Binary Search Tree——暴力解法

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.

本来想在递归中不用for循环把问题解决点，想了很久不知道该怎么做，看了网上的答案，发现大家就是用的循环·····

用循环的话，就非常简单了，但是我写代码的时候，子函数用引用传参数的时候报错，不知道为啥，可能是默认的编译器的问题··

代码很简单，如下：

/**
* 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:
int getLength(ListNode* &head)
{
int len=0;
ListNode* p=head;
if(p==NULL)
return 0;
else
{
len=1;
while(p->next!=NULL)
{
len++;
p=p->next;
}
}
return len;
}
// TreeNode*getSubBST(ListNode* head,int &left,int &right)
TreeNode*getSubBST(ListNode* head,int left,int right)
{
if(left>right)
return NULL;
else
{   ListNode* p=head;
int mid=(left+right)/2;
for(int i=left;i<mid;i++)
p=p->next;
TreeNode* node=new TreeNode(p->val);
node->left=getSubBST(head,left,mid-1);
node->right=getSubBST(p->next,mid+1,right);
return node;
}
}
TreeNode* sortedListToBST(ListNode* head) {
TreeNode* res;
int len=getLength(head);
res=getSubBST(head,0,len-1);
return res;

}
};

Convert Sorted Array to Binary Search Tree（有了上面这道题的基础，这道题就非常简单了，直接搬过来就能用了。）

这道题思想其实是特别的简单，实现起来居然试了很多次才对，再次体现了我的代码能力不足，这道题就是很简单的递归，每次去除中间的数，剩余的两边采用递归构造子树。

把数组切分成左右两部分我采用了vector中迭代器赋值的方法，结果在里面倒腾了很久，其实不用迭代器也行，网上许多的代码都比我的精简，再次说明我的代码能力不足，思维不够开阔··················

我的代码：

/**
* 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* sortedArrayToBST(vector<int>& nums) {
TreeNode* res=NULL;
int len=nums.size();
if(len==0)
return NULL;
else if(len==1)
{
res=new TreeNode(nums[0]);
return res;
}
else
{
int flag;
vector<int>::iterator root;
if(len%2==0)
{
root=nums.begin()+len/2-1;
flag=len/2-1;
}
else
{
root=nums.begin()+len/2;
flag=len/2;
}

res=new TreeNode(*root);
int LeftStart=0;
int LeftEnd=flag;
vector<int> subNumsL(nums.begin(),root);
int RightStart=flag+1;
int RightEnd=len-1;
vector<int> subNumsR(root+1,nums.end());
if( LeftStart<LeftEnd)
res->left=sortedArrayToBST(subNumsL);
if(RightStart<=RightEnd)
res->right=sortedArrayToBST(subNumsR);
}
return res;
}
};

　　网上比较精简的代码：

class Solution
{
public:
void build(vector<int> &num, TreeNode * &root, int left, int right)
{
if(left>right)
return;
int mid = (left+right)/2;
root = new TreeNode(num[mid]);
build(num, root->left, left, mid-1);
build(num, root->right, mid+1, right);
}
TreeNode *sortedArrayToBST(vector<int> &num)
{
// Start typing your C/C++ solution below
// DO NOT write int main() function
int len = num.size();
TreeNode * root = NULL;
if(len>0)
build(num, root, 0, len-1);
return root;
}
};