DSA ASSIGNMENT NUMBER 03

Name: Sarah Iqbal

class_id: 114724

student_id: 15312

question 01:

class Stack:

def _init_(self):

self.items = []

def is_empty(self):

return len(self.items) == 0

def push(self, item):

self.items.append(item)

def pop(self):

if not self.is_empty():

return self.items.pop()

return None

def peek(self):

if not self.is_empty():

return self.items[-1]

return None

def precedence(op):

if op in ('+', '-'):
 return 1

if op in ('*', '/'):

return 2

if op == '^':

return 3

return 0

def is_operand(char):

return char.isalpha()

def infix_to_postfix(expression):

stack = Stack()

result = []

for char in expression:

if is_operand(char):

result.append(char)

elif char == '(':

stack.push(char)

elif char == ')':

top_token = stack.pop()

while top_token != '(':

result.append(top_token)

top_token = stack.pop()

else:

while not stack.is_empty() and precedence(char) <= precedence(stack.peek()):

result.append(stack.pop())

stack.push(char)
 while not stack.is_empty():

result.append(stack.pop())

return ' '.join(result)

expression1 = "(A+B)*C-(D-E)^(F+G)"

expression2 = "A*(B+C)/D-E"

print("Postfix of expression 1:", infix_to_postfix(expression1))

print("Postfix of expression 2:", infix_to_postfix(expression2))

question 02:

class Stack:
def __init__(self):
self.items = []
def is_empty(self):
return len(self.items) == 0
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop() if not self.is_empty() else None
def peek(self):
return self.items[-1] if not self.is_empty() else None
def get_precedence(op):
precedences = {'+': 1, '-': 1, '*': 2, '/': 2, '^': 3}
return precedences.get(op, 0)
def is_operand(char):
 return char.isalnum()
def infix_to_postfix(expression):
stack = Stack()
result = []
for char in expression:
if is_operand(char):
result.append(char)
elif char == '(':
stack.push(char)
elif char == ')':
while not stack.is_empty() and stack.peek() != '(':
result.append(stack.pop())
stack.pop()
else:
while not stack.is_empty() and get_precedence(char) <=
get_precedence(stack.peek()):
result.append(stack.pop())
stack.push(char)
while not stack.is_empty():
result.append(stack.pop())
return ''.join(result)
def infix_to_prefix(expression):
def reverse_and_swap(expression):
expression = expression[::-1]
return ''.join(['(' if char == ')' else ')' if char == '(' else char for char in expression])
def modified_infix_to_postfix(expression):
stack = Stack()
result = []
 for char in expression:
if is_operand(char):
result.append(char)
elif char == '(':
stack.push(char)
elif char == ')':
while not stack.is_empty() and stack.peek() != '(':
result.append(stack.pop())
stack.pop()
else:
while not stack.is_empty() and get_precedence(char) <
get_precedence(stack.peek()):
result.append(stack.pop())
stack.push(char)
while not stack.is_empty():
result.append(stack.pop())
return ' '.join(result)
reversed_expression = reverse_and_swap(expression)
postfix_expression = modified_infix_to_postfix(reversed_expression)
return reverse_and_swap(postfix_expression)
expression1 = "(X+Y)*(Z-W)"
expression2 = "M*N+O/P"
expression3 = "P+Q-R*S"
print("Prefix of expression 1:", infix_to_prefix(expression1))
print("Prefix of expression 2:", infix_to_prefix(expression2))
print("Prefix of expression 3:", infix_to_prefix(expression3))
 question 03:

class Stack:

def __init__(self):

self.items = []

def is_empty(self):

return len(self.items) == 0

def push(self, item):

self.items.append(item)

def pop(self):

return self.items.pop() if not self.is_empty() else None

def peek(self):

return self.items[-1] if not self.is_empty() else None

def power(base, exponent):

result = 1

for _ in range(exponent):

result *= base

return result

def multiply(a, b):

result = 0
 for _ in range(b):

result += a

return result

def precedence(op):

if op in ('+', '-'):

return 1

if op in ('*', '/'):

return 2

if op == '^':

return 3

return 0

def is_operand(char):

return char.isdigit()

def infix_to_postfix(expression):

stack = Stack()

result = []

i=0

while i < len(expression):

char = expression[i]

if char.isdigit():

num = char

while i + 1 < len(expression) and expression[i + 1].isdigit():

i += 1

num += expression[i]

result.append(num)
 elif char == '(':

stack.push(char)

elif char == ')':

top_token = stack.pop()

while top_token != '(':

result.append(top_token)

top_token = stack.pop()

else:

while not stack.is_empty() and precedence(char) <= precedence(stack.peek()):

result.append(stack.pop())

stack.push(char)

i += 1

while not stack.is_empty():

result.append(stack.pop())

return result

def evaluate_postfix(expression):

stack = Stack()

for char in expression:

if char.isdigit():

stack.push(int(char))

else:

if char == '^':

op1 = stack.pop()

op2 = stack.pop()

stack.push(power(op2, op1))
 elif char == '*':

op1 = stack.pop()

op2 = stack.pop()

stack.push(multiply(op2, op1))

elif char == '+':

op1 = stack.pop()

op2 = stack.pop()

stack.push(op1 + op2)

elif char == '-':

op1 = stack.pop()

op2 = stack.pop()

stack.push(op2 - op1)

return stack.pop()

expression1 = "3 + 2 ^ 2 ^ 2 - 2 * 3"

expression2 = "5 + 1 ^ 3 ^ 2 - 4 * 2"

expression3 = "7 + 1 ^ 4 ^ 1 - 3 * 2"

postfix_expression1 = infix_to_postfix(expression1.replace(" ", ""))

postfix_expression2 = infix_to_postfix(expression2.replace(" ", ""))

postfix_expression3 = infix_to_postfix(expression3.replace(" ", ""))

print("Result of expression 1:", evaluate_postfix(postfix_expression1))

print("Result of expression 2:", evaluate_postfix(postfix_expression2))

print("Result of expression 3:", evaluate_postfix(postfix_expression3))

class Stack:

def __init__(self):

self.stack = []

def push(self, item):

self.stack.append(item)

def pop(self):

return self.stack.pop() if not self.is_empty() else None

def is_empty(self):

return len(self.stack) == 0

def peek(self):

return self.stack[-1] if not self.is_empty() else None

def evaluate_postfix(expression):

stack = Stack()

tokens = expression.split()

for token in tokens:

if token.isdigit():

stack.push(int(token))

else:

right_operand = stack.pop()

left_operand = stack.pop()

if token == '+':

stack.push(left_operand + right_operand)
 elif token == '-':

stack.push(left_operand - right_operand)

elif token == '*':

stack.push(left_operand * right_operand)

elif token == '/':

stack.push(left_operand // right_operand)

elif token == '^':

stack.push(left_operand ** right_operand)

return stack.pop()

expression1 = "4 2 + 3 5 1 - * +"

expression2 = "7 3 2 * + 4 2 ^ -"

expression3 = "2 3 ^ 5 4 * + 8 4 / -"

result1 = evaluate_postfix(expression1)

result2 = evaluate_postfix(expression2)

result3 = evaluate_postfix(expression3)

print("Result of expression 1:", result1)

print("Result of expression 2:", result2)

print("Result of expression 3:", result3)

question 05:

def evaluate_prefix(expr):

stack = []
 tokens = expr.split()[::-1]

for token in tokens:

if token.isdigit():

stack.append(int(token))

else:

operand1 = stack.pop()

operand2 = stack.pop()

if token == '+':

stack.append(operand1 + operand2)

elif token == '-':

stack.append(operand1 - operand2)

elif token == '*':

stack.append(operand1 * operand2)

elif token == '/':

stack.append(operand1 / operand2)

elif token == '^':

stack.append(operand1 ** operand2)

return stack.pop()

expression = "* + 5 6 - 7 3"

result = evaluate_prefix(expression)

print(f"Result of prefix expression '{expression}': {result}")

expression2 = "- + 3 5 / 8 2"

result2 = evaluate_prefix(expression2)
print(f"Result of prefix expression '{expression2}': {result2}")

expression3 = "+ 2 * 3 + 4 5"

result3 = evaluate_prefix(expression3)

print(f"Result of prefix expression '{expression3}': {result3}")

question 06:

class Node:

def __init__(self, data):

self.data = data

self.prev = None

self.next = None

class DoublyLinkedList:

def __init__(self):

self.head = None

def add_node(self, data):

newNode = Node(data)

if not self.head:

self.head = newNode

return

temp = self.head

while temp.next:

temp = temp.next

temp.next = newNode
 newNode.prev = temp

def traverse_forward(self):

temp = self.head

while temp:

print(temp.data, end=" ")

temp = temp.next

print()

dll = DoublyLinkedList()

dll.add_node(8)

dll.add_node(12)

dll.add_node(15)

dll.add_node(18)

print("Traversing the doubly linked list in forward direction:")

dll.traverse_forward()

question 07:

class Node:

def __init__(self, data):

self.data = data

self.prev = None

self.next = None

class DoublyLinkedList:

def __init__(self):
 self.head = None

def add_node(self, data):

newNode = Node(data)

if not self.head:

self.head = newNode

return

temp = self.head

while temp.next:

temp = temp.next

temp.next = newNode

newNode.prev = temp

def traverse_backward(self):

if not self.head:

return

temp = self.head

while temp.next:

temp = temp.next

while temp:

print(temp.data, end=" ")

temp = temp.prev

print()

dll = DoublyLinkedList()

dll.add_node(14)

dll.add_node(18)

dll.add_node(22)
dll.add_node(26)

print("Traversing the doubly linked list in backward direction:")

dll.traverse_backward()

question 08:

class Node:

def __init__(self, data):

self.data = data

self.next = None

class SinglyLinkedList:

def __init__(self):

self.head = None

def add_node(self, data):

new_node = Node(data)

if not self.head:

self.head = new_node

return

temp = self.head

while temp.next:

temp = temp.next

temp.next = new_node

def delete_node(self, loc):

if not self.head:
 print("The list is empty.")

return

if loc < 1:

print("Invalid location.")

return

temp = self.head

if loc == 1:

self.head = temp.next

temp = None

return

for _ in range(loc - 2):

if temp.next:

temp = temp.next

else:

print("Invalid location.")

return

if not temp.next:

print("Invalid location.")

return

next_node = temp.next.next

temp.next = None

temp.next = next_node

def print_list(self):

temp = self.head

while temp:
 print(temp.data, end=" ")

temp = temp.next

print()

sll = SinglyLinkedList()

sll.add_node(35)

sll.add_node(27)

sll.add_node(18)

sll.add_node(45)

print("Original list:")

sll.print_list()

loc = 3

sll.delete_node(loc)

print(f"List after deleting node at location {loc}:")

sll.print_list()

question 09:

class Stack:

def __init__(self):

self.stack = []

def is_empty(self):

return len(self.stack) == 0

def push(self, item):

def pop(self):

return self.stack.pop() if not self.is_empty() else None

def peek(self):

return self.stack[-1] if not self.is_empty() else None

def size(self):

return len(self.stack)

def sort_stack(self):

temp_stack = Stack()

while not self.is_empty():

temp = self.pop()

while not temp_stack.is_empty() and temp_stack.peek() > temp:

self.push(temp_stack.pop())

temp_stack.push(temp)

while not temp_stack.is_empty():

self.push(temp_stack.pop())

def print_stack(self):

for item in reversed(self.stack):

print(item, end=" ")

print()

s = Stack()

s.push(54)

s.push(29)

s.push(17)

s.push(63)
s.push(42)

s.push(77)

print("Original stack:")

s.print_stack()

s.sort_stack()

print("Sorted stack:")

s.print_stack()