""" 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)