def build_from_traversals(preorder, inorder):
if not preorder or not inorder:
return None
root_val = preorder[0]
i = inorder.find(root_val)
root = TreeNode(root_val)
root.left = build_from_traversals(preorder[1:i + 1], inorder[0:i])
root.right = build_from_traversals(preorder[i + 1:], inorder[i + 1:])
def pruneTree(self, root: TreeNode) -> TreeNode:
if not root:
return None
root.left = self.pruneTree(root.left)
root.right = self.pruneTree(root.right)
if root.val == 0 and not root.left and not root.right:
return None
return root
def build_from_traversals(preorder, inorder):
if not preorder or not inorder:
return None
root_val = preorder[0]
i = inorder.find(root_val)
root = TreeNode(root_val)
root.left = build_from_traversals(preorder[1:i+1], inorder[0:i])
root.right = build_from_traversals(preorder[i+1:], inorder[i+1:])
def makeBalancedTree(nums):
if not nums:
return None
midpoint = len(nums) / 2
node = TreeNode(nums[midpoint])
node.left = solution(nums[:midpoint])
node.right = solution(nums[(midpoint + 1):])
return node
def create_by_pre_order(values):
value = values.pop(0)
if value == 0:
return None
node = TreeNode(value=value)
node.left = create_by_pre_order(values)
node.right = create_by_pre_order(values)
return node
def deleteNode(self, root: TreeNode, key: int) -> TreeNode:
""""""
v_root = TreeNode(-1)
v_root.right = root
parent = v_root
node = root
while node:
if node.val == key:
break
elif node.val > key:
node = node.left
else:
node = node.right
parent = node
if not node:
return root
def find_max_from_left(node: TreeNode) -> TreeNode:
"""从BST树节点的左子树中找到值最大的节点"""
if not node:
return
p = node
node = node.left
while node and node.right:
p = node
node = node.right
p.right = None
return node
def find_min_from_right(node: TreeNode) -> TreeNode:
"""从BST树节点的右子树中找到值最小的节点"""
if not node:
return
p = node
node = node.right
while node and node.left:
p = node
node = node.left
p.left = None
return node
if node.left:
max_sub_node = find_max_from_left(node)
node.val = max_sub_node.val
elif node.right:
min_sub_node = find_min_from_right(node)
node.val = min_sub_node.val
else:
if node.val < parent.val:
parent.left = None
else:
parent.right = None
return v_root.right
def build_coinflip_tree(k, value=""):
'''
INPUT: int
OUTPUT: TreeNode
Return the root of a binary tree representing all the possible outcomes
form flipping a coin k times.
'''
node = TreeNode(value)
if k != 0:
node.left = build_coinflip_tree(k - 1, value + "H")
node.right = build_coinflip_tree(k - 1, value + "T")
return node
def build_coinflip_tree(k, value=""):
'''
INPUT: int
OUTPUT: TreeNode
Return the root of a binary tree representing all the possible outcomes
form flipping a coin k times.
'''
node = TreeNode(value)
if k != 0:
node.left = build_coinflip_tree(k - 1, value + "H")
node.right = build_coinflip_tree(k - 1, value + "T")
return node
def build_coinflip_tree(k, value=""):
"""Return the root of a binary tree for flipping coin k times.
Root represents all the possible outcomes from flipping a coin k times.
Parameters
----------
int
Returns
-------
TreeNode
"""
node = TreeNode(value)
if k != 0:
node.left = build_coinflip_tree(k - 1, value + "H")
node.right = build_coinflip_tree(k - 1, value + "T")
return node
def test_basic_relation(self): parent = TreeNode(9) node = TreeNode(8) left = TreeNode(6) right = TreeNode(7) node.parent = parent node.left = left node.right = right self.assertEqual(id(node.parent), id(parent)) self.assertEqual(id(node.left), id(left)) self.assertEqual(id(node.right), id(right)) self.assertEqual(id(left.parent), id(node)) self.assertEqual(id(right.parent), id(node)) self.assertEqual(id(node.parent), id(parent)) self.assertEqual(id(parent.left), id(node)) self.assertTrue(parent.key > left.key) self.assertTrue(parent > left)
def create_by_pre_in_order(values1, values2):
if not values1 or not values2:
return None
root_value = values1[0]
i = 0
while values2[i] != root_value:
i += 1
left_values1 = values1[1:i + 1]
left_values2 = values2[:i]
right_values1 = values1[i + 1:]
right_values2 = values2[i + 1:]
node = TreeNode(value=root_value)
node.left = create_by_pre_in_order(left_values1, left_values2)
node.right = create_by_pre_in_order(right_values1, right_values2)
return node
def from_pre_post(pre: List[int], post: List[int]) -> TreeNode:
if not pre:
return None
root = TreeNode(pre[0])
# 左右边界判定
if len(pre) == 1:
return root
left_val = pre[1]
left_count = post.index(left_val) + 1
root.left = Construct.from_pre_post(pre[1:left_count + 1],
post[0:left_count])
root.right = Construct.from_pre_post(pre[left_count + 1:],
post[left_count:-1])
return root
return None
else:
return TreeNode(flips, build_coinflip_tree(k - 1, flips + 'H'), build_coinflip_tree(k - 1, flips + 'T'))
# node.left = build_coinflip_tree(node, k-1)
# node.right = build_coinflip_tree(node, k-1)
if __name__ == '__main__':
# build a tree
# 1
# / \
# 2 3
# /
# 4
t1 = TreeNode(1)
t1.left = TreeNode(2)
t1.right = TreeNode(3)
t1.left.left = TreeNode(4)
# build a tree
# 1
# / \
# 2 3
# / /
# 4 5
t2 = TreeNode(1)
t2.left = TreeNode(2)
t2.right = TreeNode(3)
t2.left.left = TreeNode(4)
t2.right.left = TreeNode(5)
print find_maximum(t1) # 4
from node import TreeNode
from dfs import Recursion, NonRecursion
'''
1
2 3
4 5 6 7
'''
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.left = TreeNode(6)
root.right.right = TreeNode(7)
print 'DFS Recursion'
dfsRecursion = Recursion()
print 'Pre Order'
dfsRecursion.preOrder(root)
print 'In Order'
dfsRecursion.inOrder(root)
print 'DFS NonRecursion'
dfsNonRecursion = NonRecursion()
print 'Pre Order'
dfsNonRecursion.preOrder(root)
'''Return the height of the tree.'''
if not node:
return 0
return 1 + max(get_height(node.left), get_height(node.right))
if __name__ == '__main__':
# build a tree
# 1
# / \
# 2 3
# /
# 4
t1 = TreeNode(1)
t1.left = TreeNode(2)
t1.right = TreeNode(3)
t1.left.left = TreeNode(4)
# build a tree
# 1
# / \
# 2 3
# / /
# 4 5
t2 = TreeNode(1)
t2.left = TreeNode(2)
t2.right = TreeNode(3)
t2.left.left = TreeNode(4)
t2.right.left = TreeNode(5)
print find_maximum(t1) # 4
current = stack.pop()
if current.right is None or current.right == prev:
visit_it(current.val)
prev = current
current = None
else:
stack.append(current)
stack.append(current.right)
current = current.right.left
"""
if __name__ == '__main__':
root = TreeNode(1)
root.left = TreeNode(2, right=TreeNode(3))
root.right = TreeNode(4, left=TreeNode(5))
root.right.left.left = TreeNode(6, right=TreeNode(7, right=TreeNode(8)))
root.right.left.right = TreeNode(9)
pre_order_array = []
RecursiveMode.pre_order(root, lambda x: pre_order_array.append(x))
assert pre_order_array == [1, 2, 3, 4, 5, 6, 7, 8, 9]
in_order_array = []
RecursiveMode.in_order(root, lambda x: in_order_array.append(x))
assert in_order_array == [2, 3, 1, 6, 7, 8, 5, 9, 4]
post_order_array = []
RecursiveMode.post_order(root, lambda x: post_order_array.append(x))
assert post_order_array == [3, 2, 8, 7, 6, 9, 5, 4, 1]
