ડેટા સ્ટ્રક્ચર વિથ પાયથોન (4331601) - શિયાળો 2024 સોલ્યુશન

પ્રશ્ન 1(a) [3 ગુણ]

#

પાયથોનમાં સેટ ડેટા સ્ટ્રક્ચર સમજાવો?

ઉત્તર:

સેટ એ પાયથોનમાં અનન્ય એલિમેન્ટ્સનો અક્રમ સંગ્રહ છે. સેટ્સ mutable છે પરંતુ તેમાં ફક્ત immutable એલિમેન્ટ્સ જ હોય છે.

મુખ્ય લક્ષણો:

મૂળભૂત ઓપરેશન્સ:

# સેટ બનાવો
my_set = {1, 2, 3, 4}
# એલિમેન્ટ ઉમેરો
my_set.add(5)
# એલિમેન્ટ દૂર કરો
my_set.remove(2)

મેમરી ટ્રીક: “સેટ્સ એ અનન્ય અક્રમ સંગ્રહો છે”

પ્રશ્ન 1(b) [4 ગુણ]

#

પાયથોનમાં Tuple ની વ્યાખ્યા આપો? પાયથોનમાં Tuple data structure ના operations સમજાવો.

ઉત્તર:

Tuple એ આઇટમ્સનો ક્રમિત સંગ્રહ છે જે immutable છે (બનાવ્યા પછી બદલી શકાતું નથી).

Tuple વ્યાખ્યા:

• ક્રમિત: એલિમેન્ટ્સનો નિશ્ચિત ક્રમ
• Immutable: બનાવ્યા પછી બદલી શકાતું નથી
• ડુપ્લિકેટ્સ મંજૂર: સમાન વેલ્યુઝ આવી શકે છે
• ઇન્ડેક્સ્ડ: ઇન્ડેક્સ વાપરીને એક્સેસ કરી શકાય છે

Tuple ઓપરેશન્સ:

# ઉદાહરણ ઓપરેશન્સ
tup = (10, 20, 30, 40)
print(tup[1])      # આઉટપુટ: 20
print(tup[1:3])    # આઉટપુટ: (20, 30)

મેમરી ટ્રીક: “Tuples એ Immutable ક્રમિત સંગ્રહો છે”

પ્રશ્ન 1(c) [7 ગુણ]

#

પાયથોનમાં કન્સ્ટ્રક્ટરના પ્રકારો સમજાવો? Static methodનો ઉપયોગ કરીને બે સંખ્યાઓના ગુણાકાર માટે પાયથોન પ્રોગ્રામ લખો.

ઉત્તર:

કન્સ્ટ્રક્ટરના પ્રકારો:

Static Method પ્રોગ્રામ:

class Calculator:
    def __init__(self):
        pass
    
    @staticmethod
    def multiply(num1, num2):
        return num1 * num2

# ઉપયોગ
result = Calculator.multiply(5, 3)
print(f"ગુણાકાર: {result}")  # આઉટપુટ: 15

મુખ્ય મુદ્દાઓ:

• Static methods: ઑબ્જેક્ટ ઇન્સ્ટન્સની જરૂર નથી
• @staticmethod decorator: Static method દર્શાવે છે
• કોઈ self પેરામીટર નથી: ક્લાસ ઇન્સ્ટન્સથી સ્વતંત્ર

મેમરી ટ્રીક: “Static methods સેલ્ફથી અલગ રહે છે”

પ્રશ્ન 1(c) અથવા [7 ગુણ]

#

Data Encapsulation ની વ્યાખ્યા આપો? પાયથોનમાં વિવિધ પ્રકારની methods ની યાદી આપો. Multilevel inheritance માટે પાયથોન પ્રોગ્રામ લખો.

ઉત્તર:

Data Encapsulation: ડેટા એન્કેપ્સુલેશન એ ડેટા અને methods ને ક્લાસની અંદર બાંધવાની અને કેટલાક ઘટકોની સીધી પહોંચ મર્યાદિત કરવાની વિભાવના છે.

Methods ના પ્રકારો:

Multilevel Inheritance પ્રોગ્રામ:

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name} અવાજ કરે છે")

class Mammal(Animal):
    def __init__(self, name, warm_blooded):
        super().__init__(name)
        self.warm_blooded = warm_blooded

class Dog(Mammal):
    def __init__(self, name, breed):
        super().__init__(name, True)
        self.breed = breed
    
    def bark(self):
        print(f"{self.name} ભસે છે")

# ઉપયોગ
dog = Dog("બડી", "ગોલ્ડન રિટ્રીવર")
dog.speak()  # Animal ક્લાસથી
dog.bark()   # Dog ક્લાસથી

મેમરી ટ્રીક: “એન્કેપ્સુલેશન આંતરિક વિગતો છુપાવે છે”

પ્રશ્ન 2(a) [3 ગુણ]

#

Simple Queue અને Circular Queue વચ્ચેનો તફાવત આપો.

ઉત્તર:

Queue સરખામણી:

મુખ્ય તફાવતો:

• Simple Queue: Front અને rear ફક્ત એક દિશામાં જાય છે
• Circular Queue: Rear ફરીથી front સ્થાને જોડાય છે
• કાર્યક્ષમતા: Circular queue મેમરી વેસ્ટેજ ટાળે છે

મેમરી ટ્રીક: “Circular Queues વર્તુળ પૂર્ણ કરે છે”

પ્રશ્ન 2(b) [4 ગુણ]

#

પાયથોનમાં પોલીમોર્ફિઝમ ઉદાહરણ સાથે સમજાવો.

ઉત્તર:

પોલીમોર્ફિઝમ એટલે “અનેક સ્વરૂપો” - સમાન method નામ અલગ અલગ ક્લાસમાં અલગ રીતે વર્તે છે.

પોલીમોર્ફિઝમના પ્રકારો:

ઉદાહરણ:

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "ભૌં ભૌં!"

class Cat(Animal):
    def make_sound(self):
        return "મ્યાઉં!"

# પોલીમોર્ફિક વર્તન
animals = [Dog(), Cat()]
for animal in animals:
    print(animal.make_sound())

મેમરી ટ્રીક: “પોલીમોર્ફિઝમ અનેક વ્યક્તિત્વ પ્રદાન કરે છે”

પ્રશ્ન 2(c) [7 ગુણ]

#

વ્યાખ્યા આપો. a). Infix b).Postfix સ્ટેકનો ઉપયોગ કરીને આપેલ Infix expression ને Postfix expression માં ફેરવો. A+(B*C/D)

ઉત્તર:

વ્યાખ્યાઓ:

રૂપાંતરણ એલ્ગોરિધમ:

1. Infix expression ને ડાબેથી જમણે સ્કેન કરો
2. જો operand છે, આઉટપુટમાં ઉમેરો
3. જો operator છે, સ્ટેક ટોપ સાથે precedence સરખાવો
4. વધુ precedence → સ્ટેકમાં push કરો
5. ઓછી/સમાન precedence → pop કરીને આઉટપુટમાં ઉમેરો

પગલાં પ્રમાણે રૂપાંતરણ: A+(B*C/D)

અંતિમ જવાબ: ABC*D/+

મેમરી ટ્રીક: “સ્ટેક ઓપરેટર્સને વ્યૂહાત્મક રીતે સંગ્રહિત કરે છે”

પ્રશ્ન 2(a) અથવા [3 ગુણ]

#

Queue ના ગેરફાયદા સમજાવો.

ઉત્તર:

Queue ગેરફાયદાઓ:

મુખ્ય સમસ્યાઓ:

• રેખીય Queue: આગળની જગ્યાઓ અનુપયોગી બને છે
• Insertion/Deletion: ફક્ત ચોક્કસ છેડાઓથી
• શોધ ઓપરેશન્સ: શોધવા માટે કાર્યક્ષમ નથી

મેમરી ટ્રીક: “Queues શાંતિથી ક્વિર્ક્સ સાથે કતાર લગાવે છે”

પ્રશ્ન 2(b) અથવા [4 ગુણ]

#

પાયથોનમાં Abstract class ની વ્યાખ્યા આપો? પાયથોનમાં abstract method નું declaration સમજાવો?

ઉત્તર:

Abstract Class: એક ક્લાસ જેનું instantiation કરી શકાતું નથી અને જેમાં એક અથવા વધુ abstract methods હોય છે જે સબક્લાસીઝ દ્વારા અમલ કરવા જોઈએ.

Abstract Method Declaration:

ઉદાહરણ:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    
    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def area(self):
        return self.length * self.width
    
    def perimeter(self):
        return 2 * (self.length + self.width)

મેમરી ટ્રીક: “Abstract classes ફક્ત બ્લૂપ્રિન્ટ છે”

પ્રશ્ન 2(c) અથવા [7 ગુણ]

#

Infix to postfix માટેનો અલ્ગોરિધમ લખો. નીચેની પોસ્ટફિક્સ એક્સપ્રેશન મૂલ્યાંકન કરો. 5 6 2 + * 12 4 / -

ઉત્તર:

Infix to Postfix અલ્ગોરિધમ:

1. ખાલી સ્ટેક અને આઉટપુટ સ્ટ્રિંગ પ્રારંભ કરો
2. ડાબેથી જમણે infix expression સ્કેન કરો
3. જો operand છે → આઉટપુટમાં ઉમેરો
4. જો ‘(’ છે → સ્ટેકમાં push કરો
5. જો ‘)’ છે → ‘(’ સુધી pop કરો
6. જો operator છે → વધુ/સમાન precedence operators pop કરો
7. વર્તમાન operator સ્ટેકમાં push કરો
8. બાકીના operators pop કરો

Postfix મૂલ્યાંકન: 5 6 2 + * 12 4 / -

અંતિમ પરિણામ: 37

મેમરી ટ્રીક: “Postfix પ્રોસેસિંગ યુગ્મો ચોક્કસ રીતે Pop કરે છે”

પ્રશ્ન 3(a) [3 ગુણ]

#

સિંગલ લિંક લિસ્ટમાં નોડને traverse કરવા માટે અલ્ગોરિધમ લખો.

ઉત્તર:

Traversal અલ્ગોરિધમ:

def traverse_linked_list(head):
    current = head
    while current is not None:
        print(current.data)
        current = current.next

અલ્ગોરિધમ પગલાં:

મેમરી ટ્રીક: “Traverse ટેઇલ સુધી પહોંચે છે”

પ્રશ્ન 3(b) [4 ગુણ]

#

લિસ્ટનો ઉપયોગ કરીને Queueના Dequeue ઓપરેશન માટેનો અલ્ગોરિધમ લખો.

ઉત્તર:

Dequeue અલ્ગોરિધમ:

def dequeue(queue):
    if len(queue) == 0:
        print("Queue ખાલી છે")
        return None
    else:
        element = queue.pop(0)
        return element

અલ્ગોરિધમ પગલાં:

Time Complexity: O(n) લિસ્ટ shifting ને કારણે

મેમરી ટ્રીક: “Dequeue આગળના દરવાજેથી ડિલીટ કરે છે”

પ્રશ્ન 3(c) [7 ગુણ]

#

Double linked list ની વ્યાખ્યા આપો. લિંક લિસ્ટના મુખ્ય ઓપરેશનની નોંધણી કરો. Single Linked list મા શરૂઆતમાં નોડ દાખલ કરવા માટેનો અલ્ગોરિધમ લખો.

ઉત્તર:

Double Linked List: એક રેખીય ડેટા સ્ટ્રક્ચર જ્યાં દરેક નોડમાં ડેટા અને બે pointers હોય છે - એક આગલા નોડ તરફ અને બીજો પાછલા નોડ તરફ.

લિંક લિસ્ટના મુખ્ય ઓપરેશન્સ:

શરૂઆતમાં Insert અલ્ગોરિધમ:

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

def insert_at_beginning(head, data):
    new_node = Node(data)
    new_node.next = head
    head = new_node
    return head

અલ્ગોરિધમ પગલાં:

1. આપેલ ડેટા સાથે નવો નોડ બનાવો
2. નવા નોડનો next વર્તમાન head પર સેટ કરો
3. Head ને નવા નોડ તરફ અપડેટ કરો
4. નવો head પરત કરો

મેમરી ટ્રીક: “શરૂઆતમાં Insert બેહતર લિસ્ટ બનાવે છે”

પ્રશ્ન 3(a) અથવા [3 ગુણ]

#

Single Linked List ની એપ્લિકેશન સમજાવો.

ઉત્તર:

Single Linked List એપ્લિકેશન્સ:

મુખ્ય ફાયદાઓ:

• Dynamic Size: રનટાઇમ દરમિયાન વધે/ઘટે છે
• મેમરી કાર્યક્ષમતા: જરૂર પ્રમાણે allocate કરે છે
• Insertion/Deletion: કોઈપણ સ્થાને કાર્યક્ષમ

મેમરી ટ્રીક: “Linked Lists અનેક એપ્લિકેશન્સને લિંક કરે છે”

પ્રશ્ન 3(b) અથવા [4 ગુણ]

#

લિસ્ટનો ઉપયોગ કરીને સ્ટેકના PUSH ઓપરેશન માટે અલ્ગોરિધમ લખો.

ઉત્તર:

PUSH અલ્ગોરિધમ:

def push(stack, element):
    stack.append(element)
    print(f"સ્ટેકમાં {element} push કર્યું")

અલ્ગોરિધમ પગલાં:

વિગતવાર અલ્ગોરિધમ:

1. સ્ટેક અને push કરવાનું એલિમેન્ટ સ્વીકારો
2. સ્ટેકની ક્ષમતા ચકાસો (fixed size માટે)
3. append() વાપરીને લિસ્ટના અંતે એલિમેન્ટ ઉમેરો
4. લિસ્ટ આપોઆપ મેમરી allocation હેન્ડલ કરે છે
5. સફળતાની સ્થિતિ પરત કરો

Time Complexity: O(1) - Constant time ઓપરેશન

મેમરી ટ્રીક: “PUSH સ્ટેક શિખર પર મૂકે છે”

પ્રશ્ન 3(c) અથવા [7 ગુણ]

#

Linked list ના ફાયદા સમજાવો. Single linked list માંથી last નોડ કાઢી નાખવા માટે અલ્ગોરિધમ લખો.

ઉત્તર:

Linked List ફાયદાઓ:

છેલ્લો નોડ ડિલીટ કરવાનો અલ્ગોરિધમ:

def delete_last_node(head):
    # ખાલી લિસ્ટ
    if head is None:
        return None
    
    # એક જ નોડ
    if head.next is None:
        return None
    
    # અનેક નોડ્સ
    current = head
    while current.next.next is not None:
        current = current.next
    
    current.next = None
    return head

અલ્ગોરિધમ પગલાં:

1. ખાલી લિસ્ટ કેસ હેન્ડલ કરો
2. એક નોડ કેસ હેન્ડલ કરો
3. છેલ્લાથી બીજા નોડ સુધી traverse કરો
4. છેલ્લાથી બીજા નોડનો next NULL પર સેટ કરો
5. અપડેટેડ head પરત કરો

મેમરી ટ્રીક: “Linked Lists તાર્કિક ફાયદાઓ તરફ દોરી જાય છે”

પ્રશ્ન 4(a) [3 ગુણ]

#

બબલ સૉર્ટમાટેના અલ્ગોરિધમ લખો.

ઉત્તર:

Bubble Sort અલ્ગોરિધમ:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

અલ્ગોરિધમ પગલાં:

Time Complexity: O(n²)

મેમરી ટ્રીક: “બબલ્સ ધીમે ધીમે સપાટી પર આવે છે”

પ્રશ્ન 4(b) [4 ગુણ]

#

Circular linked list ને તેના ફાયદાઓ સાથે સમજાવો.

ઉત્તર:

Circular Linked List: એક લિંક લિસ્ટ જ્યાં છેલ્લો નોડ પ્રથમ નોડ તરફ પોઇન્ટ કરે છે, વર્તુળાકાર સ્ટ્રક્ચર બનાવે છે.

લક્ષણો:

ફાયદાઓ:

• મેમરી કાર્યક્ષમ: કોઈ NULL pointers નથી
• વર્તુળાકાર Traversal: સતત લૂપ કરી શકાય છે
• Queue Implementation: કાર્યક્ષમ enqueue/dequeue
• Round Robin Scheduling: CPU time sharing
• Music Player: સતત playlist looping

મેમરી ટ્રીક: “Circular Lists સતત કનેક્શન્સ બનાવે છે”

પ્રશ્ન 4(c) [7 ગુણ]

#

યોગ્ય ઉદાહરણ સાથે મર્જ સૉર્ટ સમજાવો.

ઉત્તર:

Merge Sort: એક divide-and-conquer અલ્ગોરિધમ જે array ને ભાગોમાં વહેંચે છે, તેમને અલગ અલગ સૉર્ટ કરે છે, અને પછી ભેગા કરે છે.

અલ્ગોરિધમ તબક્કાઓ:

ઉદાહરણ: [38, 27, 43, 3, 9, 82, 10]

Time Complexity: O(n log n) Space Complexity: O(n)

મેમરી ટ્રીક: “Merge Sort વ્યવસ્થિત રીતે સેગમેન્ટ્સને મર્જ કરે છે”

પ્રશ્ન 4(a) અથવા [3 ગુણ]

#

Selection sort માટેના અલ્ગોરિધમ લખો.

ઉત્તર:

Selection Sort અલ્ગોરિધમ:

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

અલ્ગોરિધમ પગલાં:

Time Complexity: O(n²)

મેમરી ટ્રીક: “Selection Sort સફળતાપૂર્વક સૌથી નાનું સિલેક્ટ કરે છે”

પ્રશ્ન 4(b) અથવા [4 ગુણ]

#

Double linked list ને તેના ફાયદાઓ સાથે સમજાવો.

ઉત્તર:

Double Linked List: એક લિંક લિસ્ટ જ્યાં દરેક નોડમાં ડેટા અને બે pointers હોય છે - next અને previous.

સ્ટ્રક્ચર:

ફાયદાઓ:

• બાયડાયરેક્શનલ Traversal: આગળ અને પાછળ બંને દિશામાં ચાલી શકાય છે
• સરળ Deletion: પાછલો નોડ જાણ્યા વગર ડિલીટ કરી શકાય છે
• કાર્યક્ષમ Insertion: કોઈપણ સ્થાને સરળતાથી insert કરી શકાય છે
• બહેતર Navigation: બંને દિશામાં ચાલી શકાય છે

એપ્લિકેશન્સ:

• Browser navigation (back/forward બટન્સ)
• Music player (previous/next ગીત)
• Undo/Redo operations

મેમરી ટ્રીક: “Double Links બેવડી દિશા પ્રદાન કરે છે”

પ્રશ્ન 4(c) અથવા [7 ગુણ]

#

Insertion સૉર્ટ સમજાવો. Insertion સૉર્ટનો ઉપયોગ કરીને નીચેના નંબરોનો ટ્રેસ આપો: 25, 15,30,9,99,20,26

ઉત્તર:

Insertion Sort: એક સમયે એક એલિમેન્ટ દ્વારા સૉર્ટેડ array બનાવે છે દરેક એલિમેન્ટને તેની યોગ્ય પોઝિશનમાં insert કરીને.

અલ્ગોરિધમ કન્સેપ્ટ:

• સૉર્ટેડ ભાગ: વર્તમાન એલિમેન્ટની ડાબી બાજુ
• અનસૉર્ટેડ ભાગ: વર્તમાન એલિમેન્ટની જમણી બાજુ
• Insert સ્ટ્રેટેજી: વર્તમાન એલિમેન્ટને સૉર્ટેડ ભાગમાં યોગ્ય સ્થાને મૂકો

[25, 15, 30, 9, 99, 20, 26] નો ટ્રેસ:

અંતિમ સૉર્ટેડ Array: [9, 15, 20, 25, 26, 30, 99]

Time Complexity: O(n²) worst case, O(n) best case

મેમરી ટ્રીક: “Insertion વધતા ક્રમમાં Insert કરે છે”

પ્રશ્ન 5(a) [3 ગુણ]

#

બાઈનરી ટ્રીની એપ્લિકેશન સમજાવો.

ઉત્તર:

Binary Tree એપ્લિકેશન્સ:

મુખ્ય ફાયદાઓ:

• હાયરાર્કિકલ સ્ટ્રક્ચર: કુદરતી tree ઓર્ગેનાઇઝેશન
• કાર્યક્ષમ ઓપરેશન્સ: Search, insert, delete
• Recursive Processing: અમલ કરવામાં સરળ

મેમરી ટ્રીક: “Binary Trees અનેક એપ્લિકેશન્સમાં શાખા કરે છે”

પ્રશ્ન 5(b) [4 ગુણ]

#

લિસ્ટનો ઉપયોગ કરીને Binary search માટેનો અલ્ગોરિધમ લખો.

ઉત્તર:

Binary Search અલ્ગોરિધમ:

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    
    while left <= right:
        mid = (left + right) // 2
        
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    
    return -1  # એલિમેન્ટ મળ્યું નથી

અલ્ગોરિધમ પગલાં:

પૂર્વશરત: Array સૉર્ટેડ હોવું જોઈએ Time Complexity: O(log n)

મેમરી ટ્રીક: “Binary Search ઝડપથી શોધવા માટે બાઇસેક્ટ કરે છે”

પ્રશ્ન 5(c) [7 ગુણ]

#

Tree ની વ્યાખ્યા આપો. Tree ની યાદી બનાવો. પાયથોનનો ઉપયોગ કરીને બાઈનરી સર્ચ ટ્રીમાં નોડ દાખલ કરવા માટે અલ્ગોરિધમ લખો.

ઉત્તર:

Tree વ્યાખ્યા: એક હાયરાર્કિકલ ડેટા સ્ટ્રક્ચર જેમાં edges દ્વારા જોડાયેલા nodes હોય છે, એક root node સાથે અને કોઈ cycles ન હોય.

Tree ના પ્રકારો:

BST Insertion અલ્ગોરિધમ:

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

def insert_bst(root, data):
    if root is None:
        return TreeNode(data)
    
    if data < root.data:
        root.left = insert_bst(root.left, data)
    elif data > root.data:
        root.right = insert_bst(root.right, data)
    
    return root

અલ્ગોરિધમ પગલાં:

1. જો tree ખાલી છે, root node બનાવો
2. જો data < root.data, ડાબા subtree માં insert કરો
3. જો data > root.data, જમણા subtree માં insert કરો
4. જો data = root.data, ignore કરો (duplicates નથી)
5. અપડેટેડ root પરત કરો

મેમરી ટ્રીક: “Trees સંરચિત ઓર્ગેનાઇઝેશન સાથે વધે છે”

પ્રશ્ન 5(a) અથવા [3 ગુણ]

#

ટ્રીના ઇન-ઓર્ડર ટ્રાવર્સલનો અલ્ગોરિધમ લખો.

ઉત્તર:

In-order Traversal અલ્ગોરિધમ:

def inorder_traversal(root):
    if root is not None:
        inorder_traversal(root.left)    # ડાબું
        print(root.data)                # Root
        inorder_traversal(root.right)   # જમણું

અલ્ગોરિધમ પગલાં:

Traversal ક્રમ: ડાબું → Root → જમણું

ગુણધર્મો:

• BST ગુણધર્મ: In-order સૉર્ટેડ sequence આપે છે
• Time Complexity: O(n)
• Space Complexity: O(h) જ્યાં h એ height છે

ઉદાહરણ Tree પરિણામ:

મેમરી ટ્રીક: “In-order: ડાબું, Root, જમણું”

પ્રશ્ન 5(b) અથવા [4 ગુણ]

#

Search ની વ્યાખ્યા આપો? લિસ્ટનો ઉપયોગ કરીને Linear search માટેનો અલ્ગોરિધમ લખો.

ઉત્તર:

Search વ્યાખ્યા: ડેટા સ્ટ્રક્ચરમાં ચોક્કસ એલિમેન્ટ શોધવાની અથવા એલિમેન્ટ અસ્તિત્વમાં છે કે નહીં તે ચકાસવાની પ્રક્રિયા.

Linear Search અલ્ગોરિધમ:

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i  # મળ્યું તો index પરત કરો
    return -1  # ન મળ્યું તો -1 પરત કરો

અલ્ગોરિધમ લક્ષણો:

અલ્ગોરિધમ પગલાં:

1. પ્રથમ એલિમેન્ટથી શરૂ કરો
2. દરેક એલિમેન્ટને target સાથે સરખાવો
3. જો મેચ મળે, index પરત કરો
4. જો અંત પહોંચે, -1 પરત કરો

મેમરી ટ્રીક: “Linear Search રેખીય રીતે લિસ્ટ્સમાં જુએ છે”

પ્રશ્ન 5(c) અથવા [7 ગુણ]

#

વ્યાખ્યા આપો: a) પાથ b). લીફ નોડ. નીચે આપેલ માહિતી ઉપરથી binary search tree બનાવો. 60, 40, 37,31,59,21,65,30

ઉત્તર:

વ્યાખ્યાઓ:

BST બનાવટ માટે: 60, 40, 37, 31, 59, 21, 65, 30

પગલાં પ્રમાણે બનાવટ:

અંતિમ BST સ્ટ્રક્ચર:

Leaf Nodes: 30, 59, 65

મેમરી ટ્રીક: “BST બિલ્ડિંગ Binary Search Tree નિયમોને અનુસરે છે”