def sortedListToBST(self, head: ListNode) -> TreeNode:
"""
:param nums: 从小到大排好序了
"""
if not head:
return None
if not head.next:
return TreeNode(head.val)
slow = head
fast = head.next.next
while fast and fast.next:
slow = slow.next
fast = fast.next.next
mid = slow
# 从 mid 开始截断，这样后面再传 head 就相当于只传前半段
tmp = mid.next
mid.next = None
root = TreeNode(tmp.val)
root.left = self.sortedListToBST(head)
root.right = self.sortedListToBST(tmp.next)
return root
def sortedListToBST(self, head: ListNode) -> TreeNode:
# 空列表 return
if head is None:
return None
# 单节点 return
if head.next is None:
return TreeNode(head.val)
# 2个节点 return
if head.next and head.next.next is None:
root = TreeNode(head.next.val)
root.left = TreeNode(head.val)
return root
# 快慢指针，快指针到终点时，慢指针正好是中点
prev = fast = slow = head
while True:
if fast.next:
fast = fast.next
else:
break
if fast.next:
fast = fast.next
else:
break
if slow.next:
prev = slow
slow = slow.next
# 断开链接到中点的link
prev.next = None
root = TreeNode(slow.val)
# 递归生成子树
root.left = self.sortedListToBST(head)
root.right = self.sortedListToBST(slow.next)
return root
def test_countNodes(self):
from solution_0222 import Solution
from utils import TreeNode
solution = Solution()
root = TreeNode(1, TreeNode(2), TreeNode(3))
root.left.add_left(4)
root.left.add_right(5)
root.right.add_left(6)
self.assertEqual(solution.countNodes(root), 6)
def test_solution():
s = Solution()
tree1 = TreeNode(1, TreeNode(3, TreeNode(5)), TreeNode(2))
tree2 = TreeNode(2, TreeNode(1, None, TreeNode(4)),
TreeNode(3, None, TreeNode(7)))
tree3 = s.mergeTrees(tree1, tree2)
print(tree3)
def test_solution():
s = Solution()
assert s.isSameTree(tree, tree) == True
p = TreeNode(1, TreeNode(2), TreeNode(3))
q = TreeNode(1, TreeNode(2), TreeNode(3))
assert s.isSameTree(p, q) == True
p = TreeNode(1, TreeNode(2))
p = TreeNode(1, None, TreeNode(2))
assert s.isSameTree(p, q) == False
def test_inorder_traversal(self):
# 1
# \
# 2
# /
# 3
root = TreeNode(1)
root.right = TreeNode(2)
root.right.left = TreeNode(3)
self.assertListEqual([1, 3, 2], inorder_traversal_recursive(root))
self.assertListEqual([1, 3, 2], inorder_traversal_iterative(root))
def op(start, end):
if start == end:
return TreeNode(nums[start])
elif end - start == 1:
root = TreeNode(nums[start])
root.right = TreeNode(nums[end])
return root
else:
pivot = (start + end) / 2
root = TreeNode(nums[pivot])
root.left = op(start, pivot - 1)
root.right = op(pivot + 1, end)
return root
def test_findTilt():
t1 = TreeNode(1)
t2 = TreeNode(2)
t3 = TreeNode(3)
t1.left = t2
t1.right = t3
assert findTilt(t1) == 1, findTilt(t1)
t4 = TreeNode(4)
t5 = TreeNode(5)
t2.left = t4
t3.left = t5
assert findTilt(t1) == 11, findTilt(t1)
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder:
return None
if len(preorder) == 1:
return TreeNode(preorder[0])
root = TreeNode(preorder[0])
index = inorder.index(root.val)
left_inorder = inorder[0:index]
right_inorder = inorder[index + 1:]
left_preorder = preorder[1:index + 1]
right_preorder = preorder[index + 1:]
root.left = self.buildTree(left_preorder, left_inorder)
root.right = self.buildTree(right_preorder, right_inorder)
return root
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
if not inorder:
return None
if len(inorder) == 1:
return TreeNode(inorder[0])
root = TreeNode(postorder[-1])
index = inorder.index(root.val)
left_inorder = inorder[0:index]
right_inorder = inorder[index + 1:]
left_post_order = postorder[0:index]
right_post_order = postorder[index:-1]
root.left = self.buildTree(left_inorder, left_post_order)
root.right = self.buildTree(right_inorder, right_post_order)
return root
def test_binaryTreePaths(self):
from solution_0257 import Solution
from utils import TreeNode
solution = Solution()
root1 = TreeNode(1, TreeNode("2"), TreeNode("3"))
root1.left.right = TreeNode("5")
root2 = TreeNode("1")
self.assertListEqual(solution.binaryTreePaths(root1),
["1->2->5", "1->3"])
self.assertListEqual(solution.binaryTreePaths(root2), ["1"])
def test_solution():
tree = TreeNode(5,
TreeNode(4,
TreeNode(11,
TreeNode(7), TreeNode(2))),
TreeNode(8,
TreeNode(13), TreeNode(4, TreeNode(1))))
print(tree)
s = Solution()
assert s.hasPathSum(tree, 22) == False
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
"""
:param nums: 从小大大排好序了
"""
if not nums or not len(nums):
return None
if len(nums) == 1:
return TreeNode(nums[0])
mid = (0 + len(nums)) // 2
root = TreeNode(nums[mid])
root.left = self.sortedArrayToBST(nums[:mid])
root.right = self.sortedArrayToBST(nums[mid + 1:])
return root
def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
tokens = data.split(',')
nodes = dict()
for token in tokens:
idx, val = token.split(':')
nodes[int(idx)] = TreeNode(int(val)) if val != '' else None
for idx in sorted(nodes.keys()):
if nodes[idx] is None:
continue
li = 2 * idx + 1
ri = 2 * idx + 2
if li in nodes:
nodes[idx].left = nodes[li]
if ri in nodes:
nodes[idx].right = nodes[ri]
return nodes[0]
def buildTree(preorder: 'list[int]', inorder: 'list[int]') -> TreeNode:
if inorder:
ind = inorder.index(preorder.pop(0))
root = TreeNode(inorder[ind])
root.left = buildTree(preorder, inorder[0:ind])
root.right = buildTree(preorder, inorder[ind + 1:])
return root
def helper(s):
cur = next(s)
if cur == "#": return
node = TreeNode(cur)
node.left = helper(s)
node.right = helper(s)
return node
def node_from_preorder(p_i: int, p_j: int) -> TreeNode:
"""
p_i and p_j is left and right bounds for preorder list
If bounds not valid (list not empty) -> return null
Create node from left element in preorder
With binary search search for first element which index in inorder is greater than node's
Link node created with bounds p_i + 1 (miss first element) and left as left child
Link node created with bound left and p_j as right child
Return node
"""
if p_i >= p_j:
return None
node = TreeNode(preorder[p_i])
left, right = p_i + 1, p_j - 1
while left <= right:
mid = (left + right) // 2
if indices[preorder[mid]][1] > indices[node.val][1]:
right = mid - 1
else:
left = mid + 1
node.left = node_from_preorder(p_i + 1, left)
node.right = node_from_preorder(left, p_j)
return node
def build(stop):
if inorder and inorder[-1] != stop:
root = TreeNode(preorder.pop())
root.left = build(root.val)
inorder.pop()
root.right = build(stop)
return root
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
if len(nums) == 0:
return None
i = (len(nums) - 1) // 2
root = TreeNode(nums[i])
root.left = self.sortedArrayToBST(nums[:i])
root.right = self.sortedArrayToBST(nums[i + 1:])
return root
def help(nums, l, h):
m = (l + h) // 2
node = TreeNode(nums[m])
if l <= m - 1:
node.left = help(nums, l, m - 1)
if m + 1 <= h:
node.right = help(nums, m + 1, h)
return node
def initialize(self):
""" Makes the frequency dict, list and encoding tree."""
self.freq_dict = self._mk_freq_dict()
self.freq_list = list()
for word in self.freq_dict:
self.freq_list.append(TreeNode(self.freq_dict[word], content=word))
self.encode_tree = self._mk_encode_tree()
self.encode_dict = self._mk_encode_dict()
def deserialize_tree_util(nodes):
val = nodes.pop()
if val == '$':
return None
root = TreeNode(int(val))
root.left = deserialize_tree_util(nodes)
root.right = deserialize_tree_util(nodes)
return root
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if len(preorder) == 0:
return None
mid = inorder.index(preorder[0])
t = TreeNode(preorder[0])
t.left = self.buildTree(preorder[1:mid + 1], inorder[:mid])
t.right = self.buildTree(preorder[mid + 1:], inorder[mid + 1:])
return t
def min_height_bst_from_sorted_array(A):
if not A:
return None
mid = len(A) / 2
root = TreeNode(A[mid])
root.left = min_height_bst_from_sorted_array(A[:mid])
root.right = min_height_bst_from_sorted_array(A[mid + 1:])
return root
def sorted_array2bst(nums):
if not nums:
return None
mid = len(nums) // 2
root = TreeNode(nums[mid])
root.left = sorted_array2bst(nums[:mid])
root.right = sorted_array2bst(nums[mid+1:])
return root
def addToTree(arr, start, end):
if end < start:
return None
mid = (start + end) // 2
n = TreeNode(arr[mid])
n.left = addToTree(arr, start, mid - 1)
n.right = addToTree(arr, mid + 1, end)
return n
def sortedArrayToBST(self, nums: List[int]):
if not nums:
return
mid = len(nums) // 2
root = TreeNode(nums[mid])
root.left = self.sortedArrayToBST(nums[:mid])
root.right = self.sortedArrayToBST(nums[mid + 1:])
return root
def recoverFromPreorder(self, S: str) -> TreeNode:
# AC 思路如下：
# 保存每一层的节点，由于是深度遍历，父节点必定是上一层的最后一个。
# 依次遍历得到深度和数值，
# 根据深度得到父节点，如果父节点的左节点为空，赋值给左节点，否则给右节点
if not S:
return None
root = None
stacks = []
depth = 0
num_str = ''
for c in S:
if c == '-':
if num_str:
new_node = TreeNode(int(num_str))
if not stacks:
root = new_node
stacks.append([root])
else:
father_node = stacks[depth - 1][-1]
if father_node.left is None:
father_node.left = new_node
else:
father_node.right = new_node
if len(stacks) < depth + 1:
stacks.append([new_node])
else:
stacks[depth].append(new_node)
depth = 1
num_str = ''
else:
depth += 1
else:
num_str += c
new_node = TreeNode(int(num_str))
if root is None:
return new_node
father_node = stacks[depth - 1][-1]
if father_node.left is None:
father_node.left = new_node
else:
father_node.right = new_node
return root
def dfs(low, high):
if low > high:
return [None]
trees = []
for i in range(low, high + 1):
left_set = dfs(low, i - 1)
right_set = dfs(i + 1, high)
trees += [TreeNode(i, left, right) for left in left_set for right in right_set]
return trees
def buildTree(postorder, inorder):
if not postorder or not inorder:
return None
tree_val = postorder[-1]
root = TreeNode(tree_val)
left_index = inorder.index(tree_val)
root.left = buildTree(postorder[:left_index], inorder[:left_index])
root.right = buildTree(postorder[left_index:-1], inorder[left_index + 1:])
return root
