તમે સમસ્યા માટે સાચી ડેટા સ્ટ્રક્ચર કેવી રીતે પસંદ કરશો?

Question

Accepted Answer

જે સ્ટ્રક્ચર તમારા એક્સેસ પેટર્ન માટે **સૌથી વધુ વારંવાર ક્રિયાઓ સૌથી સસ્તી હોય** તે પસંદ કરો. તમે જે ક્રિયાઓ કરશો તે સૂચિબદ્ધ કરીને શરૂ કરો, તેમની આવર્તન નક્કી કરો, પછી તેને સ્ટ્રક્ચરની શક્તિઓ સાથે મેળવો.

## નિર્ણય તપાસી સૂચિ

```text
1. How do you access data?  by index -> array
                            by key   -> hash map
                            by order -> tree / heap
2. Need ordering?           sorted   -> balanced BST / sorted array
                            FIFO     -> queue
                            LIFO     -> stack
3. Frequent middle inserts? -> linked list
4. Need fast "seen it?"     -> set / hash map
5. Need "best/min/max next" -> heap (priority queue)
```

## કામગીરી જટિલતા સાથે મેળવો

| જરૂર | સર્વોત્તમ સ્ટ્રક્ચર | મુખ્ય ક્રિયા ખર્ચ |
|---|---|---|
| ઇન્ડેક્સ દ્વારા રેન્ડમ એક્સેસ | dynamic array | O(1) |
| કી દ્વારા શોધ | hash map | O(1) avg |
| સૉર્ટ કરેલ + શ્રેણી પ્રશ્નો | balanced BST | O(log n) |
| ન્યૂનતમ/મહત્તમ વારંવાર | heap | O(log n) pop |
| FIFO / LIFO | queue / stack | O(1) |
| ઉપસર્ગ શોધ | trie | O(L) |

## ઉદાહરણ તર્ક

```text
"Find the 10 most frequent words in a huge file."
 - count frequencies  -> hash map (O(1) updates)
 - keep top 10        -> min-heap of size 10 (O(log 10) per word)
```

## તે શા માટે મહત્વપૂર્ણ છે

સાચું પસંદ કરવું ઘણીવાર O(n) અને O(n²) સમાધાન વચ્ચેનો તફાવત છે — કામગીરી પર સૌથી મોટો એક લિવર.

ઇન્ટરવ્યુકર્તા બરાબર આ તર્કનું પરીક્ષણ કરે છે: તેઓ તમને જરૂરિયાતોને ક્રિયા ખર્ચ સાથે મેળવતા જોવા માંગે છે, સ્ટ્રક્ચર્સ યાદ નહીં કરવા.

જરૂર	સર્વોત્તમ સ્ટ્રક્ચર	મુખ્ય ક્રિયા ખર્ચ
ઇન્ડેક્સ દ્વારા રેન્ડમ એક્સેસ	dynamic array	O(1)
કી દ્વારા શોધ	hash map	O(1) avg
સૉર્ટ કરેલ + શ્રેણી પ્રશ્નો	balanced BST	O(log n)
ન્યૂનતમ/મહત્તમ વારંવાર	heap	O(log n) pop
FIFO / LIFO	queue / stack	O(1)
ઉપસર્ગ શોધ	trie	O(L)