"एन के छोटे मूल्यों के लिए, ओ (एन) को माना जा सकता है जैसे कि यह ओ (1) है"

Question

मैंने कई बार सुना है कि पर्याप्त रूप से छोटे मानों के लिए, O (n) के बारे में सोचा जा सकता है / माना जाता है जैसे कि यह O (1) है।

उदाहरण :

ऐसा करने की प्रेरणा गलत विचार पर आधारित है कि O (1) हमेशा O (lg n) से बेहतर होता है, हमेशा O (n) से बेहतर होता है। यदि किसी परिस्थिति में समस्या का आकार वास्तव में बड़ा हो जाता है, तो किसी ऑपरेशन का स्पर्शोन्मुख क्रम ही प्रासंगिक होता है। अगर n छोटा रहता है तो हर समस्या O (1) है!

पर्याप्त रूप से छोटा क्या है? 10? 100? 1000? आप किस बिंदु पर कहते हैं, "हम इसे मुफ्त ऑपरेशन की तरह नहीं मान सकते हैं"? क्या अंगूठे का एक नियम है?

ऐसा लगता है कि यह डोमेन या केस-विशिष्ट हो सकता है, लेकिन क्या इस बारे में सोचने के बारे में कोई सामान्य नियम हैं?

Comments

अंगूठे का नियम इस बात पर निर्भर करता है कि आप किस समस्या को हल करना चाहते हैं। साथ एम्बेडेड सिस्टम पर तेज रहें ? जटिलता सिद्धांत में प्रकाशित करें? $n \leq 100$

— राफेल

इसके बारे में अधिक सोचने पर, अंगूठे के एक नियम के साथ आना मूल रूप से असंभव लगता है, क्योंकि प्रदर्शन आवश्यकताओं को आपके डोमेन और इसकी व्यावसायिक आवश्यकताओं द्वारा निर्धारित किया जाता है। गैर-संसाधन विवश वातावरण में, n काफी बड़ा हो सकता है। गंभीर रूप से विवश वातावरण में, यह काफी छोटा हो सकता है। अब यह स्पष्ट लगता है।

— rianjs

@rianjs आप मुफ्त में गलत समझ O(1)रहे हैं । पहले कुछ वाक्य के पीछे तर्क यह है कि O(1)है निरंतर , जो कभी कभी पागलपन की हद तक धीमी गति से हो सकता है। एक गणना जिसमें इनपुट की परवाह किए बिना एक हजार अरब वर्ष लगते हैं, एक O(1)गणना है।

— डिंग डक

संबंधित प्रश्न कि हम पहले स्थान पर एसिम्पोटिक्स का उपयोग क्यों करते हैं।

— राफेल

@ एरींज्स: "5 के पर्याप्त बड़े मूल्यों के लिए एक पेंटागन लगभग एक सर्कल है" की तर्ज पर चुटकुलों से अवगत रहें। आप जिस वाक्य के बारे में पूछ रहे हैं वह एक बिंदु बनाता है, लेकिन चूंकि इससे आपको कुछ भ्रम हो गया है, इसलिए एरिक लिपर्ट से यह पूछना आपके लायक हो सकता है कि यह किस प्रकार का वाक्यांशलेखन का सटीक विकल्प हास्य प्रभाव के लिए था। वह कह सकता था, "अगर पर कोई ऊपरी सीमा है तो हर समस्या " और फिर भी गणितीय रूप से सही है। "छोटा" गणित का हिस्सा नहीं है। $n$$O(1)$

— स्टीव जेसोप

Answer 1

परिमाण के सभी आदेशों में एक निरंतर शामिल होता , उनमें से कई वास्तव में होते हैं। जब वस्तुओं की संख्या इतनी बड़ी हो जाती है कि स्थिर अप्रासंगिक हो जाती है। सवाल यह है कि क्या उस स्थिरांक के लिए वस्तुओं की संख्या काफी कम है।$C$

यहाँ इसके बारे में सोचने का एक दृश्य तरीका है।

सभी के पास एक स्टार्टअप स्थिरांक है जो Y अक्ष पर उनके शुरुआती बिंदु को निर्धारित करता है। प्रत्येक का एक महत्वपूर्ण निरंतर वर्चस्व है जो तेजी से बढ़ेगा।$C$

• के लिए , समय निर्धारित करता है।$O(1)$$C$
• सी × एन $O(n)$ वास्तव में , जहां कोण को निर्धारित करता है।$C \times n$$C$
• ( सी × एन ) 2$O(n^2)$ वास्तव में , जहां वक्र के तीखेपन को निर्धारित करता है।$(C \times n)^2$$C$

यह निर्धारित करने के लिए कि आपको किस एल्गोरिथ्म का उपयोग करना चाहिए, आपको उस स्थान का अनुमान लगाने की आवश्यकता है जहां रनटाइम्स प्रतिच्छेद करते हैं। उदाहरण के लिए, एक एक उच्च स्टार्टअप समय या एक उच्च के साथ समाधान एक को खो देंगे एक कम स्टार्टअप समय और एक कम के साथ समाधान वस्तुओं की काफी बड़ी संख्या में।C O ( n ) $O(1)$$C$$O(n)$$C$

यहाँ एक वास्तविक दुनिया उदाहरण है। आपको एक यार्ड में ईंटों के एक झुंड को स्थानांतरित करना होगा। आप उन्हें अपने हाथों से एक बार में कुछ ले जा सकते हैं, या एक यात्रा में उन्हें उठाने और ड्राइव करने के लिए एक विशाल, धीमी बैकहो प्राप्त कर सकते हैं। तीन ईंटें हैं तो आपका क्या जवाब है? तीन हजार हैं तो आपका क्या जवाब है?

यहाँ एक सीएस उदाहरण है। मान लीजिए कि आपको एक सूची की आवश्यकता है जो हमेशा हल होती है। आप एक पेड़ का उपयोग कर सकते हैं जो लिए खुद को रखेगा । या आप पर प्रत्येक प्रविष्टि या विलोपन के बाद एक बिना सूची वाली सूची और पुन: क्रमबद्ध कर सकते हैं । क्योंकि पेड़ के संचालन जटिल हैं (उनके पास एक उच्च निरंतरता है), और छंटाई इतनी सरल (कम निरंतर) है, सूची संभवतः सैकड़ों या हजारों वस्तुओं को जीत लेगी।O ( n लॉग एन$O(\log{n})$$O(n \log{n})$

आप इस तरह की बात पर नजर रख सकते हैं, लेकिन अंत में बेंचमार्किंग है कि वह क्या करेगा। आपको यह भी देखना होगा कि आपके पास आमतौर पर कितने आइटम होंगे, और अधिक सौंपने के जोखिम को कम करना होगा। तुम भी तरह "प्रदर्शन से अधिक तेजी से नीचा होगा अपने धारणा दस्तावेज़ के लिए चाहता हूँ आइटम" या "हम की एक अधिकतम सेट आकार ग्रहण "।$X$$X$

चूँकि ये आवश्यकताएँ परिवर्तन के अधीन हैं, इसलिए इन प्रकार के निर्णयों को इंटरफ़ेस के पीछे रखना महत्वपूर्ण है। ऊपर दिए गए पेड़ / सूची उदाहरण में, पेड़ या सूची को उजागर न करें। इस तरह, यदि आपकी धारणा गलत हो जाती है, या आप एक बेहतर एल्गोरिथ्म पाते हैं, तो आप अपना विचार बदल सकते हैं। आप एक हाइब्रिड और गतिशील रूप से एल्गोरिदम भी कर सकते हैं क्योंकि आइटम की संख्या बढ़ती है।

Comments

कहना निरर्थक है । क्या तुम सच में मतलब यह है कि अगर चलने का समय है फिर (कई मामलों में) । यदि तो कई मामलों में , या अधिक औपचारिक रूप से । और इसी तरह। ध्यान दें, हालांकि, अन्य मामलों में निरंतर भिन्न होता है , कुछ सीमा के भीतर। टी = हे ( 1 ) टी ≈ सी टी = हे ( एन ) टी ≈ सी एन टी = सी एन + ओ ( n ) सी $O(1) = O(C)$$T = O(1)$$T \approx C$$T = O(n)$$T \approx Cn$$T = Cn + o(n)$$C$$n$

— युवल फिल्मस

@YuvalFilmus यही कारण है कि मुझे रेखांकन पसंद है।

— श्वेर्न

यह अब तक का सबसे अच्छा जवाब है, मुद्दा यह है कि तेजी से कार्य कैसे बढ़ता है।

— रिकार्डो

अच्छा ग्राफ, लेकिन अक्ष को वास्तव में "समय" लेबल किया जाना चाहिए, न कि "गति"। $y$

— इल्मरी करोनें

क्या लाइन वास्तव में एक परवलय है? यह छोटे लिए बहुत सपाट और बड़े लिए बहुत सपाट दिखता है । n $O(n^2)$$n$$n$

— डेविड रिचेर्बी

Answer 2

यह पहले से ही पोस्ट किए गए उत्तरों पर काफी हद तक गुल्लक है, लेकिन एक अलग दृष्टिकोण पेश कर सकता है।

यह खुलासा कर रहा है कि सवाल " एन के पर्याप्त रूप से छोटे मूल्यों" पर चर्चा करता है । बिग-ओ का संपूर्ण बिंदु यह वर्णन करना है कि प्रसंस्करण किस प्रकार संसाधित किया जा रहा है। यदि संसाधित किया जा रहा डेटा छोटा रहता है, तो बिग-ओ पर चर्चा करना अप्रासंगिक है, क्योंकि आप वृद्धि में दिलचस्पी नहीं रखते हैं (जो कि ऐसा नहीं है)।

एक और रास्ता रखो, यदि आप सड़क से बहुत कम दूरी पर जा रहे हैं, तो पैदल चलना, साइकिल या वाहन चलाना समान रूप से तेज़ हो सकता है। अगर आपकी कार की चाबी खोजने में थोड़ी देर लगेगी, या अगर आपकी कार को गैस आदि की जरूरत है, तो चलने में भी तेज हो सकता है।

छोटे एन के लिए , जो कुछ भी सुविधाजनक है उसका उपयोग करें।

यदि आप एक क्रॉस-कंट्री ट्रिप ले रहे हैं, तो आपको अपने ड्राइविंग, अपने गैस माइलेज आदि को अनुकूलित करने के तरीकों को देखने की जरूरत है।

Comments

"छोटे एन के लिए, जो कुछ भी सुविधाजनक है उसका उपयोग करें।" - यदि आप ऑपरेशन को अक्सर निष्पादित करते हैं , तो सबसे तेज़ (अपने ) चुनें। यह भी देखें यहाँ । $n$

— राफेल

महान रूपक!

— Evorlor

विशुद्ध रूप से गणितीय दृष्टिकोण से, असममित जटिलता आपको कुछ नहीं बताती है n < infinity।

— गॉर्डन गुस्ताफसन

Answer 3

उद्धरण बल्कि अस्पष्ट और अभेद्य है। कम से कम तीन संबंधित तरीके हैं जिनमें इसकी व्याख्या की जा सकती है।

इसके पीछे का शाब्दिक गणितीय बिंदु यह है कि, यदि आप केवल कुछ सीमा तक आकार के उदाहरणों में रुचि रखते हैं, तो केवल कई संभावित बदलाव हैं। उदाहरण के लिए, सौ वर्टिकल तक केवल बहुत से ग्राफ हैं। यदि केवल उदाहरणों की एक सीमित संख्या है, तो आप सिद्धांत रूप में, सभी संभावित उदाहरणों के सभी उत्तरों के एक लुक-अप तालिका का निर्माण करके समस्या को हल कर सकते हैं। अब, आप पहले जाँच करके उत्तर पा सकते हैं कि इनपुट बहुत बड़ा नहीं है (जो निरंतर समय लेता है: यदि इनपुट k से अधिक लंबा है $k$, यह अमान्य है) और फिर तालिका में उत्तर देखें (जो निरंतर समय लेता है: तालिका में प्रविष्टियों की एक निश्चित संख्या है)। ध्यान दें, हालांकि, तालिका का वास्तविक आकार संभवतः संभवतः बड़ा है। मैंने कहा कि सौ चक्करों पर केवल परिमित संख्याएँ होती हैं और यह सच है। यह सिर्फ इतना है कि परिमित संख्या ब्रह्मांड में परमाणुओं की संख्या से बड़ी है।

एक और अधिक व्यावहारिक बात यह है कि है, जब हम कहते हैं कि एक एल्गोरिथ्म का चलने का समय है , कि केवल अर्थ यह है कि यह है asymptotically सी एन 2  कदम, कुछ निरंतर के लिए  सी । है, वहाँ कुछ निरंतर है n 0 ऐसा है कि, सभी के लिए n ≥ एन 0 , एल्गोरिथ्म मोटे तौर पर लेता है ग n 2 कदम दूर है। लेकिन शायद n 0 = 100 , 000 , $\Theta(n^2)$ $cn^2$$C$$n_0$$n\geq n_0$$cn^2$$n_0=100,000,000$और आप केवल उस से अधिक छोटे आकार के उदाहरणों में रुचि रखते हैं। स्पर्शोन्मुख द्विघात बाध्य भी आपके छोटे उदाहरणों पर लागू नहीं हो सकता है। आप भाग्यशाली हो सकते हैं और यह छोटे इनपुट पर तेज हो सकता है (या आप अशुभ हो सकते हैं और यह धीमा हो सकता है)। उदाहरण के लिए, छोटे  , n 2 < 1000 n के लिए, इसलिए आप एक विषम एल्गोरिथ्म को चलाने के बजाय अच्छे स्थिरांक के साथ एक रेखीय एल्गोरिथ्म के साथ अच्छी तरह से भाग लेंगे। इसका वास्तविक जीवन का उदाहरण यह है कि विषमतम रूप से सबसे कुशल मैट्रिक्स गुणन एल्गोरिदम ( Coppersmith-Winograd के वेरिएंट , O ( n 2.3729 ) में चल रहे हैं) शायद ही कभी अभ्यास में उपयोग किए जाते हैं: Strassen's $n$$n^2 < 1000n$$O(n^{2.3729})$ एल्गोरिथ्म तब तक तेज़ है जब तक कि आपके मैट्रीज़ वास्तव में बड़े नहीं होते।$O(n^{2.8074})$

एक तीसरा बिंदु यह है कि, यदि  छोटा है, तो n 2 और n 3  भी छोटा है। उदाहरण के लिए, यदि आपको डेटा के कुछ हज़ार आइटम सॉर्ट करने की आवश्यकता है और आपको केवल एक बार उन्हें सॉर्ट करने की आवश्यकता है, तो कोई भी सॉर्टिंग एल्गोरिदम पर्याप्त है: need ( n 2$n$$n^2$$n^3$$\Theta(n^2)$एल्गोरिथ्म अभी भी केवल आपके डेटा को सॉर्ट करने के लिए कुछ दसियों लाख निर्देशों की आवश्यकता हो सकती है, जो सीपीयू पर बिलकुल भी समय नहीं है जो प्रति सेकंड अरबों निर्देशों का प्रदर्शन कर सकता है। ठीक है, मेमोरी एक्सेस भी हैं, लेकिन यहां तक ​​कि एक धीमी एल्गोरिथ्म एक सेकंड से भी कम समय लेगा, इसलिए एक सरल, धीमी एल्गोरिथ्म का उपयोग करना बेहतर है और इसे एक जटिल, तेज एल्गोरिथ्म का उपयोग करने की तुलना में सही है और पाएं कि यह बिजली की तेजी से है। लेकिन छोटी गाड़ी और वास्तव में डेटा को ठीक से सॉर्ट नहीं करता है।

Comments

$O(n)$$O(1)$$n$$10n + 50$$100000$$n$$O(n)$

@RanG। क्या यह मेरे दूसरे मामले के अंतर्गत नहीं आता है? (खासकर अगर मैं इसे कुछ और कहने के लिए संपादित करता हूं जैसे "अच्छे स्थिरांक के साथ एक रेखीय एल्गोरिथ्म एक निरंतर / खराब

— कांस्टेंट के

जब n छोटा हो तो स्पष्ट रूप से स्थिरांक के महत्व का उल्लेख करना अच्छा होगा । यह ऐसा कुछ है जो शायद किसी ऐसे व्यक्ति के साथ नहीं होगा, जिसने इसे पहले नहीं सुना है।

— रोब वाट्स

Answer 4

$f (n) = O (n^2)$$n_0$$f (n) < c n^2$$n > n_0$

$c n^2$$n^2 + 10^{18}$

दूसरी ओर, यदि आप कभी भी एन = 1, 2 और 3 के मूल्यों का सामना करते हैं, तो व्यवहार में इससे कोई फर्क नहीं पड़ता कि f (n) n, 4 के लिए क्या करता है, इसलिए आप उस f पर विचार कर सकते हैं ( n) = O (1), c = max (f (1), f (2), f (3)) के साथ। और इसका पर्याप्त रूप से छोटा अर्थ है: यदि दावा है कि f (n) = O (1) आपको गुमराह नहीं करता है यदि आपके द्वारा च (n) के केवल मान "पर्याप्त रूप से छोटे" हैं।

Answer 5

अगर यह नहीं बढ़ता है, तो यह ओ (1) है

लेखक का कथन थोड़ा स्वयंसिद्ध है।

वृद्धि के आदेशों का वर्णन है कि काम की मात्रा क्या होती है जो आपको Nबढ़ना चाहिए । यदि आप जानते हैं कि Nवृद्धि नहीं हुई है, तो आपकी समस्या प्रभावी रूप से है O(1)।

याद रखें कि O(1)"तेज" का मतलब नहीं है। एक एल्गोरिथ्म जिसे पूरा करने के लिए हमेशा 1 ट्रिलियन चरणों की आवश्यकता होती है O(1)। एक एल्गोरिथ्म जो 1-200 चरणों से कहीं भी ले जाता है, लेकिन कभी भी अधिक नहीं होता है O(1)। [1]

यदि आपका एल्गोरिथ्म बिल्कुल N ^ 3कदम उठाता है, और आप जानते हैं कि Nयह 5 से अधिक नहीं हो सकता है, तो यह कभी भी 125 से अधिक कदम नहीं उठा सकता है, इसलिए यह प्रभावी रूप से है O(1)।

लेकिन फिर, O(1)जरूरी नहीं कि "पर्याप्त तेजी से" हो। यह एक अलग प्रश्न है जो आपके संदर्भ पर निर्भर करता है। यदि किसी चीज़ को पूरा करने में एक सप्ताह का समय लगता है, तो तकनीकी रूप से यदि आपको इसकी परवाह नहीं है O(1)।

---

[१] जैसे, हैश में O(1)दिखना, भले ही हैश टकराव का मतलब है कि आपको एक बाल्टी में कई वस्तुओं को देखना पड़ सकता है, जब तक कि उस बाल्टी में कितने आइटम हो सकते हैं, इसकी एक कठिन सीमा है।

Comments

यह सब मान्य लगता है, इसके अलावा: "यदि आपका एल्गोरिथ्म बिल्कुल एन ^ 3 कदम लेता है, और आप जानते हैं कि एन 5 से अधिक नहीं हो सकता है, तो यह कभी भी 125 से अधिक कदम नहीं उठा सकता है, इसलिए यह ओ (1) है।" । फिर, अगर एक एल्गोरिथ्म एक पूर्णांक लेता है, और मेरा अधिकतम पूर्णांक समर्थन 32767 है, तो क्या यह ओ (1) है? बेशक नहीं। Big-O मापदंडों की सीमा के आधार पर परिवर्तित नहीं होता है। यह O (n) है, भले ही आपको पता हो कि 0 <n <3 क्योंकि n = 2 दो बार n = 1 तक ले जाता है।

— जेएसोबेल

@ जेस्बेल लेकिन यह ओ (1) है। यदि कोई सीमा है जो आपके n को f (n) तक सीमित करती है, तो इसका मतलब है कि यह अनिश्चित काल तक नहीं बढ़ सकता है। यदि आपका n 2 ^ 15 तक सीमित है तो आपका great n ^ 2 फ़ंक्शन वास्तव में है g(n) = min(f(2^15), f(n))- जो O (1) में है। कहा कि अभ्यास में स्थिरांक बहुत मायने रखते हैं और स्पष्ट रूप से n इतना बड़ा हो सकता है कि एक स्पर्शोन्मुख विश्लेषण उपयोगी हो।

— वू

@JSobell यह इस सवाल के समान है कि क्या कंप्यूटर सही मायने में "ट्यूरिंग कम्प्लीट" हैं, यह देखते हुए कि तकनीकी रूप से उनके पास अनंत स्टोरेज स्पेस नहीं है। तकनीकी रूप से, गणितीय रूप से, एक कंप्यूटर "ट्रू" मशीन नहीं है। व्यवहार में, "अनंत टेप" जैसी कोई चीज नहीं है, लेकिन हार्ड ड्राइव काफी करीब आते हैं।

— काइल स्ट्रैंड

मैंने कई साल पहले एक वित्तीय जोखिम प्रणाली लिखी थी जिसमें n ^ 5 मैट्रिक्स जोड़तोड़ शामिल थे, इसलिए संसाधनों का मुद्दा बनने से पहले n = 20 की व्यावहारिक सीमा थी।

— जेएसोबेल

क्षमा करें, बहुत जल्द Enter दबाया गया। मैंने कई साल पहले एक वित्तीय जोखिम प्रणाली लिखी थी जिसमें n ^ 5 मैट्रिक्स जोड़तोड़ शामिल थे, इसलिए संसाधनों का मुद्दा बनने से पहले n = 20 की व्यावहारिक सीमा थी। इस त्रुटिपूर्ण तर्क के अनुसार, बनाया गया फ़ंक्शन O (1) है क्योंकि मेरे पास 20 का बाउंड है। जब क्लाइंट कहता है "हम्म, शायद हमें इसे एक सीमा के रूप में 40 तक ले जाना चाहिए ... हाँ, एल्गोरिथ्म हे (1) ) तो यह कोई समस्या नहीं है "... यही कारण है कि एक इनपुट पर सीमाएं व्यर्थ हैं। फ़ंक्शन O (n ^ 5) था, O (1) नहीं, और यह एक व्यावहारिक उदाहरण है कि Big-O सीमा से स्वतंत्र क्यों है।

— जेस्सोबेल

Answer 6

अब, मैं एक हैशटेबल का उपयोग कर सकता हूं, और ओ (1) लुकअप (हैशटेबल के विशिष्ट कार्यान्वयन को छोड़कर) कर सकता हूं, लेकिन अगर मेरे पास उदाहरण है, तो एक सूची, मेरे पास ओ (एन) लुकअप होंगे। इस स्वयंसिद्ध को देखते हुए, ये दोनों समान हैं यदि संग्रह काफी छोटा है। लेकिन कुछ बिंदु पर वे अलग हो जाते हैं ... वह बिंदु क्या है?

व्यावहारिक रूप से, यह वह बिंदु है जहां हैश तालिका बनाने से आपको बेहतर लुकअप से लाभ मिलता है। यह देखने के आधार पर बहुत भिन्न होगा कि आप कितनी बार लुकअप कर रहे हैं, बनाम कितनी बार आप अन्य चीजें कर रहे हैं। यदि आप इसे एक बार करते हैं तो O (1) बनाम O (10) कोई बड़ी बात नहीं है। यदि आप इसे दूसरी बार हजारों बार करते हैं, तो भी यह मायने रखता है (हालांकि कम से कम यह एक रैखिक रूप से बढ़ती दर पर मायने रखता है)।

Comments

यदि आप सुनिश्चित होना चाहते हैं, तो यह देखने के लिए कुछ प्रयोग करें कि आपके मापदंडों के लिए कौन सी डेटा संरचना बेहतर है ।

— युवल फिल्मस

@ टेलस्टाइन युवल फिल्मस सही है, अगर आप वास्तव में निश्चित होना चाहते हैं। मैं एक व्यक्ति को जिम का नाम जानता हूं, उसके पैरामीटर ठीक हैं। लेकिन उन्होंने युवल की सलाह को नहीं सुना। आपको वास्तव में निश्चित और सुरक्षित होने के लिए युवल को सुनना चाहिए।

— सूचित

Answer 7

जबकि उद्धरण सत्य है (लेकिन अस्पष्ट) इसके खतरे भी हैं। Imo आप अपने आवेदन के किसी भी चरण में जटिलता को देखना चाहिए।

यह कहना बहुत आसान है: हे मेरे पास केवल एक छोटी सूची है, अगर मैं यह जांचना चाहता हूं कि क्या आइटम ए सूची में है तो मैं सूची को देखने और आइटम की तुलना करने के लिए एक आसान लूप लिखूंगा।

तब आपका दोस्त सूची का उपयोग करने की जरूरत के साथ आता है, आपके कार्य को देखता है और इस तरह है: अरे मुझे सूची में कोई भी डुप्लिकेट नहीं चाहिए इसलिए वह सूची में जोड़े गए प्रत्येक आइटम के लिए फ़ंक्शन का उपयोग करता है।

(माइंड यू, यह अभी भी एक छोटी सूची परिदृश्य है।)

3 साल बाद मैं साथ आता हूं और मेरे मालिक ने एक बड़ी बिक्री की है: हमारे सॉफ्टवेयर का उपयोग एक बड़े राष्ट्रीय रिटेलर द्वारा किया जा रहा है। इससे पहले कि हम केवल छोटी दुकानों की सेवा करते थे। और अब मेरा बॉस मेरे पास आकर कसमसा रहा है और चिल्ला रहा है कि क्यों, सॉफ्टवेयर, जिसने हमेशा "ठीक काम किया है" अब बहुत धीरे है।

पता चला, वह सूची ग्राहकों की एक सूची थी, और हमारे ग्राहकों को शायद 100 ग्राहक पसंद थे, इसलिए किसी ने गौर नहीं किया। सूची को पॉप्युलेट करने का कार्य मूल रूप से O (1) ऑपरेशन था, क्योंकि यह तब मिलीसेकंड से कम था। खैर, इतना नहीं जब 10.000 क्लाइंट्स को इसमें जोड़ा जाए।

और मूल खराब ओ (1) निर्णय के वर्षों बाद, कंपनी ने लगभग एक बड़ा ग्राहक खो दिया। सभी एक छोटे से डिजाइन / धारणा त्रुटि सालों पहले होने के कारण।

Comments

लेकिन यह कई वास्तविक-दुनिया प्रणालियों की एक महत्वपूर्ण विशेषता को भी दिखाता है: "एल्गोरिदम" जो आप एक स्नातक के रूप में सीखते हैं, वे वास्तव में टुकड़े होते हैं जिनसे वास्तविक "एल्गोरिदम" बना होता है। यह आमतौर पर संकेत दिया जाता है; उदाहरण के लिए, अधिकांश लोगों को पता है कि विभाजन को छोटा करने के लिए क्विकॉर्ट को अक्सर सम्मिलन प्रकार पर वापस जाने के लिए लिखा जाता है और बाइनरी खोज को अक्सर रैखिक खोज में वापस आने के लिए लिखा जाता है। लेकिन बहुत से लोगों को यह एहसास नहीं है कि मर्ज सॉर्ट कुछ बाइनरी खोज से लाभ उठा सकता है।

— छद्म नाम

Answer 8

ऐसा करने की प्रेरणा इस गलत विचार पर आधारित है कि O (1) हमेशा O (lg n) से बेहतर होता है, O (n) से हमेशा बेहतर होता है। यदि किसी परिस्थिति में समस्या का आकार वास्तव में बड़ा हो जाता है, तो किसी ऑपरेशन का स्पर्शोन्मुख क्रम ही प्रासंगिक होता है।

अगर मेरे पास इन समय के साथ दो एल्गोरिदम हैं:

• लॉग (एन) 10,000
• n + 1

फिर कुछ बिंदु मौजूद हैं जहां वे पार करते हैं। nउससे छोटे के लिए , "रैखिक" एल्गोरिथ्म तेज है, और इससे भी nबड़ा "लॉगरिदमिक" एल्गोरिथ्म तेज है। बहुत से लोग लॉगरिदमिक एल्गोरिथम को संभालने की गलती करते हैं, लेकिन छोटे के लिए n, यह नहीं है।

अगर n छोटा रहता है तो हर समस्या O (1) है!

मैं अटकलें लगाता हूं कि यहां जो कुछ भी है nवह सीमित है, तो हर समस्या ओ (1) है। उदाहरण के लिए, यदि हम पूर्णांक को छाँट रहे हैं, तो हम क्विकॉर्ट का उपयोग करना चुन सकते हैं। O(n*log(n))जाहिर है। लेकिन अगर हम तय करते हैं कि 2^64=1.8446744e+19पूर्णांक से अधिक कभी नहीं हो सकते हैं, तो हम जानते हैं कि n*log(n)<= 1.8446744e+19*log(1.8446744e+19)<= 1.1805916e+21। इसलिए, एल्गोरिथ्म हमेशा 1.1805916e+21"समय की इकाइयों" से कम ले जाएगा । जैसा कि एक निरंतर समय है, हम कह सकते हैं कि एल्गोरिथ्म हमेशा उस निरंतर समय में किया जा सकता है -> O(1)। (ध्यान दें कि भले ही समय की वे इकाइयां नैनोसेकंड हों, यह 37411 वर्षों से अधिक का कुल है)। लेकिन फिर भी O(1)।

Answer 9

मुझे संदेह है कि इनमें से कई उत्तर एक मौलिक अवधारणा को याद कर रहे हैं। O (1): O (n) f (1): f (n) के समान नहीं है, जहां f एक ही कार्य है, क्योंकि O एक फ़ंक्शन का प्रतिनिधित्व नहीं करता है। यहां तक ​​कि श्वार्न का अच्छा ग्राफ मान्य नहीं है क्योंकि इसमें सभी लाइनों के लिए समान वाई अक्ष है। सभी एक ही धुरी का उपयोग करने के लिए लाइनों को fn1, fn2 और fn3 होना चाहिए, जहां प्रत्येक एक फ़ंक्शन था जिसका प्रदर्शन सीधे दूसरों की तुलना में हो सकता है।

मैंने कई बार सुना है कि पर्याप्त रूप से छोटे मानों के लिए, O (n) के बारे में सोचा जा सकता है / माना जाता है जैसे कि यह O (1) है

ठीक है, अगर n = 1 वे समान हैं? नहीं। एक फ़ंक्शन जो चर संख्या की पुनरावृत्तियों की अनुमति देता है, उसमें ऐसा कुछ भी नहीं है जो बिग-ओ नोटेशन की परवाह नहीं करता है, और न ही हमें करना चाहिए।

बिग-ओ नोटेशन केवल यह व्यक्त करने के लिए होता है कि जब हमारे पास एक पुनरावृत्ति प्रक्रिया होती है, और 'n' बढ़ने पर प्रदर्शन (समय या संसाधन) कैसे घटते हैं।

इसलिए वास्तविक प्रश्न का उत्तर देने के लिए ... मैं कहूंगा कि जो लोग दावा करते हैं वे बिग-ओ नोटेशन को ठीक से नहीं समझते हैं, क्योंकि यह एक अतार्किक तुलना है।

यहां एक समान प्रश्न है: यदि मैं वर्णों की एक स्ट्रिंग के माध्यम से लूप करता हूं, और मुझे पता है कि सामान्य रूप से मेरे तार 10 वर्णों से कम होंगे, तो क्या मैं कह सकता हूं कि यह ओ (1) के बराबर है, लेकिन अगर मेरे तार लंबे थे तो मैं 'd कहो यह O (n) था?

नहीं, क्योंकि १० वर्णों की एक स्ट्रिंग १ वर्ण की एक स्ट्रिंग जितनी लंबी होती है, १० बार लगती है, लेकिन १००० वर्णों की एक स्ट्रिंग से १०० गुना कम है! चालू है)।

Comments

$O(1)$$f(i)$$i$$\max\,\{f(0), \dots, f(10)\}$$O(1)$

हां, और यह एक उदाहरण है जहां बिग-ओ संकेतन आमतौर पर गलत समझा जाता है। आपके तर्क के अनुसार, यदि मुझे पता है कि n का अधिकतम मान 1,000,000 है, तो मेरा कार्य O (1) है। वास्तव में, मेरा कार्य सर्वश्रेष्ठ O (1) और सबसे खराब O (n) पर हो सकता है। इस संकेतन का उपयोग एल्गोरिदमिक जटिलता का वर्णन करने के लिए किया जाता है, न कि एक ठोस कार्यान्वयन के लिए, और हम हमेशा एक परिदृश्य का वर्णन करने के लिए सबसे महंगे का उपयोग करते हैं, सर्वश्रेष्ठ का नहीं। वास्तव में, आपके तर्क से, हर एक फ़ंक्शन जो n <2 की अनुमति देता है O (1) है! :)

— JSobell

$n<2$$O(1)$$f(n)\leq f(10)$$n$$O(1)$

क्षमा करें, लेकिन यदि आप कहते हैं कि n की ऊपरी सीमा को जानने से फ़ंक्शन O (1) हो जाता है, तो आप कह रहे हैं कि नोटिफ़िकेशन निरूपण सीधे n के मान से संबंधित है, और यह नहीं है। आपके द्वारा उल्लिखित बाकी सब सही है, लेकिन यह सुझाव देता है कि क्योंकि n की सीमा है, यह O (1) सही नहीं है। व्यवहार में ऐसी जगहें हैं जहाँ आप जो वर्णन करते हैं वह देखने योग्य हो सकता है, लेकिन हम यहाँ बिग-ओ संकेतन देख रहे हैं, न कि क्रियात्मक कोडिंग। तो फिर, आप यह क्यों सुझाएंगे कि अधिकतम 10 होने से यह O (1) हो जाएगा? क्यों 10? 65535 या 2 ^ 64 क्यों नहीं?

— JSobell

यह कहने के बाद कि, यदि आप एक ऐसा फंक्शन लिखते हैं जो एक तार को 10 वर्णों तक खींचता है, तो हमेशा तार पर लूप होता है, तो यह O (1) है क्योंकि n हमेशा 10 है :)

— JSobell

Answer 10

मेरा मानना ​​है कि आपके द्वारा उद्धृत पाठ काफी गलत है (शब्द "बेहतर" का उपयोग आमतौर पर तब तक व्यर्थ है जब तक आप संदर्भ प्रदान नहीं करते हैं: समय, स्थान आदि के संदर्भ में) वैसे भी, मेरा मानना ​​है कि सबसे सरल स्पष्टीकरण होगा:

$O(1)$$O(1)$

अब, चलो 10 तत्वों का एक छोटा सा सेट लेते हैं और इसे सॉर्ट करने के लिए कुछ एल्गोरिदम हैं (बस एक उदाहरण)। मान लेते हैं कि हम तत्वों को एक संरचना में रखते हैं जो हमें एल्गोरिथ्म प्रदान करता है जो तत्वों को निरंतर समय में छांटने में सक्षम है। मान लें कि हमारे छंटाई-एल्गोरिदम में निम्नलिखित जटिलताएं हो सकती हैं (बड़े-ओ संकेतन के साथ):

1. $O(1)$
2. $O(n)$
3. $O(nlog(n))$
4. $O(n^2)$

$O(1)$

अब ऊपर बताए गए उस सॉर्टिंग एल्गोरिदम की वास्तविक जटिलताओं को "प्रकट" करते हैं (जहां "सत्य" का अर्थ है निरंतर को छिपाना नहीं), समाप्त करने के लिए आवश्यक चरणों की संख्या द्वारा प्रतिनिधित्व किया गया है (और सभी चरणों को एक ही समय लगता है):

1. $200$
2. $11n$
3. $4nlog(n)$
4. $1n^2$

यदि हमारा इनपुट 10 आकार का है, तो ये ऊपर उल्लिखित प्रत्येक एल्गोरिदम के सटीक चरण हैं:

1. $200$
2. $11 \times 10 = 110$
3. $4 \times 10 \times 3.32 \approx 134$
4. $1 \times 100 = 100$

$O(n^2)$$O(1), O(n)$$O(nlog(n))$$O(n^2)$$O(1)$$O(n^2)$$O(1)$