*LeetCode-Convert Sorted List to Binary Search Tree-优快云博客

本文介绍两种将有序链表转换为平衡二叉搜索树的方法：一种时间复杂度为O(nlogn)，通过快慢指针找到链表中点作为根节点；另一种为O(n)时间复杂度的方法，通过计数并递归构建左右子树。

inorder就是顺序的一个linked list

每次找到list的中间就是root 左边sub list中间就是左子右边sub list的中间就是右子

但是注意只有一个node的情况要把head设置成null 而且每次找到mid之后要把mid之前的那个node.next = null

o(nlogn)

public class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        if ( head == null )
            return null;
         ListNode fast = head;
         ListNode slow = head;
         ListNode pre = null;
         while ( fast != null && fast.next != null ){
             fast = fast.next.next;
             pre = slow;
             slow = slow.next;
         }
         if ( pre != null )
            pre.next = null;
        else
            head = null;
         TreeNode root = new TreeNode ( slow.val );
         root.left = sortedListToBST(head);
         root.right = sortedListToBST(slow.next);
         return root;
    }
}

o(n)做法

The method 1 constructs the tree from root to leaves. In this method, we construct from leaves to root. The idea is to insert nodes in BST in the same order as the appear in Linked List, so that the tree can be constructed in O(n) time complexity. We first count the number of nodes in the given Linked List. Let the count be n. After counting nodes, we take left n/2 nodes and recursively construct the left subtree. After left subtree is constructed, we allocate memory for root and link the left subtree with root. Finally, we recursively construct the right subtree and link it with root.

While constructing the BST, we also keep moving the list head pointer to next so that we have the appropriate pointer in each recursive call.

从list头开始用一个全局指针来当pointer 每次建好左树建一个rootnode pointer ＋＋然后建右树

每个node访问一遍就是inorder的顺序 bottom up做的

public class Solution {
    private ListNode node;
    public TreeNode sortedListToBST(ListNode head) {
        if ( head == null )
            return null;
        ListNode pt = head;
        node = head;
        int count = 0; 
        while ( head != null ){
            head = head.next;
            count ++;
        }
        return helper ( 0, count - 1 );
    }
    public TreeNode helper ( int start, int end ){
        if ( start > end )
            return null;
        int mid = start + ( end - start ) / 2;
        TreeNode left = helper ( start, mid - 1 );
        TreeNode root = new TreeNode ( node.val );
        root.left = left;
        node = node.next;
        root.right = helper ( mid + 1, end );
        return root;
    }

helper里面的start end只是用来计数的我觉得为了判断停止条件