[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);
}