leetcode 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.

/**
 * 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;
}