####binary search tree.

py######
class BinaryTree:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def insert_left(self, new_data):
if self.left == None:
self.left = BinaryTree(new_data)
else:
t = BinaryTree(new_data)
t.left = self.left
self.left = t
def insert_right(self, new_data):
if self.right == None:
self.right = BinaryTree(new_data)
else:
t = BinaryTree(new_data)
t.left = self.right
self.right = t
def get_left(self):
return self.left
def get_right(self):
return self.right
def set_data(self,data):
self.data = data
def get_data(self):
return self.data
def size(my_tree):
if not my_tree:
return 0
return 1 + size(my_tree.get_left())+size(my_tree.get_right())

a = BinaryTree(1)
a.insert_left(2)
a.insert_right(3)
print(size(a))

######binary search tree.py#####

class BinaryTree:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def insert_left(self, new_data):
if self.left == None:
self.left = BinaryTree(new_data)
else:
t = BinaryTree(new_data)
t.left = self.left
self.left = t
def insert_right(self, new_data):
if self.right == None:
self.right = BinaryTree(new_data)
else:
t = BinaryTree(new_data)
t.left = self.right
self.right = t
 def get_left(self):
return self.left
def get_right(self):
return self.right
def set_data(self,data):
self.data = data
def get_data(self):
return self.data
def size(my_tree):
if not my_tree:
return 0
return 1 + size(my_tree.get_left())+size(my_tree.get_right())

a = BinaryTree(1)
a.insert_left(2)
a.insert_right(3)
print(size(a))

#####treealogorithms.py #####
class Node:

def __init__(self,info):
self.info = info
self.left = None
self.right = None
self.level = None
def __str__(self):
return str(self.info)

class searchtree:
def __init__(self):
self.root = None
def create(self,val):
if self.root == None:
self.root = Node(val)
else:
current = self.root
while 1:
if val < current.info:
if current.left:
current = current.left
else:
current.left = Node(val)
break;
elif val > current.info:
if current.right:
current = current.right
else:
current.right = Node(val)
break;
else:
break

def bft(self):
self.root.level = 0
 queue = [self.root]
out = []
current_level = self.root.level
while len(queue) > 0:
current_node = queue.pop(0)
if current_node.level > current_level:
current_level += 1
out.append("\n")
out.append(str(current_node.info) + " ")
if current_node.left:
current_node.left.level = current_level + 1
queue.append(current_node.left)
if current_node.right:
current_node.right.level = current_level + 1
queue.append(current_node.right)
result= "".join(out)
print(result)
def inorder(self,node):
if node is not None:
self.inorder(node.left)
print(node.info)
self.inorder(node.right)
def preorder(self,node):
if node is not None:
print(node.info)
self.preorder(node.left)
self.preorder(node.right)
def postorder(self,node):
if node is not None:
self.preorder(node.left)
self.preorder(node.right)
print(node.info)
tree = searchtree()
arr = [8,3,1,6,4,7,10,14,13]
for i in arr:
tree.create(i)
print('Breadth-first traversal')
tree.bft()
print('Inorder Traversal')
tree.inorder(tree.root)
print('Preorder Traversal')
tree.preorder(tree.root)
print('Postorder Traversal')
tree.postorder(tree.root)

######infixto postfix#####
class Stack:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return self.items[len(self.items)-1]
def size(self):
return len(self.items)
def infix_postfix(infixexp):
prec={}
prec["^"]=4
prec["*"]=3
prec["/"]=3
prec["+"]=2
prec["-"]=2
prec["("]=1
opStack=Stack()
postfixList=[]

tokenList=infixexp.split()
for token in tokenList:
if token in "ABCDEFGHIJKLMNOPQRSTUVWXYZ" or \
token in "abcdefghijklmnopqrstuvwxyz" or token in "0123456789":
postfixList.append(token)
elif token =='(':
opStack.push(token)
elif token == ')':
topToken = opStack.pop()
while topToken != '(':
postfixList.append(topTaken)
topTaken=opStack.pop()
else:
while (not opStack.isEmpty()) and \
(prec[opStack.peek()]>=prec[token]):
postfixList.append(opStack.pop())
opStack.push(token)

while not opStack.isEmpty():

postfixList.append(opStack.pop())
return " ".join(postfixList)
a=infix_postfix('A + B * C - D / E * H')
print("the postfix expression of infix expression A + B * C - D / E * H is \n",a)

#######binary tree.po.py #######

class Node:

def __init__(self,info): #constructor of class

self.info = info #information for node
self.left = None #left leef
self.right = None #right leef
self.level = None #level none defined
def __str__(self):
return str(self.info) #return as string

class searchtree:
def __init__(self): #constructor of class
self.root = None
def create(self,val):#create binary search tree nodes
if self.root == None:
self.root = Node(val)
else:
current = self.root
 while 1:
if val < current.info:
if current.left:
current = current.left
else:
current.left = Node(val)
break;
elif val > current.info:
if current.right:
current = current.right
else:
current.right = Node(val)
break;
else:
break
def bft(self): #Breadth-First Traversal
self.root.level = 0
queue = [self.root]
out = []
current_level = self.root.level
while len(queue) > 0:
current_node = queue.pop(0)
if current_node.level > current_level:
current_level += 1
out.append("\n")
out.append(str(current_node.info) + " ")
if current_node.left:
current_node.left.level = current_level + 1
queue.append(current_node.left)
if current_node.right:
current_node.right.level = current_level + 1
queue.append(current_node.right)
result= "".join(out)
print (result)
def inorder(self,node):
if node is not None:
self.inorder(node.left)
print (node.info)
self.inorder(node.right)
def preorder(self,node):
if node is not None:
print (node.info)
self.preorder(node.left)
self.preorder(node.right)
def postorder(self,node):
if node is not None:
self.postorder(node.left)
self.postorder(node.right)
print (node.info)

tree = searchtree()
arr = [8,3,1,6,4,7,10,14,13]
for i in arr:
tree.create(i)
print ('Breadth-First Traversal')
tree.bft()
print ('Inorder Traversal')
tree.inorder(tree.root)
print ('preorder Traversal')
tree.preorder(tree.root)
print ('postorder Traversal')
tree.postorder(tree.root)

#######queue#####
front=0
rear=0
mymax=eval(input("Enter maximum size of queue:"))
def createQueue():
queue=[]
return queue
def isEmpty(queue):
return len(queue)==0
def enqueue(queue,item):
queue.append(item)
print("Enqueued to queue",item)
def dequeue(queue):
if isEmpty(queue):
return "Queue is Empty"
item=queue[0]
del queue[0]
return item
queue=createQueue()
while True:
print("1.Enqueue")
print("2.Dequeue")
print("3.Display")
print("4.Quit")
ch=int(input("Enter your choice:"))
if ch==1:
if rear<mymax:
item=input("Enter any elements")
enqueue(queue,item)
rear+=1
else:
print("Queue is full")
elif ch==2:
print(dequeue(queue))
elif ch==3:
print(queue)
else:
print("Exit")
break

####quick sort####

def q_sort(a,low,high):
if low<high:
pivotpos=partition(a,low,high)
q_sort(a,low,pivotpos-1)
q_sort(a,pivotpos+1,high)

def partition(a,low,high):
pivotvalue=a[low]
up=low+1
down=high
done=False
while not done:
 while up<=down and a[up]<=pivotvalue:
up+=1
while down>=up and a[down]>=pivotvalue:
down-=1
if down<up:
done=True
else:
temp=a[up]
a[up]=a[down]
a[down]=temp
temp=a[low]
a[low]=a[down]
a[down]=temp
return down

print("enter elements into list")

a=[int(x) for x in input().split()]
high=len(a)
q_sort(a,0,high-1)
print("The sorted list is",a)

####shell sort#####

def shell_sort(my_list, list_len):

interval = list_len // 2
while interval > 0:
for i in range(interval, list_len):
temp = my_list[i]
j = i
while j >= interval and my_list[j - interval] > temp:
my_list[j] = my_list[j - interval]
j -= interval
my_list[j] = temp
interval //= 2

my_list = [45, 31, 62, 12, 89, 5, 9, 8]

list_len = len(my_list)
print("the list before the sorting is:")
print(my_list)
shell_sort(my_list, list_len)
print("\nThe list after performing shell sorting is :")
print(my_list)

####selection sort#####
def s_sort(a):
for i in range(len(a)):
least=i
for k in range(i+1,len(a)):
if a[k]<a[least]:
least=k
swap(a,least,i)
def swap(a,least,i):
temp=a[least]
a[least]=a[i]
a[i]=temp

print("enter elements into list:")

a=[int(x) for x in input().split()]
s_sort(a)
print("the sorted list is",a)

#####merge sort#####
def m_sort(a):
for i in range(len(a)):
if i>1:
mid=len(a)//2
l_half=a[:mid]
r_half=a[mid:]
m_sort(l_half)
m_sort(r_half)
i=j=k=0
while i<len(l_half) and j<len(r_half):
if l_half [i]<r_half[j]:
a[k]=l_half[i]
i+=1
else:
a[k]=r_half[j]
j+=1
k+=1
while i<len(l_half):
a[k]=l_half[i]
i+=1
k+=1
while j<len(r_half):
a[k]=r_half[j]
j+=1
k+=1

print("enter elements into list:")

a=[int(x) for x in input().split()]
m_sort(a)
print("the sorted list is",a)

###### insertion sort #####

def i_sort(a):
for i in range(1,len(a)):
temp=a[i]
pos=i
while pos>0 and a[pos-1]>temp:
a[pos]=a[pos-1]
pos-=1
a[pos]=temp

print("enter elements into list:")

a=[int(x) for x in input().split()]
i_sort(a)
print("the sorted list is",a)

###heap sort####
def heapify(arr, n, i):
largest = i
l = 2 * i + 1
r = 2 * i + 2
if l < n and arr[i] < arr[l]:
largest = l
 if r < n and arr[largest] < arr[r]:
largest = r

if largest != i:
arr[i],arr[largest] = arr[largest],arr[i]
heapify(arr, n, largest)

def heapsort(arr):
n = len(arr)
for i in range(n, -1, -1):
heapify(arr, n, i)

for i in range(n-1, 0, -1):

arr[i], arr[0] = arr[0], arr[i]
heapify(arr, i, 0)

arr = [2,5,3,8,6,5,4,7]
heapsort(arr)
n = len(arr)
print("sorted array is")
for i in range(n):
print(arr[i],end=" ")

###stack#####
class Stack:
def __init__(self):
self.items = []
def is_empty(self):
return self.items == []
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return self.items[len(self.items)-1]
def size(self):
return len(self.items)

s = Stack()
print(s.is_empty())
s.push(4)
s.push('dog')
print(s.peek())
s.push(True)
print(s.size())
print(s.is_empty())
s.push(8.4)
print(s.pop())
print(s.pop())
print(s.size())

#####stak implemenation using list####

top=0
mymax=eval(input("enter maximum size of stack"))
def createstack():
 stack=[]
return stack
def isEmpty(stack):
return len(stack)==0
def push(stack,item):
stack.append(item)
print("pushed to stack",item)
def pop(stack):
if isEmpty(stack):
return "stack underflow"
return stack.pop()
stack=createstack()
while True:
print("1.push")
print("2.pop")
print("3.Display")
print("4.Quit")
ch=int(input("enter your choice:"))
if ch==1:
if top<mymax:
item=input("enter any elements:")
push(stack,item)
top+=1
else:
print("stack overflow")
elif ch==2:
print(pop(stack))
elif ch==3:
print(stack)
else:
print("exit")
break

####linear search #####

def l_search(a,x,l,n):
if l<=n:
mid=(l+n)//2
if a[mid]==x:
print("the element found at",l+1,"position")
else:
l_search(a,x,mid+1,n)
else:
print("element not found")

print("enter list")
a=[int(b) for b in input().split()]
x=eval(input("enter the search element"))
n=len(a)
l_search(a,x,0,n)

### fibonocci search ####

def f_search (a,x,n):
f0=0
f1=1
f2=f0+f1
while f2<n:
f0=f1
f1=f2
f2=f0+f1
 offset=-1
while f2>1:
i = min(offset+f2, n-1)
if(a[i]<x):
f2=f1
f1=f0
f0=f2-f1
offset = i
elif (a[i]>x):
f2=f0
f1=f1-f2
f0=f2-f1
else:
return i
if(f1 and a[offset+f2]==x):
return offset+1
return -1

print("enter list")
a=[int(b) for b in input().split()]
list.sort(a)
print("the sorted list is",a)
x=eval(input("enter the search element"))
n=len(a)
pos=f_search(a,x,n)
if pos>=0:
print("the element found at",pos+1,"position")
else:
print("element not found")

###bubble sort####
def b_sort(a):
n = len(a)
for i in range(n):
for j in range(0, n-i-1):
if a[j] > a[j+1] :
a[j], a[j+1] = a[j+1], a[j]

print("enter elements into list:")

a=[int(x) for x in input().split()]
b_sort(a)
print("the sorted list is",a)

####binary search (3)####

def b_search(a,x,l,n):
if l<=n:
mid=(l+n)//2
if a[mid]==x:
print("the element found at",mid+1,"position")
else:
if a[mid]>x:
b_search(a,x,l,mid-1)
else:
b_search(a,x,mid+1,n)
else:
print("element not found")
print("enter list")
a=[int(b) for b in input().split()]
list.sort(a)
print("the sorted list is",a)
x=eval(input("enter the search element"))
n=len(a)
b_search(a,x,0,n)

##### sequential search ######

def sequentialsearch(dlist, item):
pos=0
found=False

while pos<len(dlist) and not found:

if dlist[pos]==item:
found=True
else:
pos=pos+1
return found,pos
test_list=[1,2,3,4,5,6,7,8]
print(sequentialsearch(test_list,2))
print(sequentialsearch(test_list,8))