Data Structure and Application (1333203) - Summer 2025 Solution (Gujarati)

class Cricketer:
    def __init__(self, name="", team="", run=0):
        self.name = name
        self.team = team
        self.run = run
    
    def set_run(self, run):
        self.run = run
    
    def display_run(self):
        print(f"ખેલાડી: {self.name}")
        print(f"ટીમ: {self.team}")
        print(f"રન: {self.run}")

# ઉદાહરણ ઉપયોગ
player = Cricketer("વિરાટ કોહલી", "ભારત", 100)
player.display_run()

class Student:
    def __init__(self):
        self.name = ""
        self.roll_no = ""
        self.marks = 0
        self.__getInfo()  # પ્રાઇવેટ મેથડ કૉલ
    
    def __getInfo__(self):  # પ્રાઇવેટ મેથડ
        self.name = input("નામ દાખલ કરો: ")
        self.roll_no = input("રોલ નંબર દાખલ કરો: ")
        self.marks = int(input("માર્ક્સ દાખલ કરો: "))
    
    def displayInfo(self):
        print(f"નામ: {self.name}")
        print(f"રોલ નંબર: {self.roll_no}")
        print(f"માર્ક્સ: {self.marks}")

# ઉદાહરણ ઉપયોગ
student = Student()
student.displayInfo()

def factorial(n):
    # બેઝ કેસ
    if n <= 1:
        return 1
    # રિકર્સિવ કેસ
    return n * factorial(n-1)

# ઉદાહરણ: factorial(3)
# 3 * factorial(2)
# 3 * 2 * factorial(1)
# 3 * 2 * 1 = 6

class Queue:
    def __init__(self):
        self.queue = []
        self.front = 0
        self.rear = -1
    
    def enqueue(self, item):
        self.queue.append(item)
        self.rear += 1
        print(f"એનક્યૂ કર્યું: {item}")
    
    def dequeue(self):
        if self.front <= self.rear:
            item = self.queue[self.front]
            self.front += 1
            print(f"ડીક્યૂ કર્યું: {item}")
            return item
        else:
            print("ક્યૂ ખાલી છે")
            return None
    
    def display(self):
        if self.front <= self.rear:
            print("ક્યૂ:", self.queue[self.front:self.rear+1])
        else:
            print("ક્યૂ ખાલી છે")

# ઉદાહરણ ઉપયોગ
q = Queue()
q.enqueue('A')
q.enqueue('B')
q.dequeue()
q.display()

def search_node(head, key):
    current = head
    position = 0
    
    while current is not None:
        if current.data == key:
            return position
        current = current.next
        position += 1
    
    return -1  # નહીં મળ્યું

# અલ્ગોરિધમ સ્ટેપ્સ:
# 1. હેડ થી શરૂ કરો
# 2. વર્તમાન ડેટાને કી સાથે સરખાવો
# 3. જો મળ્યું તો પોઝિશન રિટર્ન કરો
# 4. આગલા નોડ પર જાઓ
# 5. અંત સુધી પુનરાવર્તન કરો

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

class SinglyLinkedList:
    def __init__(self):
        self.head = None
    
    def insert_at_beginning(self, data):
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node
        print(f"શરૂઆતમાં {data} દાખલ કર્યું")
    
    def delete_from_beginning(self):
        if self.head is None:
            print("લિસ્ટ ખાલી છે")
            return None
        
        deleted_data = self.head.data
        self.head = self.head.next
        print(f"શરૂઆતથી {deleted_data} કાઢ્યું")
        return deleted_data
    
    def display(self):
        current = self.head
        while current:
            print(current.data, end=" -> ")
            current = current.next
        print("NULL")

# ઉદાહરણ ઉપયોગ
ll = SinglyLinkedList()
ll.insert_at_beginning(10)
ll.insert_at_beginning(20)
ll.delete_from_beginning()
ll.display()

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

class CircularLinkedList:
    def __init__(self):
        self.head = None
    
    def insert(self, data):
        new_node = Node(data)
        
        if self.head is None:
            self.head = new_node
            new_node.next = self.head
        else:
            current = self.head
            while current.next != self.head:
                current = current.next
            current.next = new_node
            new_node.next = self.head
    
    def display(self):
        if self.head is None:
            print("લિસ્ટ ખાલી છે")
            return
        
        current = self.head
        print("સર્ક્યુલર લિસ્ટ:")
        while True:
            print(current.data, end=" -> ")
            current = current.next
            if current == self.head:
                break
        print(f"{self.head.data} (હેડ પર પાછા)")

# ઉદાહરણ ઉપયોગ
cll = CircularLinkedList()
cll.insert(10)
cll.insert(20)
cll.insert(30)
cll.display()

def selection_sort(arr):
    n = len(arr)
    
    for i in range(n):
        min_idx = i
        for j in range(i+1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    
    return arr

# ઉદાહરણ ઉપયોગ
data = [64, 34, 25, 12, 22]
sorted_data = selection_sort(data)
print("સૉર્ટેડ એરે:", sorted_data)

def linear_search(arr, target):
    comparisons = 0
    
    for i in range(len(arr)):
        comparisons += 1
        if arr[i] == target:
            print(f"એલિમેન્ટ {target} ઇન્ડેક્સ {i} પર મળ્યું")
            print(f"સરખામણીઓની સંખ્યા: {comparisons}")
            return i
    
    print(f"એલિમેન્ટ {target} નહીં મળ્યું")
    print(f"સરખામણીઓની સંખ્યા: {comparisons}")
    return -1

def linear_search_all_positions(arr, target):
    positions = []
    for i in range(len(arr)):
        if arr[i] == target:
            positions.append(i)
    return positions

# ઉદાહરણ ઉપયોગ
data = [10, 25, 30, 15, 20, 30, 35]
target = 30

result = linear_search(data, target)
all_positions = linear_search_all_positions(data, target)
print(f"{target} ની બધી પોઝિશન: {all_positions}")

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        
        arr[j + 1] = key
    
    return arr

# ઉદાહરણ ઉપયોગ
data = [12, 11, 13, 5, 6]
print("મૂળ:", data)
sorted_data = insertion_sort(data.copy())
print("સૉર્ટેડ:", sorted_data)

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    
    result.extend(left[i:])
    result.extend(right[j:])
    
    return result

# ઉદાહરણ ઉપયોગ
data = [38, 27, 43, 3, 9, 82, 10]
sorted_data = merge_sort(data)
print("સૉર્ટેડ એરે:", sorted_data)

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

class BST:
    def __init__(self):
        self.root = None
    
    def insert(self, data):
        self.root = self._insert_recursive(self.root, data)
    
    def _insert_recursive(self, node, data):
        if node is None:
            return TreeNode(data)
        
        if data < node.data:
            node.left = self._insert_recursive(node.left, data)
        elif data > node.data:
            node.right = self._insert_recursive(node.right, data)
        
        return node
    
    def inorder(self, node):
        if node:
            self.inorder(node.left)
            print(node.data, end=" ")
            self.inorder(node.right)

def main():
    bst = BST()
    
    while True:
        print("\n1. દાખલ કરો")
        print("2. દર્શાવો (ઇનઓર્ડર)")
        print("3. બહાર નીકળો")
        
        choice = int(input("પસંદગી દાખલ કરો: "))
        
        if choice == 1:
            data = int(input("ડેટા દાખલ કરો: "))
            bst.insert(data)
        elif choice == 2:
            print("BST (ઇનઓર્ડર):", end=" ")
            bst.inorder(bst.root)
            print()
        elif choice == 3:
            break

if __name__ == "__main__":
    main()

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

class BST:
    def __init__(self):
        self.root = None
    
    def insert(self, data):
        if self.root is None:
            self.root = TreeNode(data)
            print(f"રૂટ નોડ {data} બનાવ્યું")
        else:
            self._insert_helper(self.root, data)
    
    def _insert_helper(self, node, data):
        if data < node.data:
            if node.left is None:
                node.left = TreeNode(data)
                print(f"{data} ને {node.data} ની ડાબી બાજુએ દાખલ કર્યું")
            else:
                self._insert_helper(node.left, data)
        elif data > node.data:
            if node.right is None:
                node.right = TreeNode(data)
                print(f"{data} ને {node.data} ની જમણી બાજુએ દાખલ કર્યું")
            else:
                self._insert_helper(node.right, data)
        else:
            print(f"ડેટા {data} પહેલેથી અસ્તિત્વમાં છે")
    
    def display_inorder(self, node, result):
        if node:
            self.display_inorder(node.left, result)
            result.append(node.data)
            self.display_inorder(node.right, result)

def main():
    bst = BST()
    
    while True:
        print("\n--- BST ઓપરેશનો ---")
        print("1. એલિમેન્ટ દાખલ કરો")
        print("2. BST દર્શાવો (ઇનઓર્ડર)")
        print("3. બહાર નીકળો")
        
        choice = int(input("તમારી પસંદગી દાખલ કરો: "))
        
        if choice == 1:
            data = int(input("દાખલ કરવાનું એલિમેન્ટ દાખલ કરો: "))
            bst.insert(data)
        elif choice == 2:
            result = []
            bst.display_inorder(bst.root, result)
            print("BST એલિમેન્ટ્સ (સૉર્ટેડ):", result)
        elif choice == 3:
            print("બહાર નીકળી રહ્યા છીએ...")
            break
        else:
            print("અયોગ્ય પસંદગી!")

if __name__ == "__main__":
    main()