def copy(self, root):
node = TreeNode(root.val)
if root.left:
node.left = self.copy(root.left)
if root.right:
node.right = self.copy(root.right)
return node
def sortedArrayToBSTHelper(self, num, start, end):
index = start + (end - start)/2
root = TreeNode(num[index])
if index > start:
root.left = self.sortedArrayToBSTHelper(num, start, index)
if end > index+1:
root.right = self.sortedArrayToBSTHelper(num, index+1, end)
return root
def listToBST(self, head, N):
if N == 1:
return [TreeNode(head.val), head.next]
l = self.listToBST(head, N/2)
root = TreeNode(l[1].val)
root.left = l[0]
if (N-1)/2:
r = self.listToBST(l[1].next, (N-1)/2)
root.right = r[0]
return [root, r[1]]
else:
return [root, l[1].next]
def generateTrees(self, n):
if n < 1:
return [None]
if n == 1:
node = TreeNode(1)
return [node]
A = self.generateTrees(n - 1)
for i in range(len(A)):
cur, j = A[i], 0
while cur:
node = self.copy(A[i])
A.append(node)
k = 0
while k < j:
node = node.right
k += 1
newNode = TreeNode(node.val)
newNode.left = node.left
newNode.right = node.right
node.val = n
node.left = newNode
node.right = None
cur = cur.right
j += 1
node = A[i]
while node.right:
node = node.right
node.right = TreeNode(n)
return A
def build(self, inorder, s1, e1, postorder, s2, e2):
size = e1 - s1
if size <= 0:
return None
node = TreeNode(inorder[s1])
if size == 1:
return node
if inorder[s1] == postorder[s2]:
i = 1
while (s1+i) < e1:
if inorder[s1+i] != postorder[s2+i]:
break
cur = TreeNode(inorder[s1+i])
cur.left = node
node = cur
i += 1
if (s1+i) < e1:
root = self.build(inorder, s1+i, e1, postorder, s2+i, e2)
cur = root
while cur.left:
cur = cur.left
cur.left = node
node = root
return node
if inorder[s1] == postorder[e2-1]:
cur = node
i = 1
while (s1+i) < e1:
if inorder[s1+i] != postorder[e2-1-i]:
break
cur.right = TreeNode(inorder[s1+i])
cur = cur.right
i += 1
if (s1+i) < e1:
root = self.build(inorder, s1+i, e1, postorder, s2, e2-i)
cur.right = root
return node
i = s2 + 1
while i < e2-1:
if postorder[i] == inorder[s1]:
break
i += 1
right = self.build(inorder, s1+1, s1+1+i-s2, postorder, s2, i)
node.right = right
root = self.build(inorder, s1+1+i-s2, e1, postorder, i+1, e2)
cur = root
while cur.left:
cur = cur.left
cur.left = node
return root
def build(self, preorder, s1, e1, inorder, s2, e2):
size = e1 - s1
if size <= 0:
return None
node = TreeNode(preorder[s1])
if size == 1:
return node
if preorder[s1] == inorder[s2]:
cur = node
i = 1
while (s1+i) < e1:
if preorder[s1+i] != inorder[s2+i]:
break
cur.right = TreeNode(preorder[s1+i])
cur = cur.right
i += 1
if (s1+i) < e1:
cur.right = self.build(preorder, s1+i, e1, inorder, s2+i, e2)
return node
if preorder[s1] == inorder[e2-1]:
cur = node
i = 1
while (s1+i) < e1:
if preorder[s1+i] != inorder[e2-1-i]:
break
cur.left = TreeNode(preorder[s1+i])
cur = cur.left
i += 1
if (s1+i) < e1:
cur.left = self.build(preorder, s1+i, e1, inorder, s2, e2-i)
return node
i = s2 + 1
while i < e2-1:
if preorder[s1] == inorder[i]:
break
i += 1
node.left = self.build(preorder, s1+1, s1+1+i-s2, inorder, s2, i)
node.right = self.build(preorder, s1+1+i-s2, e1, inorder, i+1, e2)
return node
