109.Convert Sorted List to Binary Search Tree

题目链接：https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/description/

题目大意：将升序单链表转换为平衡二叉排序树。

法一（借鉴）：利用108的二分思想，只是这里单链表没法直接拿到下标，所以每次都要遍历得到最中间的数，可以计数链表长度，然后利用长度大小来遍历得到，这里时间复杂度变为o(nlgn)，代码如下（耗时2ms）：

    public TreeNode sortedListToBST(ListNode head) {
        int length = 0;
        ListNode p = head;
        while(head != null) {
            head = head.next;
            length++;
        }
        return dfs(p, length);
    }
    public static TreeNode dfs(ListNode head, int length) {
        if(head == null || length == 0) {
            return null;
        }
        ListNode p = head;
        int leftLength = 1;
        while(leftLength <= length / 2) {
            head = head.next;
            leftLength++;
        }
        TreeNode root = new TreeNode(head.val);
        root.left = dfs(p, leftLength - 1);
        root.right = dfs(head.next, length - leftLength);
        return root;
    }

法二（借鉴）：依然是二分思想，但是这里不用Length计数链表长度来模拟二分，而是利用快慢指针来模拟二分，很巧妙，时间复杂度依然是o(nlgn)，代码如下（耗时1ms）：

    public TreeNode sortedListToBST(ListNode head) {
        return dfs(head, null);
    }
    public static TreeNode dfs(ListNode head, ListNode tail) {
        if(head == tail) {
            return null;
        }
        ListNode slow = head;
        ListNode fast = head;
        while(fast != tail && fast.next != tail) {
            fast = fast.next.next;
            slow = slow.next;
        }
        TreeNode root = new TreeNode(slow.val);
        root.left = dfs(head, slow);
        root.right = dfs(slow.next, tail);
        return root;
    }

法三：将结点放入集合中，模拟108数组的二分做即可，这里用LinkedList超时了，所以转而使用ArrayList，时间复杂度是o(n)，代码如下（耗时2ms）：

    public TreeNode sortedListToBST(ListNode head) {
        List<ListNode> list = new ArrayList<ListNode>();
        while(head != null) {
            list.add(head);
            head = head.next;
        }
        return dfs(list, 0, list.size() - 1);
    }
    public static TreeNode dfs(List<ListNode> list, int left, int right) {
        if(left > right) {
            return null;
        }
        int mid = (left + right) / 2;
        TreeNode root = new TreeNode(list.get(mid).val);
        root.left = dfs(list, left, mid - 1);
        root.right = dfs(list, mid + 1, right);
        return root;
    }

法四（借鉴）：还有一个利用中序创建二叉树的思想做的，时间复杂度是o(n)，但空间复杂度是o(1)，不是很懂，http://blog.csdn.net/feliciafay/article/details/18499545