Big-O ஒரு வழிமுறையின் இயங்கு நேரம் அல்லது நினைவகம் உள்ளீட்டு அளவு n ஆக வளரும்போது எவ்வாறு வளரும் என்பதை விவரிக்கிறது. இது மிக மோசமான அறிகுறி நடத்தையைப் பிடிக்கிறது, மாறிலிகளையும் குறைந்த வரிசை சொற்களையும் புறக்கணிக்கிறது.
আমরা வளர்ச்சির வேகத்தை கவனிக்கிறோம், சரியான படி எண்ணிக்கை அல்ல. O(2n + 5) வெறுமனே O(n) ஆகும், ஏனெனில் n வளரும்போது மாறிலிகள் மற்றும் சிறிய சொற்கள் முக்கியத்துவம் இல்லை.
| Big-O | பெயர் | உதாரணம் |
|---|---|---|
| O(1) | மாறிலி | அணி குறியீட்டு தேடல் |
| O(log n) | மடக்கை | பைனரி தேடல் |
| O(n) | கோட்டை | பட்டியல் ஸ்கேனிங் |
| O(n log n) | நேரியல்-மடக்கை | merge sort |
| O(n²) | இருபடி | உள்ளமை வளையங்கள் |
| O(2ⁿ) | அடுக்குவளர்ச்சி | பக்க வணக்கம் துணைக்குழுக்கள் |
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) தோல்வியடையாக முடியும். விண்வளி சிக்கலை கவனிக்கவும், நேரம் மட்டுமல்ல.
Big-O உங்களை வழிமுறைகளை இயங்கவோ அல்லது வன்பொருளை கவலைப்படவோ இல்லாமல் ஒப்பிட்டுப் பார்க்க முடிகிறது.
உள்ளீடுகள் நூறுகளிலிருந்து மில்லியன்களாக வளரும் போது எந்த தீர்வுகள் உயிர்வாழ்கின்றன என்பதை இது கணிக்கிறது — அளவுக்கு சரியாக செயல்படும் அம்சமும் நேரம் முடிந்துவிடும் அம்சமும் இடையே உள்ள வேறுபாடு.
இது ஒவ்வொரு பொறியியலாளரும் செயல்திறன் பற்றி காரணம் கூறுவதற்குப் பயன்படுத்தும் சொற்களஞ்சியமாகும்.