def recurse(depth):
nonlocal index
# count the number of dashes starting from index position
dash_count = 0
while index + dash_count < len(S) and S[index + dash_count] == '-':
dash_count += 1
# number of dashes should be same as the depth value
if dash_count != depth:
return None
# find the position+1 where the integer value ends
int_end = index + dash_count
while int_end < len(S) and S[int_end] != '-':
int_end += 1
# convert integer value from string to int type
int_value = int(S[index+dash_count:int_end])
# move index forward to the values read so far
index = int_end
# create a new node with this integer value
root = TreeNode(int_value)
# make recursive calls for left and right child (index is being tracked in global variable)
root.left = recurse(depth+1)
root.right = recurse(depth+1)
return root
def bst(v):
if not v:
return None
mid = len(v) // 2
root = TreeNode(v[mid])
root.left = bst(v[:mid])
root.right = bst(v[mid + 1:])
return root
def create_tree_helper(self, seq):
if not seq:
return None
mid = (len(seq) - 1) / 2
n = TreeNode(seq[mid])
n.left = self.create_tree_helper(seq[:mid])
n.right = self.create_tree_helper(seq[mid + 1:])
return n
def create_tree_helper(self,seq):
if not seq:
return None
mid=(len(seq)-1)/2
n=TreeNode(seq[mid])
n.left=self.create_tree_helper(seq[:mid])
n.right=self.create_tree_helper(seq[mid+1:])
return n
def copy(root):
if not root:
return None
node = TreeNode(root.val)
if root.left:
node.left = copy(root.left)
if root.right:
node.right = copy(root.right)
return node
def sortedArrayToBST_helper(nums, low, high):
if low > high: return None
if low == high:
return TreeNode(nums[low])
mid = (low + high) // 2
root = TreeNode(nums[mid])
root.left = sortedArrayToBST_helper(nums, low, mid - 1)
root.right = sortedArrayToBST_helper(nums, mid + 1, high)
return root
def helper(io, po):
if not io and not po: return None
root = TreeNode(po[-1])
if len(po) == 1 or len(io) == 1: return root
indexL = io.index(po[-1])
indexR = len(io) - (indexL+1)
root.left = helper(io[:indexL], po[:-(indexR+1)])
root.right = helper(io[indexL+1:], po[-(indexR+1):-1])
return root
def convert2BST(arr):
n = len(arr)
if n == 0: return None
if n == 1: return TreeNode(value=arr[0])
idx = n // 2
root = TreeNode(value=arr[idx],
left=convert2BST(arr[:idx]),
right=convert2BST(arr[idx + 1:]))
return root
def helper(node):
if not node:
t = TreeNode(val)
return t
if node.val < val:
t = TreeNode(val)
t.left = node
return t
node.right = helper(node.right)
return node
def reverse_binary_tree(root):
dummy_root = TreeNode(0)
while root:
right_child = root.right
left_child = root.left
root.left = dummy_root.left
dummy_root.left = root
root.right = left_child
root = right_child
return dummy_root.left
def constructMaximumBinaryTree(self, nums):
# Write your code here
if not nums: return None
mx, idx = 0, 0
for i in range(len(nums)):
if nums[i] > mx:
mx = nums[i]
idx = i
root = TreeNode(nums[idx])
root.left = self.constructMaximumBinaryTree(nums[:idx])
root.right = self.constructMaximumBinaryTree(nums[idx + 1:])
return root
def createBSTWithMinimalHeight(array): lengthArray = len(array) if lengthArray == 0: return None elif lengthArray == 1: return TreeNode(array[0]) else: middle = lengthArray / 2 root = TreeNode(array[middle]) root.left = createBSTWithMinimalHeight(array[:middle]) root.right = createBSTWithMinimalHeight(array[middle + 1:]) return root
def createBSTWithMinimalHeight(array):
lengthArray = len(array)
if lengthArray == 0:
return None
elif lengthArray == 1:
return TreeNode(array[0])
else:
middle = lengthArray / 2
root = TreeNode(array[middle])
root.left = createBSTWithMinimalHeight(array[:middle])
root.right = createBSTWithMinimalHeight(array[middle + 1:])
return root
def bstFromPreorder(self, preorder):
"""
:type preorder: List[int]
:rtype: TreeNode
"""
if not preorder: return None
i, val = 1, preorder[0]
while i < len(preorder):
if preorder[i] > val: break
i += 1
node = TreeNode(val)
node.left = self.bstFromPreorder(preorder[1:i])
node.right = self.bstFromPreorder(preorder[i:])
return node
def constructMinimumBinaryTree(self, nums):
"""
:type nums: List[int]
:rtype: TreeNode
"""
stack = []
for num in nums:
node = TreeNode(num)
while stack and stack[-1].val > num:
node.left = stack[-1]
stack.pop()
if stack: stack[-1].right = node
stack.append(node)
print(num, len(stack))
return stack[0]
def buildTree(preorder, inorder):
if not inorder: return None
if not preorder: return None
node = preorder[0]
ind_root_in = inorder.index(node)
len_left_tree = ind_root_in
root_node = TreeNode(node)
root_node.left = buildTree(preorder[1:len_left_tree + 1],
inorder[0:len_left_tree])
root_node.right = buildTree(preorder[len_left_tree + 1:],
inorder[ind_root_in + 1:])
return root_node
def mergeTrees(self, root1, root2):
"""
:type root1: TreeNode
:type root2: TreeNode
:rtype: TreeNode
"""
if not root1 and not root2:
return None
elif not root1:
return root2
elif not root2:
return root1
else:
node = TreeNode(root1.val + root2.val)
node.left = self.mergeTrees(root1.left, root2.left)
node.right = self.mergeTrees(root1.right, root2.right)
return node
def genTreeList(l, r):
tlis = []
if l > r:
tlis.append(None)
return tlis
if l == r:
tlis.append(TreeNode(l))
return tlis
for i in range(l, r + 1):
left = genTreeList(l, i - 1)
right = genTreeList(i + 1, r)
for lnode in left:
for rnode in right:
root = TreeNode(i)
root.left = lnode
root.right = rnode
tlis.append(root)
return tlis
def dfs(s, depth, i):
nDashes = 0
while i + nDashes < len(s) and s[i + nDashes] == '-':
nDashes += 1
if nDashes != depth:
return None
i += depth
start = i
while i < len(s) and s[i].isdigit():
i += 1
val = int(s[start:i])
root = TreeNode(val)
root.left = dfs(s, depth + 1, i)
root.right = dfs(s, depth + 1, i)
return root
def createBinaryTree(self, descriptions: List[List[int]]) -> Optional[TreeNode]:
m, roots = {}, set()
def conn_child(par, chi, left):
if left == 0: par.right = chi
else: par.left = chi
for vpar,vchi,left in descriptions:
if vpar in m:
if vchi not in m:
m[vchi] = TreeNode(vchi)
elif vchi in m:
m[vpar] = TreeNode(vpar)
else:
m[vchi] = TreeNode(vchi)
m[vpar] = TreeNode(vpar)
conn_child(m[vpar], m[vchi], left)
roots.add(vchi)
for vpar,_,_ in descriptions:
if vpar not in roots:
return m[vpar]
return None
def Deserialize(self, s):
self.flag += 1
lis = s.split(',')
if self.flag >= len(s):
return None
root = None
if lis[self.flag] != '#':
root = TreeNode(int(lis[self.flag]), left=self.Deserialize(s),\
right=self.Deserialize(s))
return root
def convert2BST_link(node, start, end):
if start > end or node is None:
return None, node
mid = (start + end) // 2
left_tree, node = convert2BST_link(node, start, mid - 1)
root = TreeNode(value=node.value)
node = node.next
right_tree, node = convert2BST_link(node, mid + 1, end)
root.left = left_tree
root.right = right_tree
return root, node
def test_depth(self):
temp = BinaryTree()
self.assertEqual(temp.depth(temp.root), 0)
temp.root = TreeNode(10)
self.assertEqual(temp.depth(temp.root), 1)
temp.initExampleTree()
self.assertEqual(temp.depth(temp.root), 3)
temp.initLeftLeaningTree()
self.assertEqual(temp.depth(temp.root), 11)
temp.initRightLeaningTree()
self.assertEqual(temp.depth(temp.root), 11)
def helper(s, d):
if not s: return None
# s1 = s.split('-'*d)
i = 0
while i < len(s) and s[i].isdigit():
i += 1
# print(s, s[:i])
root = TreeNode(int(s[:i]))
if i == len(s): return root
# j = i
while i < len(s) and s[i] == '-':
i += 1
idx = search(s[i:], d)
print(d, i, '#'+s[i:]+'#', idx)
if idx != -1:
root.left = helper(s[i:i+idx], d+1)
root.right = helper(s[i+idx+d:], d+1)
else:
root.left = helper(s[i:], d+1)
return root
def sortedListToBST(self, head):
"""
:type head: ListNode
:rtype: TreeNode
"""
"""
if not head: return None
if not head.next: return TreeNode(head.val)
slow, fast, pre = head, head, None
while fast and fast.next:
pre, slow, fast = slow, slow.next, fast.next.next
pre.next = None # cut off the left half
root = TreeNode(slow.val)
root.left = self.sortedListToBST(head)
root.right = self.sortedListToBST(slow.next)
return root
"""
def findMiddle(node):
slow, fast, pre = node, node, None
while fast and fast.next:
pre = slow
slow = slow.next
fast = fast.next.next
return pre
if not head: return None
nxt = head.next
if not nxt: return TreeNode(head.val)
middle = findMiddle(head)
print(middle.val)
lnode, middle = middle, middle.next
rnode = middle.next if middle else None
lnode.next = None
root = TreeNode(middle.val)
root.left = self.sortedListToBST(head)
root.right = self.sortedListToBST(rnode)
return root
def add_node_helper(self, node, val):
if val<node.data:
#if left subtree is not None, go to right subtree
if node.left:
self.add_node_helper(node.left,val)
#if left subtree is None, then found the place to insert
else:
new_node=TreeNode(val)
node.left=new_node
new_node.parent=node
elif val>node.data:
#if right subtree is not None, go to right subtree
if node.right:
self.add_node_helper(node.right,val)
#if right subtree is None, then found the place to insert
else:
new_node=TreeNode(val)
node.right=new_node
new_node.parent=node
else:
print 'Found same value, please check the input!'
raise IndexError(val)
def deserialize(self, data):
"""Decodes your encoded data to tree.
:type data: str
:rtype: TreeNode
"""
if not data: return None
nodes = data.split(',')
root = TreeNode(int(nodes[0]))
q = deque([root])
index = 1
while q:
node = q.popleft()
if nodes[index] is not '#':
node.left = TreeNode(int(nodes[index]))
q.append(node.left)
index += 1
if nodes[index] is not '#':
node.right = TreeNode(int(nodes[index]))
q.append(node.right)
index += 1
return root
def generateTrees(self, n):
"""
:type n: int
:rtype: List[TreeNode]
"""
if n == 1:
return [TreeNode(n)]
ans = []
subtrees = self.generateTrees(n - 1)
def copy(root):
if not root:
return None
node = TreeNode(root.val)
if root.left:
node.left = copy(root.left)
if root.right:
node.right = copy(root.right)
return node
#print(n, len(subtrees))
for st in subtrees:
# current n as root with subtree as left child
root = TreeNode(n)
root.left = copy(st)
ans.append(root)
# current n as far right leaf child
root = copy(st)
node = root
while node.right:
node = node.right
node.right = TreeNode(n)
ans.append(root)
node = st.right
lev = 1
while node:
root = copy(st)
newnode = root
cur = 1
while cur < lev:
newnode = newnode.right
cur += 1
newleft = newnode.right
newnode.right = TreeNode(n)
newnode.right.left = newleft
ans.append(root)
node = node.right
lev += 1
return ans
def deserialize_bfs(data):
if data == '': return None
data = data.split(',')
queue = [None if num == '#' else TreeNode(int(num)) for num in data]
front = 0
index = 1
root = queue[front]
while index < len(queue) and front < len(queue):
curr = queue[front]
front += 1
if curr is None: continue
if index >= len(queue): return root
curr.left = queue[index]
index += 1
if index >= len(queue): return root
curr.right = queue[index]
index += 1
return root
def test_isBalanced(self):
temp = BinaryTree()
self.assertEqual(temp.isBalanced(temp.root), True)
temp.root = TreeNode(10)
self.assertEqual(temp.isBalanced(temp.root), True)
temp.initExampleTree()
self.assertEqual(temp.isBalanced(temp.root), True)
temp.initLeftLeaningTree()
self.assertEqual(temp.isBalanced(temp.root), False)
temp.initRightLeaningTree()
self.assertEqual(temp.isBalanced(temp.root), False)
temp.root = TreeNode(1)
temp.root.leftNode = TreeNode(2)
temp.root.rightNode = TreeNode(2)
temp.root.leftNode.leftNode = TreeNode(3)
temp.root.leftNode.leftNode.leftNode = TreeNode(4)
self.assertEqual(temp.isBalanced(temp.root), False)
def constructFromPrePost(self, pre, post):
"""
:type pre: List[int]
:type post: List[int]
:rtype: TreeNode
"""
if len(pre) == 0: return None
node = TreeNode(pre[0])
if len(pre) == 1: return node
if pre[1] != post[-2]:
i = post.index(pre[1])
j = pre.index(post[-2])
node.left = self.constructFromPrePost(pre[1:j], post[:i + 1])
node.right = self.constructFromPrePost(pre[j:], post[i + 1:-1])
else:
node.left = self.constructFromPrePost(pre[1:], post[:-1])
node.right = None
return node
def add_node_helper(self, node, val):
if val < node.data:
#if left subtree is not None, go to right subtree
if node.left:
self.add_node_helper(node.left, val)
#if left subtree is None, then found the place to insert
else:
new_node = TreeNode(val)
node.left = new_node
new_node.parent = node
elif val > node.data:
#if right subtree is not None, go to right subtree
if node.right:
self.add_node_helper(node.right, val)
#if right subtree is None, then found the place to insert
else:
new_node = TreeNode(val)
node.right = new_node
new_node.parent = node
else:
print 'Found same value, please check the input!'
raise IndexError(val)
def test():
node1 = TreeNode(1)
node2 = TreeNode(2)
node3 = TreeNode(3)
node4 = TreeNode(4)
node5 = TreeNode(5)
node6 = TreeNode(6)
node7 = TreeNode(7)
root = node4
node4.addLeftChild(node2)
node2.addLeftChild(node1)
node2.addRightChild(node3)
node4.addRightChild(node6)
node6.addLeftChild(node5)
node6.addRightChild(node7)
node8 = TreeNode(8)
print "Passed" if findCommonAncestorHasParent(node1,
node3) == node2 else "Failed"
print "Passed" if findCommonAncestorHasParent(node1,
node5) == node4 else "Failed"
print "Passed" if findCommonAncestorHasParent(node1,
node4) == node4 else "Failed"
print "Passed" if findCommonAncestorHasParent(node1,
node8) == None else "Failed"
print "Passed" if findCommonAncestorWithoutParent(
root, node1, node3) == node2 else "Failed"
print "Passed" if findCommonAncestorWithoutParent(
root, node1, node5) == node4 else "Failed"
print "Passed" if findCommonAncestorWithoutParent(
root, node1, node4) == node4 else "Failed"
print "Passed" if findCommonAncestorWithoutParent(
root, node1, node8) == None else "Failed"
return []
result = []
def FindPathCore(root, path, currentNum):
currentNum += root.val
path.append(root)
flag = (root.left == None and root.right == None)
if currentNum == expectNum and flag:
onepath = []
for node in path:
onepath.append(node.val)
result.append(onepath)
if currentNum < expectNum:
if root.left:
FindPathCore(root.left, path, currentNum)
if root.right:
FindPathCore(root.right, path, currentNum)
path.pop()
FindPathCore(root, [], 0)
return result
if __name__ == "__main__":
node1 = TreeNode(4)
node2 = TreeNode(7)
node3 = TreeNode(5, left=node1, right=node2)
node4 = TreeNode(12)
root = TreeNode(10, left=node3, right=node4)
a = Solution()
print(a.FindPath(root, 22))
return True
# If one of them is non empty, violates isomorphism
if not t1 or not t2:
return False
# If data in a level are not same; violates isomorphism
if t1.data != t2.data:
return False
else:
case1 = (is_isomorphic(t1.left_node, t2.left_node) and
is_isomorphic(t1.right_node, t2.right_node))
case2 = (is_isomorphic(t1.left_node, t2.right_node) and
is_isomorphic(t1.right_node, t2.left_node))
return case1 or case2
if __name__ == "__main__":
bTree1 = TreeNode(1)
bTree1.left_node = TreeNode(2)
bTree1.right_node = TreeNode(3)
bTree1.left_node.left_node = TreeNode(4)
bTree1.left_node.right_node = TreeNode(5)
bTree1.right_node.left_node = TreeNode(6)
bTree1.left_node.right_node.left_node = TreeNode(7)
bTree1.left_node.right_node.right_node = TreeNode(8)
bTree2 = TreeNode(1)
bTree2.left_node = TreeNode(3)
bTree2.right_node = TreeNode(2)
bTree2.left_node.right_node = TreeNode(6)
bTree2.right_node.left_node = TreeNode(4)
bTree2.right_node.right_node = TreeNode(5)
bTree2.right_node.right_node.left_node = TreeNode(8)
def __init__(self, e):
self.height = 0 # New data field
TreeNode.__init__(self, e)
def test(): node1 = TreeNode(1) node2 = TreeNode(2) node3 = TreeNode(3) node4 = TreeNode(4) node5 = TreeNode(5) node6 = TreeNode(6) node7 = TreeNode(7) root = node4 node4.addLeftChild(node2) node2.addLeftChild(node1) node2.addRightChild(node3) node4.addRightChild(node6) node6.addLeftChild(node5) node6.addRightChild(node7) root.inOrderTraverse() print "Passed" if findSuccessor(node1) == node2 else "Failed" print "Passed" if findSuccessor(node4) == node5 else "Failed" print "Passed" if findSuccessor(node2) == node3 else "Failed" print "Passed" if findSuccessor(node3) == node4 else "Failed" print "Passed" if findSuccessor(node5) == node6 else "Failed" print "Passed" if findSuccessor(node7) == None else "Failed"
def test(): node1 = TreeNode(1) node2 = TreeNode(2) node3 = TreeNode(3) node4 = TreeNode(4) node5 = TreeNode(4) node6 = TreeNode(1) node7 = TreeNode(-1) node8 = TreeNode(5) root = node4 node4.addLeftChild(node2) node4.addRightChild(node6) node2.addLeftChild(node1) node2.addRightChild(node3) node6.addLeftChild(node5) node6.addRightChild(node7) node7.addLeftChild(node8) node5.addRightChild(TreeNode(5)) print allPossiblePaths(root, 9)
def test(): a = [1,2,3,4,5] root = createBSTWithMinimalHeight(a) print "Passed" if isBST(root) else "Failed" a = [1,2,6,4,5] root = createBSTWithMinimalHeight(a) print "Passed" if not isBST(root) else "Failed" root = TreeNode(3) node2 = TreeNode(2) root.left = node2 node2.right = TreeNode(4) root.right = TreeNode(5) print "Passed" if not isBST(root) else "Failed" root = TreeNode(3) node2 = TreeNode(2) root.left = node2 node2.right = TreeNode(3) root.right = TreeNode(5) print "Passed" if isBST(root) else "Failed" root = TreeNode(3) root.left = TreeNode(2) node5 = TreeNode(5) root.right = node5 node5.left = TreeNode(4) print "Passed" if isBST(root) else "Failed" root = TreeNode(3) root.left = TreeNode(2) node5 = TreeNode(5) root.right = node5 node5.left = TreeNode(2) print "Passed" if not isBST(root) else "Failed" root = TreeNode(3) root.left = TreeNode(2) node5 = TreeNode(5) root.right = node5 node5.left = TreeNode(3) print "Passed" if not isBST(root) else "Failed"
def printSpiral(node, level, flag):
if not node:
return
if level == 0:
print node.data,
elif level > 0:
if flag:
printSpiral(node.left_node, level - 1, flag)
printSpiral(node.right_node, level - 1, flag)
else:
printSpiral(node.right_node, level - 1, flag)
printSpiral(node.left_node, level - 1, flag)
if __name__ == "__main__":
bTree = TreeNode(1)
bTree.left_node = TreeNode(2)
bTree.right_node = TreeNode(3)
bTree.left_node.left_node = TreeNode(4)
bTree.left_node.right_node = TreeNode(5)
bTree.right_node.left_node = TreeNode(6)
bTree.left_node.left_node.left_node = TreeNode(12)
print "Reverse Level order traversal: ",
reverseLevelOrderTraversal(bTree)
print ""
print "*"*80
print "Reverse level order using recursion: "
reverseLevelOrderRecursion(bTree)
