Big-O વર્ણન કરે છે કે જ્યારે ઇનપુટ સાઈઝ n વધે છે ત્યારે અલ્ગોરિધમના રનિંગ ટાઈમ અથવા મેમોરી કેવી રીતે વધે છે. તે worst-case asymptotic વર્તન ક્લીક કરે છે, સ્થિરાંક અને નીચલા-ક્રમની શરતોને અવગણે છે.
আমરা growth rate ની કાળજી લઈએ છીએ, બરાબર step counts ની નહીં. O(2n + 5) એ સરળતાથી O(n) છે કારણ કે જ્યારે n મોટું થાય છે, સ્થિરાંક અને નાની શરતો મહત્તમ બંધ થાય છે.
વિગતવાર જવાબો સાથે IT ઇન્ટરવ્યૂ પ્રશ્નોની લાઇબ્રેરી — જુનિયરથી સિનિયર સુધી.
દાન કરો| Big-O | નામ | ઉદાહરણ |
|---|
| O(1) | constant | array index lookup |
| O(log n) | logarithmic | binary search |
| O(n) | linear | scanning a list |
| O(n log n) | linearithmic | merge sort |
| O(n²) | quadratic | nested loops |
| O(2ⁿ) | exponential | naive subsets |
def has_duplicate(nums):
for i in range(len(nums)): # outer loop: n
for j in range(i + 1, len(nums)): # inner loop: n
if nums[i] == nums[j]:
return True
return False
# nested loops -> O(n^2) time, O(1) space
Big-O સ્થિરાંકોને છુપાવે છે: એક O(n) અલ્ગોરિધમ મોટા સ્થિરાંક સાથે નાના ઇનપુટમાં O(n log n) ને હારાવી શકે છે. ફક્ત સમય જ નહીં, space complexity પર પણ નજર રાખો.
Big-O તમને અલ્ગોરિધમોની તુલના કરવા દે છે તેમને ચલાવ્યા વિના અથવા હાર્ડવેર વિશે ચિંતા કર્યા વિના.
તે અનુમાન કરે છે કે કઈ સમાધાનો ટકી રહે છે જ્યારે ઇનપુટ સેંકડોથી લાખો સુધી વધે છે — એક feature અને એક વચ્ચેનો તફાવત જે scale થાય છે અને એક જે time out થાય છે.
તે vocabulary છે જે દરેક engineer કામમાં લે છે performance વિશે વિચાર કરવા માટે.