def buildTree(self, preorder, inorder):
"""
:type preorder: List[int]
:type inorder: List[int]
:rtype: TreeNode
"""
if not preorder and not inorder:
return None
tmp1 = zip(*sorted(enumerate(preorder), key=lambda x: x[1]))[0]
tmp2 = zip(*sorted(enumerate(inorder), key=lambda x:x[1]))[0]
pre2in = zip(*sorted(zip(tmp1, tmp2)))[1]
root = TreeNode(preorder[0])
i, j, k = 0, len(inorder), 0
node, stack = root, []
while True:
ind = pre2in[k]
if j-ind-1 > 0:
stack.append((node, ind+1, j))
if ind-i > 0:
k += 1
node.left = TreeNode(preorder[k])
node = node.left
j = ind
elif stack:
node, i, j = stack.pop()
k += 1
node.right = TreeNode(preorder[k])
node = node.right
else:
return root
def buildTree(self, inorder, postorder):
"""
:type inorder: List[int]
:type postorder: List[int]
:rtype: TreeNode
"""
if not inorder or not postorder:
return None
tmp1 = zip(*sorted(enumerate(inorder), key=lambda x: x[1]))[0]
tmp2 = zip(*sorted(enumerate(postorder), key=lambda x: x[1]))[0]
post2in = list(zip(*sorted(zip(tmp2, tmp1)))[1])
ref = zip(post2in, postorder)
root = TreeNode(postorder.pop())
ind = post2in.pop()
i, j = 0, len(inorder)
node, stack = root, []
while True:
if ind > i:
stack.append((node, i, ind))
if j > ind + 1:
node.right = TreeNode(postorder.pop())
node = node.right
i = ind + 1
ind = post2in.pop()
elif stack:
node, i, j = stack.pop()
node.left = TreeNode(postorder.pop())
node = node.left
ind = post2in.pop()
else:
return root
def rec(ini, inj, posti, postj):
if inj - ini == 0 or postj - posti == 0:
return None
ind = post2in[postj - 1]
root = TreeNode(inorder[ind])
root.left = rec(ini, ind, posti, posti + ind - ini)
root.right = rec(ind + 1, inj, posti + ind - ini, postj - 1)
return root
def rec(prei, prej, ini, inj):
if prej==prei and inj==ini:
return None
ind = pre2in[prei]
root = TreeNode(preorder[prei])
root.left = rec(prei+1, prei+1+ind-ini, ini, ind)
root.right = rec(prei+1+ind-ini, prej, ind+1, inj)
return root
def rec(self, i, j):
if j - i == 0:
return [None]
ans = []
for x in xrange(i, j):
for left in self.rec(i, x):
for right in self.rec(x + 1, j):
root = TreeNode(x)
root.left, root.right = left, right
ans.append(root)
return ans
def sortedArrayToBST(self, nums):
"""
:type nums: List[int]
:rtype: TreeNode
"""
if not nums:
return None
mid = len(nums) / 2
root = TreeNode(nums[mid])
root.left = self.sortedArrayToBST(nums[:mid])
root.right = self.sortedArrayToBST(nums[mid + 1:])
return root
def buildTree(self, preorder, inorder):
"""
:type preorder: List[int]
:type inorder: List[int]
:rtype: TreeNode
"""
if not preorder and not inorder:
return None
for i in xrange(len(inorder)):
if inorder[i] == preorder[0]:
break
root = TreeNode(preorder[0])
root.left = self.buildTree(preorder[1:i+1], inorder[:i])
root.right = self.buildTree(preorder[i+1:], inorder[i+1:])
return root
def helper(node, n):
if n == 0:
return None, None
if n == 1:
return TreeNode(node.val), node
n1 = n / 2
n2 = n1 if n % 2 == 1 else n1 - 1
hleft, node = helper(node, n1)
node = node.next
root, root_in_list = TreeNode(node.val), node
root.left = hleft
node = node.next
hright, node = helper(node, n2)
root.right = hright
node = node if node else root_in_list
return root, node
def recoverTree(self, root):
"""
:type root: TreeNode
:rtype: void Do not return anything, modify root in-place instead.
"""
tmp = [TreeNode(-float('inf')), None, None]
self.rec(root, tmp)
tmp[1].val, tmp[2].val = tmp[2].val, tmp[1].val
return BinaryTree(root).inorder()
def create_empty_tree(self, head):
if not head:
return None
root = TreeNode(None)
level = [root]
curr = head
while True:
tmp = []
for node in level:
if not curr.next:
return root
node.left = TreeNode(None)
tmp.append(node.left)
curr = curr.next
if not curr.next:
return root
node.right = TreeNode(None)
tmp.append(node.right)
curr = curr.next
level = tmp
def sortedListToBST(self, head):
"""
:type head: ListNode
:rtype: TreeNode
"""
if not head:
return None
prev, slow, fast = None, head, head
while fast and fast.next:
prev = slow
slow = slow.next
fast = fast.next.next
right_head = slow.next
root = TreeNode(slow.val)
if not prev:
root.left = None
else:
prev.next = None
root.left = self.sortedListToBST(head)
root.right = self.sortedListToBST(right_head)
return root