"""
def flatten(root):
if root.left and root.right:
left_head, left_tail = flatten(root.left)
right_head, right_tail = flatten(root.right)
root.left = None
root.right = left_head
left_tail.right = right_head
return root, right_tail
elif root.left:
left_head, left_tail = flatten(root.left)
root.left = None
root.right = left_head
return root, left_tail
elif root.right:
right_head, right_tail = flatten(root.right)
root.right = right_head
return root, right_tail
else:
return root, root
if root:
flatten(root)
root = list_to_tree([1, 2, 5, 3, 4, None, 6])
root = list_to_tree([1, 2, None, 3])
Solution().flatten(root)
print tree_to_list(root)
self.right = None
class Solution(object):
def widthOfBinaryTree(self, root):
"""
:type root: TreeNode
:rtype: int
"""
if root == None: return 0
ans = 1
q = [root]
while q:
temp = []
for node in q:
temp.append(node.left if node else None)
temp.append(node.right if node else None)
i, j = 0, len(temp) - 1
while i <= j and temp[i] == None: i += 1
while i <= j and temp[j] == None: j -= 1
temp = temp[i:j + 1]
ans = max(len(temp), ans)
q = temp
return ans
root = list_to_tree([1, 3, 2, 5, 3, None, 9])
print Solution().widthOfBinaryTree(root)
# if k == 0:
# return root.val
# root = root.right
# У«░тйЋУіѓуѓ╣тидтГљТаЉуџёу╗Њуѓ╣СИфТЋ░
# The optimal runtime complexity is O(height of BST).
# But pre-process is neccesary
def get_nodes_num(node):
if node.left: get_nodes_num(node.left)
if node.right: get_nodes_num(node.right)
node.nodes_num = (node.left.nodes_num if node.left else 0) + (
node.right.nodes_num if node.right else 0) + 1
get_nodes_num(root)
node = root
while True:
left_count = node.left.nodes_num if node.left else 0
# print "**", node.val, left_count
if k == left_count + 1:
return node.val
if k < left_count + 1:
node = node.left
if k >= left_count + 1:
k -= left_count + 1
node = node.right
arr = [4, 2, 6, 1, 3, 5, 7]
root = list_to_tree(arr)
print Solution().kthSmallest(root, 2)
self.left = None
self.right = None
class Solution(object):
def getMinimumDifference(self, root):
"""
:type root: TreeNode
:rtype: int
"""
self.last_num = None
self.ans = float("inf")
def inorder(node):
if node != None and self.ans != 0:
inorder(node.left)
if self.last_num != None:
self.ans = min(self.ans, abs(node.val - self.last_num))
self.last_num = node.val
else:
self.last_num = node.val
inorder(node.right)
inorder(root)
return self.ans
root = list_to_tree([1, None, 2, 3])
print Solution().getMinimumDifference(root)
class Solution(object):
def recoverTree(self, root):
"""
:type root: TreeNode
:rtype: void Do not return anything, modify root in-place instead.
"""
self.last = None
self.first = self.second = None
def inorder(root):
if root:
inorder(root.left)
if self.last != None:
if self.first == None and self.last.val >= root.val :
self.first = self.last
if self.first != None and self.last.val >= root.val:
self.second = root
self.last = root
print root.val
inorder(root.right)
inorder(root)
print self.first.val, self.second.val
self.first.val, self.second.val = self.second.val, self.first.val
root = list_to_tree([2, 3, 1])
Solution().recoverTree(root)
print inorder_traversal(root)
self.ans = max(self.ans, res)
return res
if root == None: return 0
def inorder(node):
if node:
foo(node)
inorder(node.left)
inorder(node.right)
inorder(root)
return self.ans
root = list_to_tree([1, 4, 5, 4, 4, 5])
root = list_to_tree([
26, 26, 26, 26, 26, 24, 26, 25, 25, 25, 27, 23, 25, 25, 27, 24, 26, 24, 26,
24, 24, None, 28, None, None, 26, None, None, 26, 26, 28, 25, None, 25, 27,
None, None, None, None, None, 23, None, None, 29, 27, None, None, None,
None, 25, None, 27, 27, 24, 26, 24, 26, 26, 26, None, 22, 28, None, 26, 26,
None, None, 26, None, 28, 28, 25, None, None, None, 25, 25, 25, 27, 25, 25,
27, 25, None, None, None, None, None, None, None, 27, 27, 27, None, None,
27, 29, 24, 26, 26, 26, None, 26, None, 26, None, None, None, 24, 24, 24,
None, 26, 24, 26, None, None, None, 26, None, None, None, 28, None, 30,
None, 23, 27, None, None, None, None, None, None, None, None, None, None,
None, 23, 25, 25, 25, 27, 25, 23, 25, None, None, None, None, None, None,
29, None, None, None, 26, None, 22, None, None, 26, 24, 26, None, 26, 28,
None, None, 26, 22, None, None, None, None, None, None, None, None, None,
None, 25, 23, None, None, None, None, 27
])
self.memo = {}
def foo(node):
res = 1
if node.left:
left = self.memo(node.left) if node.left in self.memo else foo(node.left)
else:
left = 0
if node.right:
right = self.memo(node.right) if node.right in self.memo else foo(node.right)
else:
right = 0
if left and node.left.val == node.val + 1:
res = max(res, left + 1)
if right and node.right.val == node.val + 1:
res = max(res, right + 1)
self.ans = max(self.ans, res)
self.memo[node] = res
return res
foo(root)
# for k, v in self.memo.items():
# print k.val, v
# print self.memo
return self.ans
root = list_to_tree([1, None, 3, 2, 4, None, None, None, 5])
print Solution().longestConsecutive(root)
elif node.right:
parent, p = node, node.right
while p.left:
parent = p
p = p.left
if parent != node:
parent.left = p.right
else:
parent.right = p.right
node.val = p.val
return root
elif parent:
if parent.left == node: parent.left = None
if parent.right == node: parent.right = None
return root
else:
return None
else:
return root
root = list_to_tree([5, 3, 6, 2, 4, None, 7])
root = list_to_tree([2, 1, 3])
root = list_to_tree([3, 2, 4, 1])
key = 3
root = Solution().deleteNode(root, key)
print tree_to_list(root)
:type root: TreeNode
:rtype: TreeNode
"""
if root == None: return None
def get_sibling_and_parent(node):
if node.left:
node.left.sibling = node.right
node.left.parent = node
get_sibling_and_parent(node.left)
get_sibling_and_parent(root)
node = root
while node.left:
node = node.left
new_root = node
while node != root:
node.left = node.sibling
node.right = node.parent
node = node.parent
node.left = node.right = None
return new_root
root = list_to_tree([1, 2, 3, 4, 5])
root = list_to_tree([])
new_root = Solution().upsideDownBinaryTree(root)
print tree_to_list(new_root)
:rtype: bool
"""
def inorder_traversal(root):
arr = []
def inorder(node):
if node:
inorder(node.left)
arr.append(node.val)
inorder(node.right)
inorder(root)
return arr
arr = inorder_traversal(root)
d = {}
for num in arr:
d.setdefault(num, 0)
d[num] += 1
for num in arr:
if k - num != num and k - num in d:
return True
if k - num == num and k - num in d and d[k - num] > 1:
return True
return False
root = list_to_tree([1])
k = 2
print Solution().findTarget(root, k)
if node.left:
edges[node].add(node.left)
edges[node.left].add(node)
q.append(node.left)
if node.right:
edges[node].add(node.right)
edges[node.right].add(node)
q.append(node.right)
q = deque([sourceNode])
visited = set()
# print sourceNode.val
# for u in edges:
# for v in edges[u]:
# print u.val, v.val
while q:
u = q.popleft()
visited.add(u)
if u.left == u.right == None:
return u.val
for v in edges[u]:
if v not in visited:
q.append(v)
root = list_to_tree([1, 3, 2])
# root = list_to_tree([1])
k = 1
print Solution().findClosestLeaf(root, k)
:type p: TreeNode
:type q: TreeNode
:rtype: TreeNode
"""
self.ans = None
def has(node, p, q):
if self.ans == None:
left = right = False
if node == None: return (False, False)
if node == p:
left = True
if node == q:
right = True
a1, b1 = has(node.left, p, q)
a2, b2 = has(node.right, p, q)
res = (left or a1 or a2, right or b1 or b2)
if self.ans == None and res == (True, True):
self.ans = node.val
return res
else:
return (False, False)
has(root, p, q)
return self.ans
root = list_to_tree([3, 5, 1, 6, 2, 0, 8, None, None, 7, 4])
print Solution().lowestCommonAncestor(root, 5, 4)
def countUnivalSubtrees(self, root):
"""
:type root: TreeNode
:rtype: int
"""
d = {}
def foo(node):
if node == None: return True
if node in d:
return d[node]
if (node.left and node.left.val == node.val or node.left
== None) and (node.right and node.right.val == node.val
or node.right == None):
d[node] = foo(node.left) and foo(node.right)
return d[node]
else:
foo(node.left)
foo(node.right)
d[node] = False
return False
foo(root)
return d.values().count(True)
root = list_to_tree([5, 1, 5, 5, 5, None, 5])
root = list_to_tree([1])
print Solution().countUnivalSubtrees(root)
print leftBoundary
# leaves
s = []
leaves = []
node = root
while node or s:
if node:
s.append(node)
node = node.left
else:
node = s.pop()
if node.left == node.right == None and node != root:
leaves.append(node.val)
node = node.right
print leaves
# right
rightBoundary = []
node = root.right
while node and (node.left or node.right):
rightBoundary.append(node.val)
node = node.right if node.right else node.left
print rightBoundary
return leftBoundary + leaves + rightBoundary[::-1]
root = list_to_tree([1, 2, 3, 4, 5, 6, None, None, None, 7, 8, 9, 10])
root = list_to_tree([1, 2, 7, 3, 5, None, 6, 4])
root = list_to_tree([1])
print Solution().boundaryOfBinaryTree(root)
# arr = []
# def postorder(node):
# if node:
# postorder(node.left)
# postorder(node.right)
# arr.append(node.val)
# postorder(root)
# return arr
# iterative
if root == None: return []
left_viewed = set()
right_viewed = set()
s = [root]
ans = []
while s:
node = s[-1]
if node.left and (not node in left_viewed):
s.append(node.left)
left_viewed.add(node)
elif node.right and (not node in right_viewed):
s.append(node.right)
right_viewed.add(node)
else:
node = s.pop()
ans.append(node.val)
return ans
root = list_to_tree([1, 2, 3, None, 4, None, 5])
print Solution().postorderTraversal(root)
# self.right = None
class Solution(object):
def countNodes(self, root):
"""
:type root: TreeNode
:rtype: int
"""
def height(node):
res = -1
while node:
node = node.left
res += 1
return res
def count(root):
if root == None: return 0
left_height = height(root.left)
right_height = height(root.right)
if left_height == right_height:
return 1 + 2**(left_height + 1) - 1 + count(root.right)
else:
return 1 + count(root.left) + 2**(right_height + 1) - 1
return count(root)
root = list_to_tree([1, 2, 3, 4, 5, 6])
print Solution().countNodes(root)
for node in ans[-1]:
left = node.left if node else None
right = node.right if node else None
temp.append(left)
temp.append(right)
if left != None or right != None:
flag = True
if flag: ans.append(temp)
return ans
ans = levelTraverseFromRoot(root)
ans = [[str(node.val) if node else "" for node in row] for row in ans]
level = len(ans)
nodes_count = 2**level - 1
inds = [nodes_count / 2]
res = [[""] * (2**level - 1) for _ in xrange(level)]
for i, row in enumerate(ans):
for j, node in enumerate(row):
res[i][inds[j]] = node
new_inds = []
temp = 2**(level - i - 2)
for ind in inds:
new_inds.append(ind - temp)
new_inds.append(ind + temp)
inds = new_inds
return res
root = list_to_tree([1, 2, 5, 3, None, None, None, 4])
print Solution().printTree(root)
self.val = x
self.left = None
self.right = None
class Solution(object):
def convertBST(self, root):
"""
:type root: TreeNode
:rtype: TreeNode
"""
self.inorder_nodes_arr = []
self.total = 0
def inorder(node):
if node:
inorder(node.left)
self.inorder_nodes_arr.append(node)
self.total += node.val
inorder(node.right)
inorder(root)
for node in self.inorder_nodes_arr:
self.total -= node.val
node.val += self.total
return root
root = list_to_tree([5, 5, 5])
print tree_to_list(Solution().convertBST(root))
def pathSum(self, root, sum):
"""
:type root: TreeNode
:type sum: int
:rtype: List[List[int]]
"""
from copy import copy
def dfs(node, sum, path):
path.append(node.val)
sum -= node.val
if node.left == node.right == None and sum == 0:
ans.append(copy(path))
else:
if node.left:
dfs(node.left, sum, path)
if node.right:
dfs(node.right, sum, path)
path.pop()
ans = []
if root:
dfs(root, sum, [])
return ans
root = list_to_tree([5, 4, 8, 11, None, 13, 4, 7, 2, None, None, 5, 1])
sum = 22
print Solution().pathSum(root, sum)
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution(object):
def tree2str(self, t):
"""
:type t: TreeNode
:rtype: str
"""
def foo(node):
if node:
if node.right:
return str(node.val) + "(" + foo(node.left) + ")" + "(" + foo(node.right) + ")"
if node.left and (not node.right):
return str(node.val) + "(" + foo(node.left) + ")"
if (not node.left) and (not node.right):
return str(node.val)
else:
return ""
return foo(t)
t = list_to_tree([1, 2, 3, None, 4])
print Solution().tree2str(t)
class Solution(object):
def verticalOrder(self, root):
"""
:type root: TreeNode
:rtype: List[List[int]]
"""
if root == None: return []
from collections import deque, defaultdict
lo = hi = 0
ans = defaultdict(list)
q = deque([(root, 0)])
while q:
node, level = q.popleft()
ans[level].append(node.val)
if node.left:
lo = min(lo, level - 1)
q.append((node.left, level - 1))
if node.right:
hi = max(hi, level + 1)
q.append((node.right, level + 1))
return [ans[i] for i in xrange(lo, hi + 1)]
root = list_to_tree([3, 9, 8, 4, 0, 1, 7, None, None, None, 2, 5])
print Solution().verticalOrder(root)