मैंने इस शब्द को "ओ (1) एक्सेस टाइम" जल्दी "मतलब" देखा है, लेकिन मुझे समझ में नहीं आया कि इसका क्या मतलब है। दूसरे शब्द जो मैं उसी संदर्भ में इसके साथ देख रहा हूं वह है "O (n) एक्सेस टाइम"। क्या कोई सरल तरीके से समझा सकता है कि इन शब्दों का क्या मतलब है?
यह सभी देखें
जवाबों:
आप जटिलता के आदेश पर पढ़ना चाहते हैं।
http://en.wikipedia.org/wiki/Big_O_notation
संक्षेप में, O (1) का अर्थ है कि यह लगातार समय लेता है, जैसे 14 नैनोसेकंड, या तीन मिनट सेट में डेटा की मात्रा से कोई फर्क नहीं पड़ता।
O (n) का मतलब है कि सेट के आकार के साथ रैखिक समय लगता है, इसलिए एक सेट दो बार आकार को दोगुना समय लगेगा। आप शायद इनमें से किसी एक में एक लाख ऑब्जेक्ट नहीं डालना चाहते हैं।
int main() { int n; cin >> n; if(n == 0) { sleep(60 * 60 * 24 * 365); } cout << n; }है O(1)।
संक्षेप में, इसका मतलब है कि आपके संग्रह में एक मूल्य देखने के लिए उतना ही समय लगता है कि क्या आपके संग्रह में बहुत कम आइटम हैं या बहुत बहुत (आपके हार्डवेयर की कमी के भीतर)
O (n) का अर्थ होगा कि किसी वस्तु को देखने में लगने वाला समय संग्रह में वस्तुओं की संख्या के समानुपाती होता है।
इनमें से विशिष्ट उदाहरण सरणियाँ हैं, जिन्हें सीधे उनके आकार और संबद्ध सूचियों की परवाह किए बिना पहुँचा जा सकता है, जिन्हें किसी दिए गए आइटम तक पहुँचने के लिए शुरुआत से ही ट्रैवर्स किया जाना चाहिए।
आमतौर पर चर्चा किए गए अन्य ऑपरेशन सम्मिलित हैं। एक संग्रह पहुंच के लिए ओ (1) हो सकता है लेकिन डालने के लिए ओ (एन)। वास्तव में एक सरणी में वास्तव में यह व्यवहार होता है, क्योंकि बीच में एक आइटम सम्मिलित करने के लिए, आपको प्रत्येक आइटम को दाईं ओर निम्नलिखित स्लॉट में कॉपी करके स्थानांतरित करना होगा।
वर्तमान में इस प्रश्न का उत्तर देने वाला प्रत्येक उत्तर आपको बताता है कि O(1)निरंतर समय (जो कुछ भी मापने के लिए होता है; रनटाइम हो सकता है, संचालन की संख्या, आदि)। यह सही नहीं है।
यह कहने के लिए कि रनटाइम का O(1)मतलब है कि एक स्थिरांक cऐसा है कि रनटाइम cइनपुट से स्वतंत्र होकर ऊपर से घिरा हुआ है । उदाहरण के लिए, nपूर्णांकों की एक सरणी का पहला तत्व लौटाना है O(1):
int firstElement(int *a, int n) {
return a[0];
}
लेकिन यह समारोह O(1)भी है:
int identity(int i) {
if(i == 0) {
sleep(60 * 60 * 24 * 365);
}
return i;
}
यहां रनटाइम 1 वर्ष से ऊपर है, लेकिन अधिकांश समय रनोस नैनोसेकंड के क्रम पर होता है।
यह कहने के लिए कि रनटाइम का O(n)मतलब है कि एक स्थिरांक cऐसा है कि रनटाइम ऊपर से घिरा हुआ है c * n, जहां nइनपुट के आकार को मापता है। उदाहरण के लिए, nनिम्नलिखित एल्गोरिथ्म द्वारा पूर्णांक के एक असंक्रमित सरणी में किसी विशेष पूर्णांक की घटनाओं की संख्या का पता लगाना है O(n):
int count(int *a, int n, int item) {
int c = 0;
for(int i = 0; i < n; i++) {
if(a[i] == item) c++;
}
return c;
}
ऐसा इसलिए है क्योंकि हमें सरणी के माध्यम से प्रत्येक तत्व को एक बार में निरीक्षण करना होगा।
ओ (1) का अर्थ "जल्दी" नहीं है। इसका मतलब यह है कि समय लगता है स्थिर है, और फ़ंक्शन के लिए इनपुट के आकार पर आधारित नहीं है। लगातार तेज या धीमा हो सकता है। O (n) का अर्थ है कि फ़ंक्शन द्वारा लिया जाने वाला समय n द्वारा निरूपित फ़ंक्शन के इनपुट के आकार के प्रत्यक्ष अनुपात में बदल जाएगा। फिर से, यह तेज या धीमा हो सकता है, लेकिन यह n के आकार में वृद्धि के साथ धीमा हो जाएगा।
इसे बिग ओ नोटेशन कहा जाता है , और विभिन्न एल्गोरिदम के लिए खोज समय का वर्णन करता है।
O (1) का मतलब है कि सबसे खराब स्थिति रन टाइम है। अधिकांश स्थिति के लिए इसका मतलब है कि आपको संग्रह की खोज करने की आवश्यकता नहीं है, आप वह खोज सकते हैं जो आप अभी खोज रहे हैं।
O(1)हमेशा डाटासेट n की परवाह किए बिना एक ही समय में निष्पादित करें। O (1) का एक उदाहरण एक ऐरेलेस्ट होगा जो अपने तत्व को इंडेक्स के साथ एक्सेस करेगा।
O(n)रैखिक ऑर्डर के रूप में भी जाना जाता है, प्रदर्शन रैखिक रूप से और इनपुट डेटा के आकार के प्रत्यक्ष अनुपात में बढ़ेगा। O (n) का एक उदाहरण यादृच्छिक स्थिति में एक ArrayList प्रविष्टि और विलोपन होगा। यादृच्छिक स्थिति में प्रत्येक बाद के सम्मिलन / विलोपन के कारण ArrayList में तत्वों को इसके आंतरिक सरणी के बायीं ओर शिफ्ट करने का कारण होगा ताकि इसकी रैखिक संरचना को बनाए रखा जा सके, नए सरणियों के निर्माण और पुराने से तत्वों की नकल के बारे में उल्लेख नहीं किया जा सके। नए सरणी के लिए जो महंगा प्रसंस्करण समय लेता है, इसलिए प्रदर्शन को रोक देता है।
असल में, हे (1) का मतलब है अपनी गणना समय स्थिर है, जबकि हे (एन) का अर्थ है यह निर्भर करेगा lineally इनपुट के आकार पर - बस पाशन - - क्योंकि यह संख्या पर निर्भर करता एक सरणी के माध्यम से पाशन यानी हे (एन) है वस्तुओं की संख्या, साधारण संख्याओं के बीच अधिकतम गणना करते समय O (1) है।
विकिपीडिया भी मदद कर सकता है: http://en.wikipedia.org/wiki/Computational_complexity_theory
O (1) और O (n) को अलग करने का सबसे आसान तरीका है सरणी और सूची की तुलना करना।
सरणी के लिए, यदि आपके पास सही सूचकांक मूल्य है, तो आप डेटा को तुरंत एक्सेस कर सकते हैं। (यदि आप सूचकांक नहीं जानते हैं और सरणी के माध्यम से लूप करना है, तो यह अब O (1) नहीं होगा)
सूची के लिए, आपको हमेशा इसके माध्यम से लूप करने की आवश्यकता है, चाहे आप सूचकांक को जानते हों या नहीं।
यहाँ एक सरल सादृश्य है; कल्पना करें कि आप O (1) के साथ ऑनलाइन फ़िल्में डाउनलोड कर रहे हैं, अगर किसी एक फ़िल्म को डाउनलोड करने में 5 मिनट लगते हैं, तो भी 20 फ़िल्में डाउनलोड करने में एक ही समय लगेगा। इससे कोई फर्क नहीं पड़ता कि आप कितनी फिल्में डाउनलोड कर रहे हैं, वे एक ही समय (5 मिनट) लेंगे चाहे वह एक या 20 फिल्में हों। इस सादृश्य का एक सामान्य उदाहरण है जब आप किसी मूवी लाइब्रेरी में जाते हैं, चाहे आप एक फिल्म ले रहे हों या 5, आप बस एक बार उन्हें चुनेंगे। इसलिए एक ही समय बिताना।
हालाँकि, O (n) के साथ, अगर एक मूवी को डाउनलोड करने में 5 मिनट लगते हैं, तो 10 मूवी डाउनलोड करने में लगभग 50 मिनट लगेंगे। इसलिए समय स्थिर नहीं है या आप जितनी फिल्में डाउनलोड कर रहे हैं, उतनी आनुपातिक नहीं है।
इसका मतलब है कि पहुंच का समय स्थिर है। चाहे आप 100 या 100,000 रिकॉर्ड से पहुंच रहे हों, पुनर्प्राप्ति समय समान होगा।
इसके विपरीत, O (n) एक्सेस समय यह दर्शाता है कि पुनर्प्राप्ति समय आपके द्वारा रिकॉर्ड किए जा रहे रिकॉर्ड की संख्या के लिए सीधे आनुपातिक है।
इसका अर्थ है कि पहुंच में निरंतर समय लगता है यानी डेटासेट के आकार पर निर्भर नहीं करता है। O (n) का अर्थ है कि पहुंच डेटा के आकार पर रैखिक रूप से निर्भर करेगा।
O को बड़ा-O के नाम से भी जाना जाता है।
एल्गोरिदम का परिचय: Cormen, Leiserson, Rivest & Stein द्वारा दूसरा संस्करण पेज 44 पर कहा गया है
चूँकि कोई भी स्थिरांक एक डिग्री -0 बहुपद है, हम किसी भी स्थिर फ़ंक्शन को थीटा (n ^ 0), या थीटा (1) के रूप में व्यक्त कर सकते हैं। यह बाद का अंकन एक छोटी सी गाली है, हालांकि, यह स्पष्ट नहीं है कि चर अनंत के लिए क्या है। हम अक्सर कुछ चर के संबंध में या तो एक स्थिर या स्थिर फ़ंक्शन का अर्थ करने के लिए नोटेशन थीटा (1) का उपयोग करेंगे। ... हम O (g (n)) द्वारा निरूपित करते हैं ... फ़ंक्शन का सेट f (n) ऐसा है कि वहाँ सकारात्मक स्थिरांक c और n0 ऐसे मौजूद हैं कि 0 <= f (n) <= c * g (n) सभी n> = n0 के लिए। ... ध्यान दें कि f (n) = थीटा (g (n)) से तात्पर्य f (n) = O (g (n)) है, क्योंकि थीटा संकेतन O संकेतन से अधिक मजबूत है।
यदि कोई एल्गोरिथ्म O (1) समय में चलता है, तो इसका मतलब है कि asymptotically किसी भी चर पर निर्भर नहीं करता है, जिसका अर्थ है कि कम से कम एक सकारात्मक निरंतर मौजूद है कि जब एक से गुणा किया जाता है तो फ़ंक्शन के स्पर्शोन्मुख जटिलता (~ रनटाइम) से अधिक होता है एक निश्चित राशि से ऊपर एन के मूल्यों के लिए। तकनीकी रूप से, यह O (n ^ 0) समय है।
O (1) का मतलब है रैंडम एक्सेस। किसी भी रैंडम एक्सेस मेमोरी में, किसी भी स्थान पर किसी भी तत्व को एक्सेस करने के लिए लिया गया समय समान होता है। यहां समय किसी भी पूर्णांक का हो सकता है, लेकिन याद रखने वाली एकमात्र चीज तत्व (n-1) वें या nth स्थान पर पुनः प्राप्त करने के लिए लिया गया समय समान (यानी स्थिर) होगा।
जबकि O (n) n के आकार पर निर्भर है।