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

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

લીનીઅર અને નોન લીનીઅર ડેટા સ્ટ્રક્ચર નો તફાવત લખો.

જવાબ:

મેમરી ટ્રીક: "લીનીઅર પાણીની જેમ વહે, નોન-લીનીઅર નેટવર્ક જેવું નેવિગેટ કરે"

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

Object Oriented programming ના વિવિધ concepts સમજાવો.

જવાબ:

OOP કોન્સેપ્ટ્સ કોષ્ટક:

• Encapsulation: ડેટા હાઇડિંગ અને બન્ડલિંગ
• Inheritance: પેરેન્ટ-ચાઇલ્ડ સંબંધ દ્વારા કોડ પુનઃઉપયોગ
• Polymorphism: મેથડ ઓવરરાઇડિંગ અને ઓવરલોડિંગ
• Abstraction: ઇમ્પ્લિમેન્ટેશન વગરનું ઇન્ટરફેસ

મેમરી ટ્રીક: "દરેક હોશિયાર પ્રોગ્રામર Abstracts કરે છે"

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

Polymorphism ની વ્યાખ્યા આપો. Inheritance વડે Polymorphism નો python program લખો.

જવાબ:

Polymorphism એટલે "અનેક સ્વરૂપો" - એજ મેથડ નામ અલગ અલગ ક્લાસોમાં અલગ વર્તન દર્શાવે.

કોડ:

Python

• Polymorphism: સેમ ઇન્ટરફેસ, અલગ ઇમ્પ્લિમેન્ટેશન
• Runtime binding: ઑબ્જેક્ટ ટાઇપ પર આધારિત મેથડ કૉલ
• કોડ લવચીકતા: નવી ક્લાસો સાથે સરળતાથી વિસ્તાર

મેમરી ટ્રીક: "Polymorphism પરફેક્ટ પ્રોગ્રામિંગ પ્રદાન કરે"

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

Abstraction ની વ્યાખ્યા આપો. Abstract class નો concept સમજવા માટેનો python program લખો.

જવાબ:

Abstraction ઇમ્પ્લિમેન્ટેશન વિગતો છુપાવે છે અને ફક્ત જરૂરી ફીચર્સ બતાવે છે.

કોડ:

Python

• Abstract class: સીધી રીતે instantiate કરી શકાતી નથી
• Abstract method: ચાઇલ્ડ ક્લાસોમાં ઇમ્પ્લિમેન્ટ કરવું આવશ્યક
• ઇન્ટરફેસ ડેફિનિશન: સબક્લાસ માટે ટેમ્પ્લેટ પ્રદાન કરે

મેમરી ટ્રીક: "Abstraction વાસ્તવિક ઇમ્પ્લિમેન્ટેશન ટાળે"

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

નીચેની વ્યાખ્યા આપો: I. Best case II. Worst case III. Average case

જવાબ:

મેમરી ટ્રીક: "Best-Worst-Average = પરફોર્મન્સ એનાલિસિસ"

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

Infix, postfix અને prefix એક્સપ્રેશન સમજાવો.

જવાબ:

• Infix: પ્રાકૃતિક ગાણિતિક સંકેત
• Prefix: Polish notation
• Postfix: Reverse Polish notation
• Stack ઉપયોગ: Postfix કૌંસ દૂર કરે છે

મેમરી ટ્રીક: "In-Pre-Post = ઑપરેટરની સ્થિતિ"

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

Circular queue ની વ્યાખ્યા આપો. Circular queue ના INSERT અને DELETE operations આકૃતિ સાથે સમજાવો.

જવાબ:

Circular Queue: લીનીઅર ડેટા સ્ટ્રક્ચર જેમાં છેલ્લી સ્થિતિ પ્રથમ સ્થિતિ સાથે જોડાય છે.

આકૃતિ:

goat

INSERT ઑપરેશન:

1. ચકાસો કે queue ભરાઈ ગઈ છે કે નહીં
2. જો ભરાઈ નથી, rear વધારો
3. જો rear size કરતાં વધે, rear = 0 કરો
4. rear પોઝિશને એલિમેન્ટ insert કરો

DELETE ઑપરેશન:

1. ચકાસો કે queue ખાલી છે કે નહીં
2. જો ખાલી નથી, front માંથી એલિમેન્ટ કાઢો
3. front વધારો
4. જો front size કરતાં વધે, front = 0 કરો

• ગોળ પ્રકૃતિ: કાર્યક્ષમ મેમરી ઉપયોગ
• કોઈ શિફ્ટિંગ નહીં: એલિમેન્ટ્સ જગ્યામાં રહે
• Front-rear pointers: queue બાઉન્ડરીઝ ટ્રેક કરે

મેમરી ટ્રીક: "Circular સ્પેસ બચાવે છે"

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

ઉદાહરણ સાથે વિવિધ Data Structure જણાવો.

જવાબ:

મેમરી ટ્રીક: "Arrays-Stacks-Queues = લીનીઅર, Trees-Graphs = નોન-લીનીઅર"

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

Circular queue એ simple queue કરતાં કેવી રીતે અલગ છે તે જણાવો.

જવાબ:

• મેમરી કાર્યક્ષમતા: Circular ડિલીટ કરેલી જગ્યાઓ ફરી વાપરે
• Pointer મેનેજમેન્ટ: Wraparound માટે મોડ્યુલો અંકગણિત
• પરફોર્મન્સ: બહેતર સ્પેસ ઉપયોગ

મેમરી ટ્રીક: "Circular મેમરી સમસ્યાઓ જીતે છે"

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

Stack ની વ્યાખ્યા આપો. PUSH અને POP operation ઉદાહરણ સાથે સમજાવો. Stack ના PUSH અને POP operation ના algorithm લખો.

જવાબ:

Stack: LIFO (Last In First Out) ડેટા સ્ટ્રક્ચર.

PUSH Algorithm:

1. ચકાસો કે stack ભરાઈ ગઈ છે કે નહીં
2. જો ભરાઈ નથી, top વધારો
3. top પોઝિશને એલિમેન્ટ insert કરો
4. top pointer અપડેટ કરો

POP Algorithm:

1. ચકાસો કે stack ખાલી છે કે નહીં
2. જો ખાલી નથી, top એલિમેન્ટ સ્ટોર કરો
3. top pointer ઘટાડો
4. સ્ટોર કરેલું એલિમેન્ટ return કરો

ઉદાહરણ:

Stack: [10, 20, 30] ← top
PUSH 40: [10, 20, 30, 40] ← top
POP: returns 40, stack: [10, 20, 30] ← top

• LIFO સિદ્ધાંત: છેલ્લું ઉમેરેલું એલિમેન્ટ પ્રથમ કાઢવામાં આવે
• Top pointer: વર્તમાન stack પોઝિશન ટ્રેક કરે
• Overflow/Underflow: ઑપરેશન પહેલાં ચકાસણી

મેમરી ટ્રીક: "Stack છેલ્લા-અંદર-પ્રથમ-બહાર સ્ટોર કરે"

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

નીચે આપેલા infix expression ને postfix માં ફેરવો: ( ( ( A - B ) * C ) + ( ( D - E ) / F ) )

જવાબ:

પગલાબદ્ધ રૂપાંતર:

અંતિમ જવાબ: AB-C*DE-F/+

મેમરી ટ્રીક: "Postfix ઑપરેટર્સ ઑપરેન્ડ્સ પછી મૂકે"

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

Doubly linked list વિશે ટૂંકનોંધ લખો.

જવાબ:

Doubly Linked List: દ્વિદિશીય લિંક્સ સાથેની લીનીઅર ડેટા સ્ટ્રક્ચર.

સ્ટ્રક્ચર:

goat

ફાયદાઓ:

• દ્વિદિશીય traversal: આગળ અને પાછળ navigation
• કાર્યક્ષમ deletion: પાછલા node ના reference ની જરૂર નહીં
• બહેતર insertion: આપેલા node પહેલાં સરળતાથી insert કરી શકાય

ગેરફાયદાઓ:

• વધારાની મેમરી: વધારાના pointer storage
• જટિલ operations: વધુ pointer manipulations

મેમરી ટ્રીક: "Doubly દ્વિદિશીય ફાયદાઓ આપે"

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

Singly linked list માં પ્રથમ અને અંતિમ node કાઢવા માટેનો Python Program લખો.

જવાબ:

કોડ:

Python

• પ્રથમ ડિલીટ: head pointer અપડેટ કરો
• છેલ્લું ડિલીટ: બીજા છેલ્લા node સુધી traverse કરો
• Edge cases: ખાલી list અને સિંગલ node

મેમરી ટ્રીક: "Delete pointer અપડેટ દ્વારા આપે"

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

Queue ની વિવિધ એપ્લિકેશન જણાવો.

જવાબ:

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

• FIFO પ્રકૃતિ: પ્રથમ આવ્યો પ્રથમ સેવા
• Real-time systems: ઓર્ડરમાં requests handle કરે
• Resource sharing: વાજબી ફાળવણી

મેમરી ટ્રીક: "Queues ક્રમબદ્ધ operations શાંતિથી handle કરે"

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

Singly linked list પર આપણે કરી શકીએ તેવા વિવિધ ઑપરેશન્સ સમજાવો.

જવાબ:

Singly Linked List ઑપરેશન્સ:

• ડાયનામિક સાઇઝ: runtime દરમિયાન વધે/ઘટે
• મેમરી કાર્યક્ષમતા: જરૂર મુજબ allocate કરે
• Sequential access: કોઈ random access નથી

મેમરી ટ્રીક: "Insert-Delete-Traverse-Search-Count"

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

Doubly linked list માં અંતે નવી node insert કરવા માટેનો algorithm લખો.

જવાબ:

અંતે insertion માટે Algorithm:

1. આપેલા ડેટા સાથે નવું node બનાવો
2. નવા node નું next = NULL કરો
3. જો list ખાલી છે:
   - head = નવું node કરો
   - નવા node નું prev = NULL કરો
4. નહીં તો:
   - છેલ્લા node સુધી traverse કરો
   - છેલ્લા node નું next = નવું node કરો
   - નવા node નું prev = છેલ્લું node કરો
5. success return કરો

કોડ:

Python

• દ્વિદિશીય લિંકિંગ: next અને prev બંને pointers અપડેટ કરો
• અંત insertion: છેલ્લું node શોધવા traverse કરો
• દ્વિદિશીય કનેક્શન: list integrity જાળવો

મેમરી ટ્રીક: "દ્વિદિશીય લિંક્સ સાથે હોશિયારીથી Insert કરો"

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

Linear search માટેનો Python Program લખો.

જવાબ:

કોડ:

Python

• Sequential search: દરેક element એક પછી એક ચકાસો
• Time complexity: O(n)
• સાદું implementation: સમજવામાં આસાન

મેમરી ટ્રીક: "Linear દરેક element દ્વારા જુએ છે"

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

Circular linked list વિશે ટૂંકનોંધ લખો.

જવાબ:

Circular Linked List: છેલ્લું node પ્રથમ node તરફ પાછું point કરે છે અને ગોળ બનાવે છે.

આકૃતિ:

goat

લક્ષણો:

• કોઈ NULL pointers નથી: છેલ્લું node પ્રથમ સાથે જોડાય
• સતત traversal: અનંત traversal શક્ય
• મેમરી કાર્યક્ષમતા: બહેતર cache performance
• એપ્લિકેશન્સ: Round-robin scheduling, multiplayer games

ફાયદાઓ:

• કાર્યક્ષમ insertion: કોઈપણ પોઝિશને
• કોઈ બગડેલા pointers નથી: બધા nodes જોડાયેલા

મેમરી ટ્રીક: "Circular બધું loop માં જોડે છે"

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

Quick sort algorithm ઉદાહરણ સાથે સમજાવો.

જવાબ:

Quick Sort: Pivot element વાપરીને divide અને conquer sorting algorithm.

Algorithm:

1. Pivot element પસંદ કરો
2. Pivot આસપાસ array partition કરો
3. બાઈ subarray ને recursively sort કરો
4. જમણી subarray ને recursively sort કરો

ઉદાહરણ: [64, 34, 25, 12, 22, 11, 90] સોર્ટ કરો

પગલું 1: Pivot = 64

[34, 25, 12, 22, 11] 64 [90]

પગલું 2: બાઈ partition [34, 25, 12, 22, 11] સોર્ટ કરો Pivot = 34

[25, 12, 22, 11] 34 []

અંતિમ sorted: [11, 12, 22, 25, 34, 64, 90]

• Divide અને conquer: સમસ્યાને નાના ભાગોમાં વહેંચો
• In-place sorting: ન્યૂનતમ વધારાની મેમરી
• Average complexity: O(n log n)

મેમરી ટ્રીક: "Quick Partitions પછી જીતે છે"

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

Binary search algorithm ઉદાહરણ સાથે સમજાવો.

જવાબ:

Binary Search: Divide અને conquer વાપરીને sorted arrays માટે search algorithm.

Algorithm:

1. left = 0, right = array length - 1 સેટ કરો
2. જ્યાં સુધી left <= right:
   - mid = (left + right) / 2 calculate કરો
   - જો target = array[mid], mid return કરો
   - જો target < array[mid], right = mid - 1
   - જો target > array[mid], left = mid + 1
3. ન મળે તો -1 return કરો

ઉદાહરણ: [11, 12, 22, 25, 34, 64, 90] માં 22 શોધો

મેમરી ટ્રીક: "Binary ઝડપથી શોધવા બે ભાગ કરે છે"

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

Linked list ની વિવિધ એપ્લિકેશન જણાવો.

જવાબ:

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

• ડાયનામિક મેમરી: જરૂર મુજબ allocate કરો
• કાર્યક્ષમ insertion/deletion: કોઈ shifting જરૂરી નથી
• લવચીક structure: બદલાતી જરૂરિયાતોને અનુકૂળ

મેમરી ટ્રીક: "Linked Lists ડાયનામિક એપ્લિકેશન્સમાં રહે છે"

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

ઉદાહરણ સાથે Insertion sort માટેનો python program લખો.

જવાબ:

કોડ:

Python

પગલાબદ્ધ ઉદાહરણ:

Initial: [64, 34, 25, 12, 22, 11, 90]
Pass 1:  [34, 64, 25, 12, 22, 11, 90]
Pass 2:  [25, 34, 64, 12, 22, 11, 90]
Pass 3:  [12, 25, 34, 64, 22, 11, 90]
Pass 4:  [12, 22, 25, 34, 64, 11, 90]
Pass 5:  [11, 12, 22, 25, 34, 64, 90]
Pass 6:  [11, 12, 22, 25, 34, 64, 90]

• કાર્ડ sorting analogy: playing cards ગોઠવવા જેવું
• Stable sort: સમાન elements નો relative order જાળવે
• Online algorithm: ડેટા મળતા જ list sort કરી શકે

મેમરી ટ્રીક: "Insertion યોગ્ય જગ્યામાં Insert કરે છે"

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

નીચેની વ્યાખ્યા આપો: I. Complete Binary tree II. In-degree III. Out-degree.

જવાબ:

મેમરી ટ્રીક: "Complete-In-Out = Tree terminology"

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

Bubble sort algorithm ઉદાહરણ સાથે સમજાવો.

જવાબ:

Bubble Sort: અડીખમ elements ની તુલના કરો અને ખોટા ક્રમમાં હોય તો swap કરો.

Algorithm:

1. દરેક pass માટે (0 થી n-1):
   2. દરેક element માટે (0 થી n-pass-1):
      3. જો arr[j] > arr[j+1]:
         4. arr[j] અને arr[j+1] swap કરો

ઉદાહરણ: [64, 34, 25, 12]

• Bubble up: સૌથી મોટું element અંતે bubble થાય
• Multiple passes: દરેક pass એક element સાચી જગ્યામાં મૂકે
• સાદું implementation: સમજવામાં આસાન

મેમરી ટ્રીક: "Bubble સૌથી મોટાને પાછળ લાવે છે"

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

આપેલી સંખ્યાઓ માટે Binary Search Tree બનાવો તથા તેના Preorder, Inorder અને Postorder traversals લખો: 15, 35, 12, 48, 5, 25, 58, 8

જવાબ:

BST Construction:

goat

Traversal Sequences:

Traversal નિયમો:

• Preorder: Root → Left → Right
• Inorder: Left → Root → Right (sorted order આપે)
• Postorder: Left → Right → Root

મેમરી ટ્રીક: "Pre-In-Post = Root ની સ્થિતિ"

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

Binary tree ની વ્યાખ્યા આપો. Binary tree માં node searching વિશે સમજાવો.

જવાબ:

Binary Tree: Hierarchical ડેટા structure જેમાં દરેક node ને મહત્તમ બે children હોય.

Search Algorithm:

1. Root થી શરુઆત કરો
2. જો target = current node, found return કરો
3. જો target < current node, ડાબે જાઓ
4. જો target > current node, જમણે જાઓ
5. મળે કે NULL સુધી પહોંચે ત્યાં સુધી repeat કરો

• Hierarchical structure: Parent-child સંબંધ
• Binary property: node દીઠ મહત્તમ બે children
• Search કાર્યક્ષમતા: Balanced trees માટે O(log n)

મેમરી ટ્રીક: "Binary બે પાથમાં branch કરે છે"

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

આપેલા ડેટા ને bubble sort ની મદદથી ચડતા ક્રમમાં ગોઠવી બતાવો. ડેટા: 44, 72, 94, 28, 18, 442, 41

જવાબ:

Bubble Sort Trace:

અંતિમ sorted array: [18, 28, 41, 44, 72, 94, 442]

મેમરી ટ્રીક: "Bubble sort દરેક pass સૌથી મોટાને અંતે bubbles કરે"

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

Trees ની વિવિધ એપ્લિકેશન જણાવો. General tree ને Binary Search Tree માં રૂપાંતર કરવા માટેની technique ઉદાહરણ સાથે સમજાવો.

જવાબ:

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

General Tree થી BST રૂપાંતર:

Technique: First Child - Next Sibling Representation

મૂળ General Tree:

    A
   /|\
  B C D
 /| |
E F G

Binary Tree માં રૂપાંતર:

goat

પગલાં:

1. First child: Binary tree માં left child બને
2. Next sibling: Binary tree માં right child બને
3. Recursive application: બધા nodes પર લાગુ કરો

• વ્યવસ્થિત રૂપાંતર: Tree structure જાળવે
• Binary representation: node દીઠ ફક્ત બે pointers વાપરે
• Space કાર્યક્ષમતા: મानક binary tree operations લાગુ પડે

મેમરી ટ્રીક: "First-child ડાબે, Next-sibling જમણે"