def inOrderEx():

    tree = Tree()

    n1 = Node("T")
    n2 = Node("H")
    n3 = Node("N")
    n4 = Node("A")
    n5 = Node("U")
    n6 = Node("Y")
    n7 = Node("K")
    n8 = Node("O")

    n6.left = n7
    n6.right = n8

    n5.left = n6

    n3.left = n4
    n3.right = n5

    n2.left = n1
    n2.right = n3

    tree.root = n2

    return tree
Exemplo n.º 2
0
def postOrderEx():
    tree = Tree()
    n1 = Node('A')  # I
    n2 = Node('M')  # N
    n3 = Node('A')  # S
    n4 = Node('Z')  # C
    n5 = Node('O')  # R
    n6 = Node('N')  # E
    n7 = Node(' ')
    n8 = Node(' ')
    n9 = Node('<')
    n0 = Node('3')

    n0.left = n6
    n0.right = n9
    n6.left = n1
    n6.right = n5
    n5.left = n2
    n5.right = n4
    n4.right = n3
    n9.left = n8
    n8.right = n7

    tree.root = n0

    return tree
Exemplo n.º 3
0
def createMinimalBST(array, start, end):
    if (end < start):
        return None
    mid = (start + end) // 2
    node = Node(array[mid])
    node.left = createMinimalBST(array, start, mid - 1)
    node.right = createMinimalBST(array, mid + 1, end)
    return node
Exemplo n.º 4
0
def sortedArrToBST(arr,start,end):
	"""
		The inorder traverse of BFS is 
		the same as the sorted array
	"""
	if start > end:
		return None
	if start == end:
		return Node(arr[start])
	mid = (start + end)/2 + 1
	root = Node(arr[mid])
	root.left = sortedArrToBST(arr,start, mid-1)
	root.right = sortedArrToBST(arr, mid+1 , end)
	return root
Exemplo n.º 5
0
def main():
    # Driver code to build binary tree
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)

    print('###################')
    postOrder(root)
    print()
    print('###################')
    inOrder(root)
    print()
    print('###################')
    print(inOrder_stack(root))
    print('###################')
    preOrder(root)
    print('###################')
    print(height(root))
    print('###################')
    givenLevel(root, 3)
    print()
    givenLevel(root, 2)
    print()
    givenLevel(root, 1)
    print()
    givenLevel(root, 0)
    print('###################')
    levelOrder(root)
    print('###################')
    levelOrder_queue(root)
    print('###################')
    print(maxDepth(root))
    print('###################')
    print(diameter(root))
Exemplo n.º 6
0
from binaryTree import Node
from treeTraverse import *
node = Node(3)
node.left = Node(20)
node.right = Node(9)
node.left.left = Node(7)
node.left.right = Node(15)

node_list = preorderTraverse(node)
node_list.sort()
n = len(node_list)
print(node_list)


def arrToBST(arr, root):
    """
		just apply sorted array to BST
	"""
    if not root:
        return
    arrToBST(arr, root.left)
    root.val = arr[0]
    arr.pop(0)
    arrToBST(arr, root.right)


def binTreeToBST(root):
    if not root:
        return None
    arr = inorderTraverse(root)
    arr.sort()
Exemplo n.º 7
0
from binaryTree import Node

t1 = Node(1)
t1.left = Node(2)
t1.right = Node(3)

t2 = Node(1)
t2.left = Node(2)
t2.right = Node(3)


def treeToList(t):
    if t == None:
        return []
    result = [t.val]
    return result + treeToList(t.left) + treeToList(t.right)


def isSameTree(t, s):
    t_list = treeToList(t)
    s_list = treeToList(s)
    return s_list == t_list


def isSame(t, s):
    if not t and not s:
        return True
    if t and s:
        if t.val == s.val:
            return isSame(t.left, s.left) and isSame(t.right, s.right)
    return False
Exemplo n.º 8
0
from binaryTree import Node
from treeTraverse import *
from levelTraverseTree import *

def pathSum(root, target):
	if not root:
		return []
	if not root.left and not root.right and root.val == target:
		return [[root.val]]
	temp = pathSum(root.left, target-root.val) + pathSum(root.right, target-root.val)
	return [[root.val] + i for i in temp]

target = 22
root = Node(5)
root.left = Node(4)
root.right = Node(8)
root.left.left = Node(11)
root.left.left.left = Node(7)
root.left.left.right = Node(2)
root.right.left = Node(13)
root.right.right = Node(4)
root.right.right.right = Node(1)
root.right.right.left = Node(5)

print (pathSum(root, target))
Exemplo n.º 9
0
from binaryTree import Node


def invertTree(root):
    if root == None:
        return None
    tl = invertTree(root.left)
    tr = invertTree(root.right)
    root.right = tl
    root.left = tr
    return root


node = Node(3)
node.left = Node(9)
node.right = Node(20)
node.right.left = Node(15)
node.right.left.right = Node(7)
node.right.left.left = Node(7)

node = invertTree(node)
print(node.left.val)
Exemplo n.º 10
0
        return

    list = None
    if len(lists) == level:
        list = []
        list.append(root)
        lists.append([])
    else:
        list = lists[level]
        list.append(root)

    createLevelLinkedList(root.left, level + 1)
    createLevelLinkedList(root.right, level + 1)


ten = TreeNode(10)

eight = TreeNode(8)
eight.left = TreeNode(6)
eight.right = TreeNode(9)

twelve = TreeNode(12)

eight.left
ten.left = eight
ten.right = twelve

sol = createLevelLinkedList(ten, 0)
for i in lists:
    print(i)
Exemplo n.º 11
0
from binaryTree import Node
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.right.left = Node(4)
root.right.right = Node(5)


# these are dfs of the tree
def inorderTraverse(tree):
    """
		left root right
	"""
    if not tree:
        return []
    return inorderTraverse(tree.left) + [tree.val] + inorderTraverse(
        tree.right)


def preorderTraverse(tree):
    """
		root left right
	"""
    if not tree:
        return []
    return [tree.val] + preorderTraverse(tree.left) + preorderTraverse(
        tree.right)


def postorderTraverse(tree):
    """
Exemplo n.º 12
0
from binaryTree import Node
from treeTraverse import *
from arrToBST import *
root = Node(5)
root.left = Node(2)
root.left.left = Node(1)
root.left.right = Node(9)
root.left.right.left = Node(7)
root.left.right.right = Node(11)
root.right = Node(13)


def BSTtoGT(root):
    node_list = inorderTraverse(root)
    summation = sum(node_list)
    idx = 0
    while idx < len(node_list):
        summation -= node_list[idx]
        node_list[idx] += summation
        idx += 1
    return sortedArrToBST(node_list, 0, len(node_list) - 1)


root = BSTtoGT(root)
print(inorderTraverse(root))

summation = 0

# def BST2GT(root):
# 	convert(root)
# 	return root
Exemplo n.º 13
0
from binaryTree import Node
from treeTraverse import *
node = Node(5)
node.left=Node(3)
node.right= Node(6)
node.left.left = Node(2)
node.left.right =Node(4)
node.right.right = Node(7)
target = 10

# use two sum in array
node_list = inorderTraverse(node)
def twoSum(arr,target):
	"""
		O(n) solution for two sum
	"""
	maxVal = max(arr)
	help_list= [0] * (maxVal +1)
	for j in range(len(arr)):
		need = target - arr[j]
		if need < maxVal:
			if help_list[need] == 1:
				return True
			help_list[arr[j]] += 1
	return False


print (twoSum(node_list, target))


# Do not use two sum in array
Exemplo n.º 14
0
from binaryTree import Tree, Node


if __name__ == "__main__":
    tree = Tree()

    n1 = Node("a")
    n2 = Node("+")
    n3 = Node("*")
    n4 = Node("b")
    n5 = Node("-")
    n6 = Node("/")
    n7 = Node("c")
    n8 = Node("d")
    n9 = Node("e")

    n6.left = n7
    n6.right = n8

    n5.left = n6
    n5.right = n9

    n3.left = n4
    n3.right = n5

    n2.left = n1
    n2.right = n3

    tree.root = n2