Convert Sorted List to Balanced Binary Search Tree leetcode

题目：将非递减有序的链表转化为平衡二叉查找树！

参考的博客：http://blog.csdn.net/worldwindjp/article/details/39722643

利用递归思想：首先找到链表的中间节点，于是链表被分为了由该中间节点划分开来的两部分。递归地处理这两部分，最终便得到了平衡二叉查找树。

/**
 * 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) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedListToBST(ListNode* head) {
        if(!head)
            return NULL;
        if(head->next==NULL){
            TreeNode*root=new TreeNode(head->val);
            return root;
        }
        ListNode*pre=getLeftOfMid(head),*mid=pre->next;
        TreeNode*root=new TreeNode(mid->val);//根
        pre->next=NULL;
        root->left=sortedListToBST(head);//左子树
        root->right=sortedListToBST(mid->next);//右子树
        return root;
    }
    ListNode* getLeftOfMid(ListNode*head)//说简单点，就是获取链表中间节点，作为树的根节点，并由此划分根的2个子树
    {
        if(!head)
            return NULL;
        ListNode*pre=head,*back=head;
        while(back!=NULL)//back后退的步数大致是head的两倍，确保pre能落在中间节点位置的前一结点处
        {
            back=back->next;
            if(!back)
                break;
            back=back->next;
            if(!back)
               break;
            pre=head;
            head=head->next;
        }
        return pre;
    }
};

 上面的方法是一种自顶向下的方法，先找到root然后对左右子树分别递归调用。

网上又看到一种自底向上的方法，算法复杂度为O(N)。先递归构建左子树，在构建左子树的同时不断移动链表的头指针，链表的头指针永远是对应当前子树位置的。一直到左叶子节点，左叶子节点对应的就是链表的第一个元素，生成左叶子节点之后移动链表当前指针。

看这个博客：http://blog.csdn.net/linhuanmars/article/details/23904937

这里的问题是对于一个链表我们是不能常量时间访问它的中间元素的。这时候就要利用到树的中序遍历了，按照递归中序遍历的顺序对链表结点一个个进行访问，而我们要构造的二分查找树正是按照链表的顺序来的。思路就是先对左子树进行递归，然后将当前结点作为根，迭代到下一个链表结点，最后在递归求出右子树即可。整体过程就是一次中序遍历，时间复杂度是O(n)，空间复杂度是栈空间O(logn)。

来看一下对应数组的中序遍历建立BST代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
private:
     int cur;//不去掉这前面的static编译不会通过的
public:
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        cur = 0;
        if (nums.size() == 0)
            return NULL;
        return helper(nums, 0, nums.size() - 1);
    }
    TreeNode* helper(vector<int>&nums, int l, int r)
    {
        if (l > r)
            return NULL;
        int mid = (l+r) / 2;
        TreeNode*left=helper(nums, l, mid-1);
        TreeNode * root = new TreeNode(nums[cur++]);//回忆考研时候，中序遍历中，这个地方才是真正干活的语句（并且终须遍历二叉排序树得到的就是有序数组）
        root->left = left;
        root->right = helper(nums, mid + 1, r);
        return root;
    }
};