class stack:

def __init__(self , limit=100):

)Stack( ‫پشته‬
self.top = -1
‫ اولین‬،‫پشته یک ساختمان داده است که بر اساس اصل "آخرین ورودی‬
self.limit = limit
self.list = [None]*limit .‫) انجام میشود‬LIFO - Last In, First Out( "‫خروجی‬

def push(self , item):

if self.is_full():
print("stack is full")
return
self.top += 1
self.list[self.top] = item

def pop(self):
if self.is_empty():
print("stack is empty")
return
popped_item = self.list[self.top]
self.list.pop(self.top)
self.top -= 1
return popped_item

def is_empty(self):
return self.top == -1 : )Dynamic Stack( ‫پشته پویا‬
def is_full(self):
class dynamic_stack:
return self.top == self.limit - 1
def __init__(self):
self.top = -1
def show(self): # or showV()
self.list = []
if self.is_empty():
print("stack is empty")
def push(self, item):
return
self.list.append(item)
data = []
self.top += 1
for i in range(self.top + 1):
data.append(self.list[i])
def pop(self):
return data
if self.is_empty():
print("stack is empty")
def peek(self): # or top()
return
if self.top == -1:
popped_item = self.list[self.top]
print("stack is empty")
self.list.pop()
return
self.top -= 1
return self.list[self.top]
return popped_item

def find(self , item):

def is_empty(self):
if self.is_empty():
return self.top == -1
print("stack is empty")
return
for i in range(self.top + 1):
if self.list[i] == item:
return True
return False

def clear(self):
self.top = -1
self.list = []*self.limit
class queue():
)Queue( ‫صف‬
def __init__(self,size=100):
self.front = -1
‫ یک ساختمان داده است که بر اساس اصل "اولین‬،‫ مانند پشته‬،‫صف‬
self.rear = -1
self.limit = size
.‫) عمل میکند‬FIFO - First In, First Out( "‫ اولین خروجی‬،‫ورودی‬
self.list = [None]*size

def enqueue(self,item):
if self.is_full():
print("queue is full")
return
if self.rear == -1:
self.front = 0
self.rear = 0
self.list[self.rear] = item
return
self.rear += 1
self.list[self.rear] = item

def dequeue(self):
if self.is_empty():
print("queue is empty")
return
self.front += 1

def show(self): # or display()

if self.is_empty():
return None
data = []
for i in range(self.front, self.rear + 1):
data.append(self.list[i])
return data

def is_empty(self):
return self.rear == -1

def is_full(self):
return self.rear == self.limit - 1

def peek(self): # or front()

if self.is_empty():
return
return self.list[self.front]
class Cqueue: )Circular Queue( ‫صف حلقوی‬
def __init__(self,size=100):
self.front = -1
self.rear = -1
self.limit = size
self.list = [None]*size

def enqueue(self,item):
if self.is_full():
print("queue is full")
return
if self.is_empty():
self.front = self.rear = 0
self.list[0] = item
return
self.rear = (self.rear + 1) % self.limit
self.list[self.rear] = item

def dequeue(self):
if self.is_empty():
print("queue is empty")
return
if self.front == self.rear:
self.front , self.rear = -1 , -1
return
def showIV(self):
self.front = (self.front + 1) % self.limit
if self.rear == self.front:
return None
def is_empty(self):
data = []
return self.rear == -1
i = self.rear + 1
while True:
def is_full(self):
if self.list[i] == None:
return (self.rear + 1) % self.limit == self.front
pass
else:
def showV(self):
data.append(self.list[i])
if self.rear == self.front:
if i == self.front - 1:
return None
break
data = []
i = (i + 1) % self.limit
i = self.front
return data
while True:
data.append(self.list[i])
if i == self.rear:
break
i = (i + 1) % self.limit
return data
class Node:
def __init__(self, data): )Singly Linked List( ‫لیست پیوندی یک طرفه‬
self.data = data
self.next = None

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

def insert_at_end(self,value): # or append()

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

def insert_at_first(self,value): # or prepend()

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

def insert_after(self,prev_node,value):
if self.head is None:
return "Error"
current = self.head
if current.next is None:
if current.data == prev_node:
new_node = Node(value) def is_find(self, value):

current.next = new_node current = self.head

else: while current:

return "Error" if current.data == value:

while current: return True

if current.data == prev_node: current = current.next

new_node = Node(value) return False

new_node.next = current.next
current.next = new_node def replace(self, old_value, new_value):

return current = self.head

current = current.next while current:

return "Error" if current.data == old_value:

current.data = new_value

def delete_first(self): return

if self.head is None: current = current.next

return "list is empty"

current = self.head def display(self): # or show()

self.head = self.head.next current = self.head

del current while current.next:

print(f"{current.data} -> ",end="")

def is_empty(self): current = current.next

return self.head == None print(current.data,end="")

 )Circular Singly Linked List( ‫لیست پیوندی یک طرفه حلقوی‬

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

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

def insert_at_end(self,value): # or append()

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

def insert_at_first(self,value): # or prepend()

new_node = Node(value)
if self.head is None:
self.head = new_node
new_node.next = new_node
else:
current = self.head
new_node.next = self.head def replace(self, old_value, new_value):
self.head = new_node current = self.head
while current.next != self.head: while current:
current = current.next if current.data == old_value:
current.next = new_node current.data = new_value
self.head = new_node return
current = current.next
def is_empty(self): if current == self.head:
return self.head == None break

def search(self, value): # or is_find def display(self): # or show()

current = self.head current = self.head
while current: while current:
if current.data == value: print(f"{current.data} -> ",end="")
return True current = current.next
current = current.next if current == self.head:
if current == self.head: break
break print(current.data,end="")
return False
 )Doubly Linked List( ‫لیست پیوندی دوطرفه‬

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

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

def insert_at_end(self,value): # or append()

if self.head is None:
new_node = Node(value)
self.head = new_node
return
current = self.head
while current.next:
current = current.next
new_node = Node(value) def delete_first(self):
current.next = new_node if self.head is None:
new_node.prev = current return "list is empty"
current = self.head
def insert_at_first(self,value): # or prepend() self.head.prev.next = self.head.next
new_node = Node(value) self.head = self.head.next
new_node.next = self.head del current
if self.head:
self.head.prev = new_node def is_empty(self):
self.head = new_node return self.head == None

def insert_after(self,prev_node,value): def is_find(self, value):

if self.head is None: current = self.head
return "Error" while current:
current = self.head if current.data == value:
if current.next is None: return True
if current.data == prev_node: current = current.next
new_node = Node(value) return False
current.next = new_node
else: def replace(self, old_value, new_value):
return "Error" current = self.head
while current: while current:
if current.data == prev_node: if current.data == old_value:
new_node = Node(value) current.data = new_value
new_node.next = current.next return
new_node.prev = current current = current.next
if current.next:
current.next.prev = new_node def display(self): # or show()
current.next = new_node current = self.head
return while current.next:
current = current.next print(f"{current.data} <-> ",end="")
return "Error" current = current.next
print(current.data,end="")
class Node:
)Binary Tree( ‫درخت باینری‬
def __init__(self, d):
self.data = d
self.left = None
self.right = None

class Node:
def __init__(self, key): def inorder(self, node):
self.left = None if node:
self.right = None self.inorder(node.left)
self.val = key print(node.key, end=' ')
self.inorder(node.right)
def insert(self, key):
new_node = Node(key) def preorder(self, node):
if not self.root: if node:
self.root = new_node print(node.key, end=' ')
return self.preorder(node.left)
queue = [self.root] self.preorder(node.right)
while queue:
temp = queue.pop(0) def postorder(self, node):
if not temp.left: if node:
temp.left = new_node self.postorder(node.left)
return self.postorder(node.right)
else: print(node.key, end=' ')
queue.append(temp.left)
if not temp.right: def level_order(self):
temp.right = new_node if not self.root:
return return
else: queue = [self.root]
queue.append(temp.right) while queue:
temp = queue.pop(0)
def search(self, key): print(temp.key, end=' ')
if not self.root: if temp.left:
return False queue.append(temp.left)
queue = [self.root] if temp.right:
while queue: queue.append(temp.right)
node = queue.pop(0)
if node.key == key:
return True
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return False

def height(self, node):

if not node:
return 0
return 1 + max(self.height(node.left), self.height(node.right))
 ‫نمونه سواالت‬
def evaluate_postfix(expression): ‫ الگوریتمی بنویسید که یک عبارت ریاضی در‬.1
stack = dynamic_stack()
‫نمادگذاری پسوندی را دریافت کرده و مقدار آن را‬
operators = "+-*/"
tokens = expression.split() ‫ از یک پشته برای حل مسئله استفاده‬.‫محاسبه کند‬
.‫کنید‬
for token in tokens:
if token not in operators:
stack.push(float(token))
else:
right = stack.pop()
left = stack.pop()
if token == '+':
result = left + right
elif token == '-':
result = left - right
elif token == '*':
result = left * right
elif token == '/':
if right == 0:
raise ZeroDivisionError("Division by zero")
result = left / right
stack.push(result)

return stack.pop()

.‫ {} را بررسی کند و تشخیص دهد آیا پرانتزها به درستی بسته شدهاند یا خیر‬,][ ,)( ‫ تابعی بنویسید که یک رشته شامل پرانتزهای‬.2

def is_balanced(expression):
stack = []
pairs = {')': '(', ']': '[', '}': '{'}

for char in expression:

if char in '([{':
stack.append(char)
elif char in ')]}':
if not stack or stack[-1] != pairs[char]:
return False
stack.pop()

return len(stack) == 0
 class QueueWithTwoStacks:
‫ یک صف را با استفاده از دو پشته پیاده سازی کنید‬.3
def __init__(self):
self.stack_in = []
self.stack_out = []

def enqueue(self, x):

self.stack_in.append(x)

def dequeue(self):
if self.stack_out:
while self.stack_in:
self.stack_out.append(self.stack_in.pop())
if not self.stack_out:
print("Queue is empty")
return self.stack_out.pop()

def is_empty(self):
return not self.stack_in and not self.stack_out

class Node:
def __init__(self, data, priority): ‫) با‬Priority Queue( ‫ یک صف اولویت دار‬.4
self.data = data
.‫استفاده از لیست پیوندی پیاده سازی کنید‬
self.priority = priority
self.next = None

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

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

def enqueue(self, data, priority):

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

def dequeue(self):
if self.is_empty():
print("Queue is empty!")
return None
removed = self.front
self.front = self.front.next
return removed.data
 class Node:
‫ الگوریتمی بنویسید که تشخیص دهد آیا یک لیست‬.5
def __init__(self, data):
self.data = data .‫پیوندی دارای حلقه است یا خیر‬
self.next = None

def has_cycle(head):
slow = head
fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next

if slow == fast:
return True
return False

class Node:
‫ تابعی بنویسید که یک لیست پیوندی را به صورت‬.6
def __init__(self, data): .‫ گره) معکوس کند‬k ‫گروهی (هر‬
self.data = data
self.next = None

def reverse_k_group(head, k):

current = head
count = 0

while current and count < k:

current = current.next
count += 1

if count == k:
reversed_head = reverse_k_group(current, k)
current = head
for _ in range(k):
next_node = current.next
current.next = reversed_head
reversed_head = current
current = next_node
head = reversed_head
return head

def print_list(node):
while node:
print(node.data, end=" → " if node.next else "\n")
node = node.next
class Node: ‫ الگوریتمی بنویسید که یک درخت دودویی را به‬.7
def __init__(self, x):
‫صورت مورب پیمایش کند و مقادیر هر مورب را‬
self.data = x
self.left = None )diagonal traversal( .‫چاپ کند‬
self.right = None

def diagonalRecur(root, level, levelData):

if root is None:
return
if level not in levelData:
levelData[level] = []
levelData[level].append(root.data)
diagonalRecur(root.left, level + 1, levelData)
diagonalRecur(root.right, level, levelData)

def diagonal(root):
ans = []
levelData = {}
diagonalRecur(root, 0, levelData)
level = 0
while level in levelData:
ans.extend(levelData[level])
level += 1
return ans

.‫) دریافت کند و کوچکترین جد مشترک آنها را برگرداند‬BST( ‫ تابعی بنویسید که دو گره در یک درخت جستجوی دودویی‬.8

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

def find_LCA_BST(root, p, q):

if not root:
return None
if p.data < root.data and q.data < root.data:
return find_LCA_BST(root.left, p, q)
if p.data > root.data and q.data > root.data:
return find_LCA_BST(root.right, p, q)
return root
class Node:
‫ یک‬Inorder ‫ الگوریتمی بنویسید که پیمایش‬.9
def __init__(self, data):
self.data = data ‫درخت دودویی را بدون بازگشت و با استفاده از‬
self.left = None .‫یک پشته انجام دهد‬
self.right = None

def inorder_iterative(root):
stack = []
current = root
while stack or current:
while current:
stack.append(current)
current = current.left
current = stack.pop()
print(current.data, end=" ")
current = current.right

class Node:
def __init__(self, key, value):
‫ را با‬LRU (Least Recently Used) ‫ یک سیستم کش‬.10
self.key = key ‫ترکیب یک صف (بر اساس لیست پیوندی) و یک هش مپ‬
self.value = value
.‫ را شرح دهید‬put ‫ و‬get ‫پیادهسازی کنید و عملیات‬
self.prev = None
self.next = None

class LRUCache:
def __init__(self, capacity):
self.capacity = capacity
self.cache = dict()

self.head = Node(0, 0)
self.tail = Node(0, 0)
self.head.next = self.tail
self.tail.prev = self.head

def _remove(self, node):

prev = node.prev
nxt = node.next
prev.next = nxt
nxt.prev = prev

def _add_to_front(self, node):

node.prev = self.head
node.next = self.head.next
def put(self, key, value):
self.head.next.prev = node
if key in self.cache:
self.head.next = node
self._remove(self.cache[key])
elif len(self.cache) == self.capacity:
def get(self, key):
lru = self.tail.prev
if key in self.cache:
self._remove(lru)
node = self.cache[key]
del self.cache[lru.key]
self._remove(node)
node = Node(key, value)
self._add_to_front(node)
self._add_to_front(node)
return node.value
self.cache[key] = node
return -1
class Node:
def __init__(self, data): ‫ پیاده سازی صف با لیست پیوندی‬.11
self.data = data
self.next = None
def dequeue(self):
if self.is_empty():
class LinkedQueue:
print("queue is empty")
def __init__(self):
return None
self.front = None
value = self.front.data
self.rear = None
self.front = self.front.next
if self.front is None:
def is_empty(self):
self.rear = None
return self.front is None
return value

def enqueue(self, value):

def peek(self):
new_node = Node(value)
if self.is_empty():
if self.rear is None:
return None
self.front = self.rear = new_node
return self.front.data
else:
self.rear.next = new_node
def display(self):
self.rear = new_node
current = self.front
while current:
print(current.data, end=" ")
current = current.next

class Node: ‫ پیاده سازی پشته با لیست پیوندی‬.12

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

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

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

def push(self, value): def peek(self):

new_node = Node(value) if self.is_empty():

new_node.next = self.top print("stack is empty")

self.top = new_node return None

return self.top.data

def pop(self):
if self.is_empty(): def display(self):

print("stack is empty") current = self.top

return None while current:

value = self.top.data print(current.data, end=" ")

self.top = self.top.next current = current.next

return value
def find_lca(root, n1, n2):
‫ کوچک ترین جد مشترک دو گره در یک درخت دودویی‬.13
if root is None:
return None )BT(
if root.val == n1 or root.val == n2: ‫ مراجعه کنید‬8 ‫ به سوال‬class node ‫برای‬ •
return root
left_lca = find_lca(root.left, n1, n2)
right_lca = find_lca(root.right, n1, n2)
if left_lca and right_lca:
return root
return left_lca if left_lca is not None else right_lca

‫ کوچک ترین جد مشترک دو گره بدون استفاده از تابع بازگشتی‬.14

def find_path(root, target):
stack = [(root, [root])]
while stack:
node, path = stack.pop()
if node.data == target:
return path
if node.right:
stack.append((node.right, path + [node.right]))
if node.left:
stack.append((node.left, path + [node.left]))
return None

def find_lca(root, n1, n2):

path1 = find_path(root, n1)
path2 = find_path(root, n2)

if path1 is None or path2 is None:

return None

lca = None
for u, v in zip(path1, path2):
if u.data == v.data:
lca = u
else:
break
return lca