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