Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.
/**
* 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)
{
ListNode *tmp = head;
vector<int> data;
TreeNode * root = NULL;
while (NULL != tmp)
{
data.push_back(tmp->val);
tmp = tmp->next;
}
maketree(data,root);
return root;
}
void maketree(vector<int> data, TreeNode *&root)
{
if (data.size() == 0)
return;
int middle = data.size()/2;
root = new TreeNode(data[middle]);
vector<int> leftdata(data.begin(), data.begin()+middle);
vector<int> rightdata(data.begin()+middle+1, data.end());
maketree(leftdata, root->left);
maketree(rightdata, root->right);
}
};
//data数组不每次生成新的 结果是对的 但是和答案结构不一样,未通过
class Solution {
public:
TreeNode *sortedListToBST(ListNode *head)
{
ListNode *tmp = head;
vector<int> data;
TreeNode * root = NULL;
while (NULL != tmp)
{
data.push_back(tmp->val);
tmp = tmp->next;
}
maketree(data,root,0,data.size()-1);
return root;
}
void maketree(vector<int> &data, TreeNode *&root, int left, int right)
{
if (left>right)
return;
int middle = (left + right)/2;
root = new TreeNode(data[middle]);
maketree(data, root->left, left, middle-1);
maketree(data, root->right, middle+1,right);
}
};
测试
#include<vector>
#include<algorithm>
#include<iostream>
using namespace std;
struct ListNode {
int val;
ListNode *next;
ListNode(int x) : val(x), next(NULL) {}
};
struct TreeNode
{
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {}
};
ListNode * generateLinkList(vector<int> vec)
{
ListNode * head = NULL;
if (vec.size() == 0)
return head;
head = new ListNode(vec[0]);
ListNode * tmp = head;
for (int i = 1; i<vec.size(); i++)
{
tmp->next = new ListNode(vec[i]);
tmp = tmp->next;
}
return head;
}
void inorder(TreeNode * root)
{
if (NULL == root)
return;
inorder(root->left);
cout<<" "<<root->val;
inorder(root->right);
}
class Solution {
public:
TreeNode *sortedListToBST(ListNode *head)
{
ListNode *tmp = head;
vector<int> data;
TreeNode * root = NULL;
while (NULL != tmp)
{
data.push_back(tmp->val);
tmp = tmp->next;
}
maketree(data,root);
return root;
}
void maketree(vector<int> data, TreeNode *&root)
{
if (data.size() == 0)
return;
int middle = data.size()/2;
root = new TreeNode(data[middle]);
vector<int> leftdata(data.begin(), data.begin()+middle);
vector<int> rightdata(data.begin()+middle+1, data.end());
maketree(leftdata, root->left);
maketree(rightdata, root->right);
}
};
class Solution1 {
public:
TreeNode *sortedListToBST(ListNode *head)
{
ListNode *tmp = head;
vector<int> data;
TreeNode * root = NULL;
while (NULL != tmp)
{
data.push_back(tmp->val);
tmp = tmp->next;
}
maketree(data,root,0,data.size()-1);
return root;
}
void maketree(vector<int> &data, TreeNode *&root, int left, int right)
{
if (left>right)
return;
int middle = (left + right)/2;
root = new TreeNode(data[middle]);
maketree(data, root->left, left, middle-1);
maketree(data, root->right, middle+1,right);
}
};
int main()
{
Solution1 s;
int A[] = {1,3,2,3,4,5,6};
vector<int> vec(A, A +2);
sort(vec.begin(), vec.end());
ListNode * head1 = generateLinkList(vec);
TreeNode * root = s.sortedListToBST(head1);
inorder(root);
cout<<endl;
return 0;
}