LeetCode中 将升序链表转换成平衡二叉树

节点和树的结构：

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) {}

 * };

 */

这题的大致解题思想是， 找到链表的中间节点，将它设置成root节点，然后迭代前半段链表和后半段链表，找root的左节点和右节点，时间复杂度：O(NlogN）。感觉边界的确定是一个很头痛的问题啊！我就是遇到边界确定是一直有点晕。

代码：

class Solution {

public:

    TreeNode* sortedListToBST(ListNode* head) {

        if(head == NULL)//异常情况返回

        {

            return NULL;

        }

        ListNode* slow = getMid(head);//得到中间值

         if(slow->next == NULL)

        {

           TreeNode* root = new TreeNode(slow->val);

           return root;

        }

        ListNode* sedhead = slow->next;

        slow->next = NULL;//分为2个链表

        TreeNode* root = new TreeNode(sedhead->val);

        root->left = sortedListToBST(head);//迭代的时候注意左边和右边是不一样的，这个和中点的选取有关系，比如{1 3 5 8 10} 中点是5，那么左边从3开始，右边从中间节点的下一个节点也就是8开始，最开始我搞错了从5开始，造成了重复。

        if(sedhead->next != NULL)

        {

           root->right = sortedListToBST(sedhead->next);

        }

        return root;

    }

    ListNode* getMid(ListNode* head)//返回中点前的一个点。如果只有一个点，返回这个点。

    {

        ListNode* slow = head;

        ListNode* fast = head;

        ListNode* pre = head;

        if(head == NULL)

        {

            return NULL;

        }

        while(fast->next != NULL && fast->next->next != NULL)

        {

            pre = slow;

            slow = slow->next;

            fast = fast->next->next;

        }

        return pre;

    }

};