[leetcode] Convert Sorted List to Binary Search Tree

#include<iostream>
#include<vector>
using namespace std;
struct TreeNode
{
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int val):val(val),left(NULL),right(NULL){};
};
struct ListNode
{
int val;
ListNode* next;
ListNode(int val):val(val),next(NULL){};
};
class Solution
{
public:
TreeNode* sortedListToBST (ListNode* head)
{
return sortedListToBST (head, listLength (head));
}
TreeNode* sortedListToBST (ListNode* head, int len)
{
if (len == 0) return NULL;
TreeNode* root = new TreeNode (nth_node (head, len / 2 +1)->val);
root->left = sortedListToBST (head, len / 2);
root->right = sortedListToBST (nth_node (head, len / 2 + 2),len-len / 2-1);
return root;
}
int listLength (ListNode* node)
{
int n = 0;
while(node)
{
++n;
node = node->next;
}
return n;
}
ListNode* nth_node (ListNode* node, int n)
{
while (--n)
node = node->next;
return node;
}
void display(TreeNode* root)
{
if(!root)
return;
display(root->left);
cout<<root->val<<' ';
display(root->right);
}
};

class Solution2
{
public:
TreeNode *sortedListToBST(ListNode *head)
{
int len = 0;
ListNode *p = head;
while (p)
{
len++;
p = p->next;
}
return sortedListToBST(head, 0, len - 1);
}
void display(TreeNode* root)
{
if(!root)
return;
display(root->left);
cout<<root->val<<' ';
display(root->right);
}
private:
TreeNode* sortedListToBST(ListNode*& list, int start, int end)
{
if (start > end) return NULL;
int mid = start + (end - start) / 2;
TreeNode *leftChild = sortedListToBST(list, start, mid - 1);
if(leftChild)
cout<<"left "<<leftChild->val<<' ';
else
cout<<"left no"<<' ';
TreeNode *parent = new TreeNode(list->val);
parent->left = leftChild;
list = list->next;
parent->right = sortedListToBST(list, mid + 1, end);
return parent;
}
};

void main()
{
Solution2 solution;
ListNode* node=new ListNode(1);
ListNode* root=node;
for(int i=2;i<8;i++)
{
ListNode* cur=new ListNode(i);
node->next=cur;
node=node->next;
}
node->next=NULL;
TreeNode* head;
head=solution.sortedListToBST(root);
solution.display(head);
}