class MinHeap: for _ in range(int(input("How many?

"))):
def __init__(self, maxsize): [Link](int(input("Enter element: ")))
[Link], [Link], [Link] = maxsize, 0, [0] # Dummy index 0 heap.print_heap()
def parent(self, pos): return pos // 2 elif ch == "delete":
def leftChild(self, pos): return 2 * pos print(f"Removed: {[Link]() if not heap.is_empty() else 'Heap is empty'}")
def rightChild(self, pos): return (2 * pos) + 1 heap.print_heap()
def isLeaf(self, pos): return pos * 2 > [Link] elif ch == "e":
def swap(self, fpos, spos): [Link][fpos], [Link][spos] = [Link][spos], break
[Link][fpos] else:
def is_empty(self): return [Link] == 0 print("Invalid choice!")
HEIGHT AND DEPTH OF A NODE IN TREE
def minHeapify(self, pos): class Node:
if not [Link](pos): def __init__(self, data):
left, right = [Link](pos), [Link](pos) [Link] = [Link] = None
smallest = left if left <= [Link] and [Link][left] < [Link][pos] else pos [Link] = data
if right <= [Link] and [Link][right] < [Link][smallest]: smallest = right
if smallest != pos: class Tree:
[Link](pos, smallest) def __init__(self, root):
[Link](smallest) [Link] = Node(root)

def insert(self, element): def insert(self, node, data):

if [Link] >= [Link]: if node is None: return Node(data)
print("Heap overflow!") if data < [Link]: [Link] = [Link]([Link], data)
else: else: [Link] = [Link]([Link], data)
[Link] += 1 return node
[Link](element)
curr = [Link] def height(self, node):
while curr > 1 and [Link][curr] < [Link][[Link](curr)]: return -1 if node is None else max([Link]([Link]), [Link]([Link])) +
[Link](curr, [Link](curr)) 1
curr = [Link](curr)
def find_height(self, root, x):
def remove(self): if root is None: return -1
if self.is_empty(): return -1 if [Link] == x: return [Link](root)
popped, [Link][1] = [Link][1], [Link]() return self.find_height([Link], x) if x < [Link] else self.find_height([Link],
[Link] -= 1 x)
[Link](1)
return popped def depth(self, root, x, d=0):
if root is None: return -1
def print_heap(self): print("Heap:", [Link][1:]) if [Link] == x: return d
left = [Link]([Link], x, d + 1)
if __name__ == "__main__": return left if left != -1 else [Link]([Link], x, d + 1)
heap = MinHeap(int(input("Enter max heap size: ")))
while True: if __name__ == "__main__":
ch = input("\n(insert/delete/e to exit): ").strip().lower() tree = Tree(int(input("Enter root node: ")))
if ch == "insert": while True:
 ch = input("\n(insert/height/depth/exit): ").strip().lower() [Link]([Link])
if ch == "insert": [Link]([Link])
for _ in range(int(input("How many? "))):
[Link]([Link], int(input("Enter node: "))) def postorder(self, node):
elif ch == "height": if node:
print(f"Height: {tree.find_height([Link], int(input('Node: ')))}") [Link]([Link])
elif ch == "depth": [Link]([Link])
print(f"Depth: {[Link]([Link], int(input('Node: ')))}") print([Link], end=" ")
elif ch == "exit": break
else: print("Invalid choice!") def traverse(self):
if not [Link]:
TREE TRAVERSAL print("Tree is empty!")
class Node: return
def __init__(self, data): ch = input("\nChoose traversal (inorder/preorder/postorder/bfs):
[Link] = [Link] = None ").strip().lower()
[Link] = data print(f"\n{[Link]()} Traversal:")
if ch == "inorder": [Link]([Link])
class Tree: elif ch == "preorder": [Link]([Link])
def __init__(self, root): elif ch == "postorder": [Link]([Link])
[Link] = Node(root) elif ch == "bfs": [Link]([Link])
else: print("Invalid choice!")
def insert(self, node, data):
if not node: return Node(data) if __name__ == "__main__":
if data < [Link]: [Link] = [Link]([Link], data) tree = Tree(int(input("Enter root node: ")))
else: [Link] = [Link]([Link], data) while True:
return node ch = input("\n(insert/traverse/exit): ").strip().lower()
if ch == "insert":
def bfs(self, node): for _ in range(int(input("How many? "))):
if not node: return [Link]([Link], int(input("Enter node: ")))
queue = [node] elif ch == "traverse":
while queue: [Link]()
curr = [Link](0) elif ch == "exit": break
print([Link], end=" ") else: print("Invalid choice!")
if [Link]: [Link]([Link])
if [Link]: [Link]([Link]) REVERSE QUEUE
from collections import deque
def inorder(self, node):
if node: class RevQueue:
[Link]([Link]) def __init__(self):
print([Link], end=" ") self.q = deque()
[Link]([Link])
def enqueue(self, ele):
def preorder(self, node): [Link](ele)
if node:
print([Link], end=" ") def dequeue(self):
 return [Link]() if self.q else "Queue is empty" def display(self):
print([Link])
def reverse(self):
if len(self.q) > 1: st = RevStack()
[Link]() while True:
else: ch = input("\n(push/pop/display/reverse/exit): ").strip().lower()
print("Queue should have more than 1 element.") if ch == "push":
[Link](input("Enter element: "))
def display(self): elif ch == "pop":
print(list(self.q)) print(f"Popped: {[Link]()}")
elif ch == "display":
q = RevQueue() [Link]()
while True: elif ch == "reverse":
ch = input("\n(insert/delete/display/reverse/exit): ").strip().lower() [Link]()
if ch == "insert": [Link]()
[Link](input("Enter element: ")) elif ch == "exit":
elif ch == "delete": break
print(f"Deleted: {[Link]()}") else:
elif ch == "display": print("Invalid choice!")
[Link]()
elif ch == "reverse":
[Link]() QUEUE USING CLASS
[Link]() from collections import deque
elif ch == "exit":
break class Queue:
else: def __init__(self):
print("Invalid choice!") self.q = deque()

REVERSE STACK def enqueue(self, item):

class RevStack: [Link](item)
def __init__(self): print(f"Inserted: {item}")
[Link] = []
def dequeue(self):
def push(self, ele): print(f"Deleted: {[Link]()}" if self.q else "Queue is empty.")
[Link](ele)
def display(self):
def pop(self): print("Queue:", list(self.q) if self.q else "Queue is empty.")
return [Link]() if [Link] else "Stack is empty"
q = Queue()
def reverse(self): while True:
if len([Link]) > 1: ch = input("\n(insert/delete/display/exit): ").strip().lower()
[Link]() if ch == "insert":
else: [Link](input("Enter element: "))
print("Stack should have more than 1 element.") elif ch == "delete":
[Link]()
 elif ch == "display": def sort_data(self):
[Link]() print("Original list:", [Link])
elif ch == "exit": [Link]([Link], 0, len([Link]) - 1)
break print("Sorted list:", [Link])
else:
print("Invalid choice!") def partition(self, lst, left, right):
pivot, i = lst[right], left
STACK USING CLASS for j in range(left, right):
class Stack: if lst[j] < pivot:
def __init__(self): lst[i], lst[j] = lst[j], lst[i]
[Link] = [] i += 1
lst[i], lst[right] = lst[right], lst[i]
def push(self, item): return i
[Link](item)
print(f"Pushed: {item}") def qsort(self, lst, left, right):
if left < right:
def pop(self): pi = [Link](lst, left, right)
print(f"Popped: {[Link]()}" if [Link] else "Stack is empty.") [Link](lst, left, pi - 1)
[Link](lst, pi + 1, right)
def display(self):
print("Stack:", [Link] if [Link] else "Stack is empty.") # Driver code
qs = QuickSort()
st = Stack() qs.read_data()
while True: qs.sort_data()
ch = input("\n(push/pop/display/exit): ").strip().lower()
if ch == "push": MERGE SORT
[Link](input("Enter element: ")) class MergeSort:
elif ch == "pop": def __init__(self):
[Link]() [Link] = [int(input(f"Enter element {i+1}: ")) for i in range(int(input("Enter
elif ch == "display": number of elements: ")))]
[Link]()
elif ch == "exit": def sort_data(self):
break print("Original list:", [Link])
else: [Link] = self.merge_sort([Link])
print("Invalid choice!") print("Sorted list:", [Link])

QUICK SORT def merge_sort(self, lst):

class QuickSort: if len(lst) > 1:
def __init__(self): mid = len(lst) // 2
[Link] = [] left, right = lst[:mid], lst[mid:]
left, right = self.merge_sort(left), self.merge_sort(right)
def read_data(self): return [Link](left, right)
[Link] = [int(input(f"Enter element {i+1}: ")) for i in range(int(input("Enter return lst
number of elements: ")))]
def merge(self, left, right):
 merged, i, j = [], 0, 0 def __init__(self, name, age, gender):
while i < len(left) and j < len(right): [Link], [Link], [Link] = name, age, [Link]()
[Link](left[i] if left[i] < right[j] else right[j])
i, j = (i + 1, j) if left[i] < right[j] else (i, j + 1) def greeting(self):
return merged + left[i:] + right[j:] print(f"Hello {'Mr.' if [Link] == 'male' else 'Ms./Mrs.'} {[Link]}")

# Driver code class Student(Person):

ms = MergeSort() def __init__(self, name, age, gender, course, branch):
ms.sort_data() super().__init__(name, age, gender)
[Link], [Link] = course, branch
BINARY SEARCH
class BinarySearchRec: def details(self):
def __init__(self): print(f"Name: {[Link]}\nAge: {[Link]}\nGender: {[Link]}\nCourse:
self.L = [] {[Link]}\nBranch: {[Link]}")

def read_data(self): # Driver code

self.L = [input("Enter name: ") for _ in range(int(input("Enter no. of names: ")))] s1 = Student(input("Enter name: "), int(input("Enter age: ")), input("Enter gender: "),
input("Enter course: "), input("Enter branch: "))
def input_search_data(self): [Link]()
while input("Do you wanna search again? y/n: ").lower() == 'y': [Link]()
name = input("Enter name to search: ")
[Link](name) CLASS
class Person:
def search(self, x, s=0, e=None, count=1): def __init__(self, name, age, gender):
if e is None: [Link], [Link], [Link] = name, age, [Link]()
e = len(self.L) - 1
[Link]() def greeting(self):
if s <= e: print(f"Hello {'Mr.' if [Link] == 'male' else 'Ms./Mrs.'} {[Link]}")
mid = (s + e) // 2 p1 = Person(input("Enter your name: "), int(input("Enter your age: ")), input("Enter
if self.L[mid] == x: your gender: "))
print(f"Name found at iteration {count}") [Link]()
elif self.L[mid] < x:
[Link](x, mid + 1, e, count + 1) POLYMORPHISM
else: def add(a, b): return a + b
[Link](x, s, mid - 1, count + 1) # Calling add() for different argument types
else: print(add(13, 14))
print("Name is not in the list") print(add("Hello ", "world"))
# Using len() for both list and string
# Driver code print("Length of the list:", len(['apple', 'banana', 'watermelon']))
bs = BinarySearchRec() print("Length of the string:", len("Hello world"))
bs.read_data()
bs.input_search_data() USER-DEFINE FUNCTION
def fullname(fname, lname): return f"\nHi {fname} {lname}"
INHERITANCE print(fullname(input("Enter your first name: "), input("Enter your last name: ")))
class Person:
STRING OPERATION & INDEX OF THE CHARACTER IN STRING marks = int(input("Enter your subject marks: "))
for i, ch in enumerate(input("Enter a string: ")): if marks >= 50: print("Congratulations! You cleared the subject")
print(f"\n\t {i} \t {ch}") else: print("You failed. Better luck next time")

WHILE LOOP SPLIT() BUILT-IN FUNCTION

total = 0 x, y = map(int, input("Enter x and y: ").split())
number = int(input("Enter an integer below 20: ")) print(f"x = {x}\ny = {y}")
while number <= 20: total, number = total + number, number + 1
print(f"Total: {total}" if number <= 20 else "Value is greater than 20") TYPE() BUILT-IN FUNCTION
number = int(input("Enter a Number"))
PRIME NUMBER USING GIVEN RANGE print(f"The Number is {number}\ntype(Number) is {type(number)}")
def isprime(n): return n > 1 and all(n % i for i in range(2, n))
N = int(input("Enter a number: ")) LIST OBJECT EXAMPLE
print("Prime numbers:", *[i for i in range(2, N + 1) if isprime(i)]) list1 = ["apple", "banana", "cherry"]
list2 = [1, 5, 7, 8, 3]
FOR LOOP USING OBJECT-LIST list3 = ["true", "false"]
Fruit = ['Apple', 'Banana', 'Grapes', 'Cherry']
print("Fruits are:", *Fruit) print(list1, list2, list3, f"\n3rd item in list1: {list1[2]}")
for item in Fruit: print("Items are:", item) print("\nlist1 items:")
for item in list1: print(item)
FOR LOOP USING OBJECT-STRING
Str = "Computer Science" INTEGER AND STRING EXAMPLE
for word in Str: print("Letters are:", word) temp = 30
print("----This is Outside String---") print("Temp =", temp, f"\ntemp_alias = {temp}")
temp_alias = 35.5
FOR LOOP USING RANGE() print(f"Temp = {temp}, temp_alias = {temp_alias}")
for number in range(9, 14): print(number) temp = "ABC"
print() print(f"Temp = {temp}, Type = {type(temp)}")
for num in range(5, 18, 2): print(num)
VARIABLE IN PYTHON
CONDITIONAL STATEMENT(NESTED IF) x, y = 5, "hello, world!"
age = int(input("Enter your age: ")) print(x, y)
if age < 18: print("You are minor\nYou are not eligible for work")
elif age <= 60: print("You are eligible for work\nPlease fill the form") SUM OF TWO NUMBER
else: print("You are too old to work as per government order") while input("Do you want to continue? y/n: ") == "y":
n1, n2 = int(input("Enter a number: ")), int(input("Enter another number: "))
print(f"Sum of {n1} + {n2} = {n1 + n2}")
CONDITIONAL STATEMENT(IF-ELIF- ELSE)
Totalmarks = int(input("Enter your total marks: "))
if Totalmarks >= 540: print("Congrats! You are eligible for full scholarship")
elif Totalmarks >= 480: print("Congrats! You are eligible for 50% scholarship")
elif Totalmarks >= 400: print("Congrats! You are eligible for 10% scholarship")
else: print("Sorry, you are not eligible for a scholarship")

CONDITIONAL STATEMENT(IF ELSE)