方法1: 和108题一样,这题的input是一个linkedlist,所以我们先把这个list转换成array,然后和108题一样做。时间复杂n,空间复杂n。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode sortedListToBST(ListNode head) {
if(head == null) return null;
List<Integer> list = new ArrayList<>();
while(head!= null){
list.add(head.val);
head = head.next;
}
return helper(list);
}
public TreeNode helper(List list){
if(list.size() == 0) return null;
TreeNode mid = new TreeNode((int)list.get(list.size()/2));
mid.left = helper(list.subList(0,list.size()/2));
mid.right = helper(list.subList(list.size()/2 + 1, list.size()));
return mid;
}
}
方法2: recursion。时间复杂nlogn,空间复杂logn。这个方法涉及到node衔接问题,所以需要keep一个prev node。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode sortedListToBST(ListNode head) {
if(head == null) return null;
if(head.next == null) return new TreeNode(head.val);
int size = findSize(head)/2;
TreeNode root = new TreeNode();
ListNode c = head;
ListNode prev = null;
while(size > 0){
root.val = c.val;
prev = c;
c = c.next;
size--;
}
prev.next = null;
root.val = c.val;
root.left = sortedListToBST(head);
root.right = sortedListToBST(c.next);
return root;
}
private int findSize(ListNode head){
ListNode ptr = head;
int c = 0;
while(ptr != null){
ptr = ptr.next;
c++;
}
return c;
}
}
方法3: Inorder Simulation。这是lc官方解答3。它是模拟了inorder traversal。这个方法的精髓就在于head的变化,这一点上确实是实实在在模拟了inorder traversal。不是特别好理解的方法,但是非常巧妙,复盘的时候可以再看看。时间复杂n,空间复杂logn。
/**
* Definition for singly-linked list. public class ListNode { int val; ListNode next; ListNode(int
* x) { val = x; } }
*/
/**
* Definition for a binary tree node. public class TreeNode { int val; TreeNode left; TreeNode
* right; TreeNode(int x) { val = x; } }
*/
class Solution {
private ListNode head;
private int findSize(ListNode head) {
ListNode ptr = head;
int c = 0;
while (ptr != null) {
ptr = ptr.next;
c += 1;
}
return c;
}
private TreeNode convertListToBST(int l, int r) {
// Invalid case
if (l > r) {
return null;
}
int mid = (l + r) / 2;
// First step of simulated inorder traversal. Recursively form
// the left half
TreeNode left = this.convertListToBST(l, mid - 1);
// Once left half is traversed, process the current node
TreeNode node = new TreeNode(this.head.val);
node.left = left;
// Maintain the invariance mentioned in the algorithm
this.head = this.head.next;
// Recurse on the right hand side and form BST out of them
node.right = this.convertListToBST(mid + 1, r);
return node;
}
public TreeNode sortedListToBST(ListNode head) {
// Get the size of the linked list first
int size = this.findSize(head);
this.head = head;
// Form the BST now that we know the size
return convertListToBST(0, size - 1);
}
}
总结:
- 无