leetcode Convert Sorted List to Binary Search Tree

把一个有序链表构成成平衡二叉树。和上一题有一点像。

思路一：将有序链表存在一个数组里。然后根据每次访问中间节点当做根节点递归左右子树节点即可。时间O(n)空间O(n)代码如下：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode *sortedArrayTree(vector<int> arr, int start, int end)
    {
        if (start > end) return NULL;
    
        TreeNode *root = new TreeNode(arr[(start + end)/2]);
    
        root -> left = sortedArrayTree(arr, start, (start + end)/2 - 1);
        root -> right = sortedArrayTree(arr, (start + end)/2 + 1, end);
        return root;
    }
    
    // 给定有序链表，构造高度平衡二叉树
    TreeNode *sortedListToBST(ListNode *head)
    {
        if (!head) return NULL;
    
        vector<int> tmp;
        while(head)
        {
            tmp.push_back(head -> val);
            head = head -> next;
        }
        return sortedArrayTree(tmp, 0, tmp.size() - 1);
    }

};

思路和做法应该是对的，但是Memory Limit Exceeded了，说明不能用数组存，没有那么大的空间，那就之间在链表上操作。是否记得我们在Construct Binary Tree from Inorder and Postorder Traversal中也遇到过Memory Limit的问题。那里也是应为开辟的空间有点大了。

其实巧妙的是，我发现如果我们这里把传入的arr当做应用传入，也就是vector<int> &arr的话，就可以Accept。不信你改改试试。不过我们还是再想想，直接链表上怎么操作吧。

这个是用两个链表节点递归的，节点相同就返回null，找中间节点用代码中的while操作，时间O(n logn)，java代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; next = null; }
 * }
 */
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        return rec(head, null);
    }
    
    public TreeNode rec(ListNode start, ListNode end) {
        if(start == end) {
            return null;
        }
        ListNode p = start, q = start;
        while(q != end && q.next != end) {
            p = p.next;
            q = q.next.next;
        }
        
        TreeNode root = new TreeNode(p.val);
        root.left = rec(start, p);
        root.right = rec(p.next, end);
        
        return root;
    }
    
}

这个是用传入长度，然后找到中间节点：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode *sortedListToBST(ListNode *head) {
        int n=0;
        ListNode *p=head;
        while(p!=NULL)n++,p=p->next;
        return build(head,n);        
    }
    TreeNode *build(ListNode *head,int n)
    {
        if(head==NULL||n==0)return NULL;
        ListNode *p=head;
        for(int i=1;i<(n+1)/2;++i)p=p->next;
        TreeNode *root=new TreeNode(p->val);
        root->left=build(head,(n+1)/2-1);
        root->right=build(p->next,n-(n+1)/2);
    }
};

leetcode上讨论组的最佳解法是自底向上的：时间O(n)，常数额外空间：

BinaryTree* sortedListToBST(ListNode *& list, int start, int end) {
  if (start > end) return NULL;
  // same as (start+end)/2, avoids overflow
  int mid = start + (end - start) / 2;
  BinaryTree *leftChild = sortedListToBST(list, start, mid-1);
  BinaryTree *parent = new BinaryTree(list->data);
  parent->left = leftChild;
  list = list->next;
  parent->right = sortedListToBST(list, mid+1, end);
  return parent;
}
 
BinaryTree* sortedListToBST(ListNode *head, int n) {
  return sortedListToBST(head, 0, n-1);
}