1.

Write a complete menu driven program to implement the basic operations of a

Singly Linked List.

class Node:
def __init__(self, data):
self.data = data
self.next = None

class SinglyLinkedList:
def __init__(self):
self.head = None

def add_node_at_the_end(self, data):

new_node = Node(data)
if not self.head:
self.head = new_node
return
last_node = self.head
while last_node.next:
last_node = last_node.next
last_node.next = new_node

def add_node_at_the_begin(self, data):

new_node = Node(data)
new_node.next = self.head
self.head = new_node

def insert_at_position(self, position, data):

if position < 0:
print("Invalid position.")
return
if position == 0:
self.add_node_at_the_begin(data)
return
new_node = Node(data)
current_node = self.head
for _ in range(position-1):
if not current_node:
break
current_node = current_node.next
if not current_node:
print("Position is greater than the length of the list.")
return
new_node.next = current_node.next
current_node.next = new_node

def delete_from_beginning(self):
if not self.head:
print("List is empty. Nothing to delete.")
return
self.head = self.head.next

def delete_from_end(self):
if not self.head:
print("List is empty. Nothing to delete.")
return
if not self.head.next:
 self.head = None
return
second_last = self.head
while second_last.next.next:
second_last = second_last.next
second_last.next = None

def delete_at_position(self, position):

if position < 0:
print("Invalid position.")
return
if position == 0:
self.delete_from_beginning()
return
current_node = self.head
prev_node = None
for _ in range(position):
if not current_node:
print("Position is greater than the length of the list.")
return
prev_node = current_node
current_node = current_node.next
if not current_node:
print("Position is greater than the length of the list.")
return
prev_node.next = current_node.next

def traverse(self):
current_node = self.head
while current_node:
yield current_node.data
current_node = current_node.next

def sort(self):
elements = list(self.traverse())
elements.sort()
self.head = None
for element in elements:
self.add_node_at_the_end(element)

def reverse(self):
prev = None
current = self.head
while current:
next_node = current.next
current.next = prev
prev = current
current = next_node
self.head = prev

def display(self):
current_node = self.head
while current_node:
print(current_node.data, end=" ")
current_node = current_node.next
print()

linked_list = SinglyLinkedList()
while True:
print("\n1. Add a Node in the Linked List.")
print("2. Delete a Node from the Linked List.")
print("3. Traverse the Nodes of the Linked List.")
print("4. Sort the Linked List.")
print("5. Reverse the Linked List.")
print("6. Exit")
choice = int(input("Enter your choice: "))
if choice == 1:
print("\n1. Add a Node at the beginning of the Linked List.")
print("2. Add a Node at the end of the Linked List.")
print("3. Add a Node at any position in the Linked List.")
ch = int(input("Enter your choice: "))
if ch == 1:
data = int(input("Enter data to add at the beginning of the Linked
List: "))
linked_list.add_node_at_the_begin(data)
linked_list.display()
elif ch == 2:
data = int(input("Enter data to add at the end of the Linked List: "))
linked_list.add_node_at_the_end(data)
linked_list.display()
elif ch == 3:
data = int(input("Enter data to add in the Linked List: "))
pos = int(input("Enter the position to add a Node in the Linked List:
"))
linked_list.insert_at_position(pos,data)
linked_list.display()

elif choice == 2:
print("\n1. Delete a Node from the beginning of the Linked List.")
print("2. Delete a Node from the end of the Linked List.")
print("3. Delete a Node from any position in the Linked List.")
ch = int(input("Enter your choice: "))
if ch == 1:
linked_list.delete_from_beginning()
linked_list.display()
elif ch == 2:
linked_list.delete_from_end()
linked_list.display()
elif ch == 3:
pos = int(input("Enter the position of the Node to delete from the
Linked List: "))
linked_list.delete_at_position(pos)
linked_list.display()

elif choice == 3:
linked_list.traverse()
linked_list.display()
elif choice == 4:
linked_list.sort()
linked_list.display()
elif choice == 5:
linked_list.reverse()
linked_list.display()
elif choice == 6:
break
else:
print("Invalid choice. Please try again.")
2. Write a Python program to implement the basic operations of Stack. Write the
corresponding algorithm.

class Stack:
def __init__(self):
self.items = []

def push(self, item):

self.items.append(item)

def pop(self):
if not self.is_empty():
return self.items.pop()
else:
raise IndexError("Pop not possible ! Stack is empty !!!")

def peek(self):
if not self.is_empty():
return self.items[-1]
else:
raise IndexError("Peek not possible ! Stack is empty !!!")

def is_empty(self):
return len(self.items) == 0

stack = Stack()
while True:
print("\n1. Push an element in the Stack.")
print("2. Pop from the Stack.")
print("3. Peek an element from the Stack.")
print("4. Check whether the stack is empty or not.")
print("5. Exit")
choice = int(input("Enter your choice: "))
if choice == 1:
data = int(input("Enter an element to insert in the Stack : "))
stack.push(data)
print(stack.items)

elif choice == 2:
stack.pop()
print("Stack after pop : ", stack.items)

elif choice == 3:
print(stack.peek())

elif choice == 4:
print(stack.is_empty())

elif choice == 5:
break

else:
print("Invalid choice. Please try again.")
3. Write a Python program which takes a postfix expression as argument and evaluate
it using Stack. Write the corresponding algorithm.

class Stack:
def __init__(self):
self.items = []

def push(self, item):

self.items.append(item)

def pop(self):
if not self.is_empty():
return self.items.pop()
else:
raise IndexError("pop from empty stack")

def peek(self):
if not self.is_empty():
return self.items[-1]
else:
raise IndexError("peek from empty stack")

def is_empty(self):
return len(self.items) == 0

def evaluate_postfix(expression):
stack = Stack()
operators = set(['+', '-', '*', '/'])

for token in expression.split():

if token not in operators:
stack.push(float(token))
else:
operand2 = stack.pop()
operand1 = stack.pop()
result = perform_operation(token, operand1, operand2)
stack.push(result)

return stack.pop()

def perform_operation(operator, operand1, operand2):

if operator == '+':
return operand1 + operand2
elif operator == '-':
return operand1 - operand2
elif operator == '*':
return operand1 * operand2
elif operator == '/':
return operand1 / operand2

postfix_expr = input("Enter the expression : ")

print("Postfix Expression:", postfix_expr)
print("Result:", evaluate_postfix(postfix_expr))
4. Write a Python program to convert an infix expression into postfix expression.

def infix_to_postfix(expression):
precedence = {'+': 1, '-': 1, '*': 2, '/': 2, '^': 3}
stack = []
postfix = []
for char in expression:
if char.isalnum():
postfix.append(char)
elif char == '(':
stack.append(char)
elif char == ')':
while stack and stack[-1] != '(':
postfix.append(stack.pop())
stack.pop()
else:
while stack and precedence.get(stack[-1], 0) >= precedence.get(char,
0):
postfix.append(stack.pop())
stack.append(char)

while stack:
postfix.append(stack.pop())

return ''.join(postfix)

infix_expr = input("Enter an infix expression: ")

postfix_expr = infix_to_postfix(infix_expr)
print("Infix Expression:", infix_expr)
print("Postfix Expression:", postfix_expr)

5. Write a Python program to evaluate a postfix expression.

def evaluate_postfix(expression):
stack = []
for char in expression:
if char.isdigit():
stack.append(int(char))
else:
operand2 = stack.pop()
operand1 = stack.pop()
if char == '+':
stack.append(operand1 + operand2)
elif char == '-':
stack.append(operand1 - operand2)
elif char == '*':
stack.append(operand1 * operand2)
elif char == '/':
stack.append(operand1 / operand2)
elif char == '^':
stack.append(operand1 ** operand2)
return stack.pop()
postfix_expr = input("Enter a postfix expression: ")
result = evaluate_postfix(postfix_expr)
print("Postfix Expression:", postfix_expr)
print("Result:", result)

6. Write a program to create a linked list to contain the vowels ‘a’, ‘e’, ‘i’,
‘o’, ‘u’ in the data field of the nodes.

class Node:
def __init__(self, data):
self.data = data
self.next = None

class LinkedList:
def __init__(self):
self.head = None

def insert_at_end(self, data):

new_node = Node(data)
if self.head is None:
self.head = new_node
return
current = self.head
while current.next:
current = current.next
current.next = new_node

def display(self):
current = self.head
while current:
print(current.data, end=" ")
current = current.next
print()

vowels = ['a', 'e', 'i', 'o', 'u']

ll = LinkedList()
for vowel in vowels:
ll.insert_at_end(vowel)

print("Linked List with vowels:")

ll.display()

7. Write a program to delete the first node that contains an integer data item of a
single linked list.

class Node:
def __init__(self, data):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None

def insert_at_end(self, data):

new_node = Node(data)
if self.head is None:
self.head = new_node
return
current = self.head
while current.next:
current = current.next
current.next = new_node

def delete_first_integer_node(self):
if self.head is None:
return

if isinstance(self.head.data, int):
self.head = self.head.next
return

current = self.head
while current.next:
if isinstance(current.next.data, int):
current.next = current.next.next
return
current = current.next

def display(self):
current = self.head
while current:
print(current.data, end=" ")
current = current.next
print()

ll = LinkedList()
ll.insert_at_end('a')
ll.insert_at_end('e')
ll.insert_at_end(1)
ll.insert_at_end('i')
ll.insert_at_end('o')
ll.insert_at_end(2)
ll.insert_at_end('u')

print("Original Linked List:")

ll.display()
ll.delete_first_integer_node()

print("Linked List after deleting the first integer data node:")

ll.display()

8. Write a Python program that implements stack as a linked list.

class Node:
 def __init__(self, data):
self.data = data
self.next = None

class Stack:
def __init__(self):
self.top = None

def push(self, data):

new_node = Node(data)
new_node.next = self.top
self.top = new_node

def pop(self):
if self.is_empty():
raise IndexError("pop from empty stack")
popped = self.top
self.top = self.top.next
popped.next = None
return popped.data

def peek(self):
if self.is_empty():
raise IndexError("peek from empty stack")
return self.top.data

def is_empty(self):
return self.top is None

def __str__(self):
current = self.top
stack_str = ""
while current:
stack_str += str(current.data) + " "
current = current.next
return stack_str.strip()

stack = Stack()
stack.push(10)
stack.push(20)
stack.push(30)
print("Stack:", stack)
print("Peek:", stack.peek())
print("Pop:", stack.pop())
print("Stack after pop:", stack)

9. Write a Python program that implements queue as a linked list.

class Node:
def __init__(self, data):
self.data = data
self.next = None

class Queue:
def __init__(self):
 self.front = None
self.rear = None

def enqueue(self, data):

new_node = Node(data)
if self.is_empty():
self.front = new_node
else:
self.rear.next = new_node
self.rear = new_node

def dequeue(self):
if self.is_empty():
raise IndexError("dequeue from empty queue")
dequeued = self.front
self.front = self.front.next
if self.front is None:
self.rear = None
dequeued.next = None
return dequeued.data

def peek(self):
if self.is_empty():
raise IndexError("peek from empty queue")
return self.front.data

def is_empty(self):
return self.front is None

def __str__(self):
current = self.front
queue_str = ""
while current:
queue_str += str(current.data) + " "
current = current.next
return queue_str.strip()

queue = Queue()
queue.enqueue(100)
queue.enqueue(200)
queue.enqueue(300)
print("Queue:", queue)
print("Peek:", queue.peek())
print("Dequeue:", queue.dequeue())
print("Queue after dequeue:", queue)

10. Write a Python program that implements circular queue as a linked list.

CODE :
class Node:
def __init__(self, data):
self.data = data
self.next = None

class CircularQueue:
def __init__(self, capacity):
 self.capacity = capacity
self.size = 0
self.front = None
self.rear = None

def enqueue(self, data):

if self.is_full():
raise IndexError("enqueue to full queue")
new_node = Node(data)
if self.is_empty():
self.front = new_node
else:
self.rear.next = new_node
self.rear = new_node
self.rear.next = self.front
self.size += 1

def dequeue(self):
if self.is_empty():
raise IndexError("dequeue from empty queue")
dequeued = self.front
if self.size == 1:
self.front = None
self.rear = None
else:
self.front = self.front.next
self.rear.next = self.front
dequeued.next = None
self.size -= 1
return dequeued.data

def is_empty(self):
return self.size == 0

def is_full(self):
return self.size == self.capacity

def __str__(self):
if self.is_empty():
return "Empty queue"
current = self.front
queue_str = ""
while current.next != self.front:
queue_str += str(current.data) + " "
current = current.next
queue_str += str(current.data) + " "
return queue_str.strip()

queue = CircularQueue(5)
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue.enqueue(4)
queue.enqueue(5)
print("Queue:", queue)
print("Dequeue:", queue.dequeue())
print("Queue after dequeue:", queue)
queue.enqueue(6)
print("Queue after enqueue:", queue)
11. Write a Python program that implements deque using a linked list.

CODE :
class Node:
def __init__(self, data):
self.data = data
self.prev = None
self.next = None

class Deque:
def __init__(self):
self.front = None
self.rear = None

def is_empty(self):
return self.front is None

def add_front(self, data):

new_node = Node(data)
if self.is_empty():
self.front = new_node
self.rear = new_node
else:
new_node.next = self.front
self.front.prev = new_node
self.front = new_node

def add_rear(self, data):

new_node = Node(data)
if self.is_empty():
self.front = new_node
self.rear = new_node
else:
self.rear.next = new_node
new_node.prev = self.rear
self.rear = new_node

def remove_front(self):
if self.is_empty():
raise IndexError("remove_front from empty deque")
removed = self.front
if self.front == self.rear:
self.front = None
self.rear = None
else:
self.front = self.front.next
self.front.prev = None
removed.next = None
return removed.data

def remove_rear(self):
if self.is_empty():
raise IndexError("remove_rear from empty deque")
removed = self.rear
if self.front == self.rear:
self.front = None
self.rear = None
 else:
self.rear = self.rear.prev
self.rear.next = None
removed.prev = None
return removed.data

def peek_front(self):
if self.is_empty():
raise IndexError("peek_front from empty deque")
return self.front.data

def peek_rear(self):
if self.is_empty():
raise IndexError("peek_rear from empty deque")
return self.rear.data

def __str__(self):
if self.is_empty():
return "Empty deque"
current = self.front
deque_str = ""
while current:
deque_str += str(current.data) + " "
current = current.next
return deque_str.strip()

deque = Deque()
deque.add_front(1)
deque.add_front(2)
deque.add_rear(3)
print("Deque:", deque)
print("Peek front:", deque.peek_front())
print("Peek rear:", deque.peek_rear())
print("Remove front:", deque.remove_front())
print("Deque after remove front:", deque)
print("Remove rear:", deque.remove_rear())
print("Deque after remove rear:", deque)

12. Write a Python program that implements a priority queue using a linked list.

class Node:
def __init__(self, data, priority):
self.data = data
self.priority = priority
self.next = None

class PriorityQueue:
def __init__(self):
self.head = None

def is_empty(self):
return self.head is None

def enqueue(self, data, priority):

new_node = Node(data, priority)
if self.is_empty() or priority > self.head.priority:
 new_node.next = self.head
self.head = new_node
else:
current = self.head
while current.next and priority <= current.next.priority:
current = current.next
new_node.next = current.next
current.next = new_node

def dequeue(self):
if self.is_empty():
raise IndexError("dequeue from empty priority queue")
dequeued = self.head
self.head = self.head.next
dequeued.next = None
return dequeued.data

def peek(self):
if self.is_empty():
raise IndexError("peek from empty priority queue")
return self.head.data

def __str__(self):
if self.is_empty():
return "Empty priority queue"
current = self.head
queue_str = ""
while current:
queue_str += f"{current.data}:{current.priority} "
current = current.next
return queue_str.strip()

priority_queue = PriorityQueue()
priority_queue.enqueue("Task1", 2)
priority_queue.enqueue("Task2", 1)
priority_queue.enqueue("Task3", 3)
print("Priority Queue:", priority_queue)
print("Peek:", priority_queue.peek())
print("Dequeue:", priority_queue.dequeue())
print("Priority Queue after dequeue:", priority_queue)