143. Reorder List
link list ⇒ list
class Solution(object):
def reorderList(self, head):
"""
:type head: ListNode
:rtype: None Do not return anything, modify head in-place instead.
"""
s=[]
cur=head
while cur:
s.append(cur)
cur=cur.next
cnt=len(s)/2
cur=head
while cnt:
node=s.pop()
t=cur.next
cur.next=node
node.next=t
cur=t
cnt-=1
if cur:
cur.next=None
return head
109. Convert Sorted List to Binary Search Tree
when not using extra space, we must seperate the link list again an again, find the middle node, then using recursive way to go on
class Solution(object):
def sortedListToBST(self, head):
"""
:type head: ListNode
:rtype: TreeNode
"""
def helper(s):
l=s
h=s
last=l
if not s:
return None
if not s.next:
return TreeNode(s.val)
while h.next and h.next.next:
h=h.next.next
last=l
l=l.next
if l==h:
l=l.next
last.next=None
h=l.next
node=TreeNode(l.val)
node.left=helper(s)
node.right=helper(h)
return node
return helper(head)
we can using extra space to store all the list values to a array, so it change to the problem: convert array to binary search tree
class Solution:
# Convert the given linked list to an array
def mapListToValues(self, head):
vals = []
while head:
vals.append(head.val)
head = head.next
return vals
def sortedListToBST(self, head):
"""
:type head: ListNode
:rtype: TreeNode
"""
# Form an array out of the given linked list and then
# use the array to form the BST.
values = self.mapListToValues(head)
# l and r represent the start and end of the given array
def convertListToBST(l, r):
# Invalid case
if l > r:
return None
# Middle element forms the root.
mid = (l + r) // 2
node = TreeNode(values[mid])
# Base case for when there is only one element left in the array
if l == r:
return node
# Recursively form BST on the two halves
node.left = convertListToBST(l, mid - 1)
node.right = convertListToBST(mid + 1, r)
return node
return convertListToBST(0, len(values) - 1)