def _buildTree(self, start, end):
if start < end:
root = TreeNode(self.postorder.pop())
index = self.inorder.index(root.val)
root.right = self._buildTree(index + 1, end)
root.left = self._buildTree(start, index)
return root
def helper(self, nums, left, right):
if left == right:
return nums[left]
mid = left + (
(right - left) >> 1) # Note! + has higher priority than >>
root = TreeNode(nums[mid])
root.left = self.helper(nums, left, mid - 1)
root.right = self.helper(nums, mid + 1, right)
return root
def build_tree(self, n):
if n <= 0:
return None
l = self.build_tree(n / 2)
root = TreeNode(self.cur.val)
self.cur = self.cur.next
r = self.build_tree(n - n / 2 - 1)
root.left = l
root.right = r
return root
def allPossibleFBT(self, N: int):
if N in self.cache:
return self.cache[N]
tree = []
for i in range(1, N, 2):
for l in self.allPossibleFBT(i):
for r in self.allPossibleFBT(N - i - 1):
node = TreeNode(0)
node.left = l
node.right = r
tree.append(node)
self.cache[N] = tree
return self.cache[N]
def buildTree(self, preorder, inorder):
"""
:type preorder: List[int]
:type inorder: List[int]
:rtype: TreeNode
"""
if inorder:
index = inorder.index(preorder[0])
del preorder[0]
root = TreeNode(inorder[index])
root.left = self.buildTree(preorder, inorder[:index])
root.right = self.buildTree(preorder, inorder[index + 1:])
return root
def dfs(self, start, end):
if start > end:
return [None]
res = []
for rootval in range(start, end + 1):
LeftTrees = self.dfs(start, rootval - 1)
RightTrees = self.dfs(rootval + 1, end)
for ltree in LeftTrees:
for rtree in RightTrees:
root = TreeNode(rootval)
root.left = ltree
root.right = rtree
res.append(root)
return res
def buildTree(self, preorder, inorder):
"""
:type preorder: List[int]
:type inorder: List[int]
:rtype: TreeNode
"""
# write your code here
if inorder:
root_pos = inorder.index(preorder[0])
del preorder[0]
root = TreeNode(inorder[root_pos])
root.left = self.buildTree(preorder, inorder[:root_pos])
root.right = self.buildTree(preorder, inorder[root_pos + 1:])
return root
def buildTree_bad(self, inorder, postorder):
"""
:type inorder: List[int]
:type postorder: List[int]
:rtype: TreeNode
"""
if inorder:
root_pos = inorder.index(postorder[-1])
del postorder[-1]
root = TreeNode(inorder[root_pos])
root.left = self.buildTree(inorder[0: root_pos], postorder[:root_pos])
root.right = self.buildTree(inorder[root_pos + 1: len(inorder)], postorder[root_pos:])
return root
def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
if not root:
return None
if root.val > key:
root.left = self.deleteNode(root.left, key)
elif root.val < key:
root.right = self.deleteNode(root.right, key)
else:
if not root.left or not root.right:
root = root.left if root.left else root.right
else:
cur = root.right
while cur.left:
cur = cur.left
root.val = cur.val
root.right = self.deleteNode(root.right, cur.val)
return root
def genertate_bin_tree(nums):
""
if not nums or len(nums) < 1:
return None
root = TreeNode()
return root
def sortedArrayToBST(self, nums):
"""
:type nums: List[int]
:rtype: TreeNode
"""
if len(nums)<1:
return
start,end = 0,len(nums)
mid = (start + end)/2
root = TreeNode(nums[mid])
leftList = nums[start:mid]
rightList = nums[mid+1:end]
print leftList,rightList
if len(leftList)>0:
root.left = self.sortedArrayToBST(leftList)
if len(rightList)>0:
root.right = self.sortedArrayToBST(rightList)
return root
def sortedListToBST(self, head):
if not head:
return None
if not head.next:
return TreeNode(head.val)
fast = head.next
slow = head
last_of_left = None
while fast and fast.next:
fast = fast.next.next
last_of_left = slow
slow = slow.next
root = TreeNode(slow.val)
if last_of_left:
last_of_left.next = None
root.left = self.sortedListToBST(head)
if slow.next:
root.right = self.sortedListToBST(slow.next)
return root
def __init__(self):
'''
满二叉树是一类二叉树，其中每个结点恰好有 0 或 2 个子结点。
返回包含 N 个结点的所有可能满二叉树的列表。 答案的每个元素都是一个可能树的根结点。
答案中每个树的每个结点都必须有 node.val=0。
你可以按任何顺序返回树的最终列表。
示例：
输入：7
输出：[[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/all-possible-full-binary-trees
'''
self.cache = {0: [], 1: [TreeNode(0)]}
示例：
输入：7
输出：[[0,0,0,null,null,0,0,null,null,0,0],[0,0,0,null,null,0,0,0,0],[0,0,0,0,0,0,0],[0,0,0,0,0,null,null,null,null,0,0],[0,0,0,0,0,null,null,0,0]]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/all-possible-full-binary-trees
'''
self.cache = {0: [], 1: [TreeNode(0)]}
def allPossibleFBT(self, N: int):
if N in self.cache:
return self.cache[N]
tree = []
for i in range(1, N, 2):
for l in self.allPossibleFBT(i):
for r in self.allPossibleFBT(N - i - 1):
node = TreeNode(0)
node.left = l
node.right = r
tree.append(node)
self.cache[N] = tree
return self.cache[N]
if __name__ == '__main__':
s = Solution()
N = 7
li = s.allPossibleFBT(N)
for n in li:
print(TreeNode.print_tree(n))