"बिग ओ" अंकन की एक स्पष्ट अंग्रेजी व्याख्या क्या है?

Question

मैं संभव और सरल गणित के रूप में कम औपचारिक परिभाषा पसंद करता हूँ।

Comments

सारांश: एक एल्गोरिथ्म की जटिलता की ऊपरी सीमा। इसी तरह का प्रश्न बिग ओ भी देखें , आप इसकी गणना कैसे करते / करते हैं? एक अच्छी व्याख्या के लिए।

— कोसी 2801

अन्य उत्तर काफी अच्छे हैं, इसे समझने के लिए सिर्फ एक विवरण: ओ (लॉग एन) या इसी तरह के साधन, कि यह इनपुट की "लंबाई" या "आकार" पर निर्भर करता है, न कि मूल्य पर। यह समझना मुश्किल हो सकता है, लेकिन बहुत महत्वपूर्ण है। उदाहरण के लिए, ऐसा तब होता है जब आपका एल्गोरिथ्म प्रत्येक पुनरावृत्ति में दो चीजों को विभाजित कर रहा होता है।

— हेराल्ड शाली

एमआईटी के व्याख्यान 8 में एल्गोरिदम की जटिलता के लिए समर्पित एक व्याख्यान है "कंप्यूटर विज्ञान और प्रोग्रामिंग के लिए परिचय" पाठ्यक्रम youtube.com/watch?v=ewd7Lf2dr5Q यह पूरी तरह से सादे अंग्रेजी नहीं है, लेकिन उदाहरणों के साथ अच्छी व्याख्या देता है आसानी से समझने योग्य।

— ivanjovanovic

बिग ओ एक फ़ंक्शन के सबसे खराब मामले के प्रदर्शन का अनुमान है जो यह मानता है कि एल्गोरिथ्म अधिकतम पुनरावृत्तियों का प्रदर्शन करेगा।

— पॉल स्वेट

Big-O notation explained by a self-taught programmer

— सोनर गॉनुएल

Answer 1

त्वरित ध्यान दें, यह लगभग निश्चित रूप से थीटा नोटेशन "is" (जो एक दो-पक्ष बाध्य है) के साथ बिग ओ नोटेशन (जो एक ऊपरी बाध्य है) को भ्रमित कर रहा है। मेरे अनुभव में, यह वास्तव में गैर-शैक्षणिक सेटिंग्स में चर्चा का विषय है। किसी भी भ्रम के कारण माफी।

---

बिग ओ जटिलता को इस ग्राफ के साथ देखा जा सकता है:

बिग-ओ नोटेशन के लिए मैं सबसे सरल परिभाषा दे सकता हूं:

बिग-ओ अंकन एक एल्गोरिथ्म की जटिलता का एक सापेक्ष प्रतिनिधित्व है।

उस वाक्य में कुछ महत्वपूर्ण और जानबूझकर चुने गए शब्द हैं:

• रिश्तेदार: आप केवल सेब की तुलना सेब से कर सकते हैं। आप एक एल्गोरिथ्म की तुलना नहीं कर सकते हैं जो अंकगणित की सूची को सॉर्ट करने वाले एल्गोरिथ्म में अंकगणितीय गुणन करता है। लेकिन अंकगणितीय संचालन (एक गुणा, एक जोड़) करने के लिए दो एल्गोरिदम की तुलना आपको कुछ सार्थक बताएगी;
• प्रतिनिधित्व: बिग-ओ (इसके सरल रूप में) एल्गोरिदम के बीच तुलना को एक एकल चर में कम कर देता है। उस चर को टिप्पणियों या मान्यताओं के आधार पर चुना जाता है। उदाहरण के लिए, छँटाई एल्गोरिदम की तुलना आम तौर पर तुलना संचालन (उनके सापेक्ष क्रम निर्धारण के लिए दो नोड्स की तुलना) के आधार पर की जाती है। यह मानता है कि तुलना महंगी है। लेकिन क्या होगा अगर तुलना सस्ती है लेकिन स्वैपिंग महंगी है? यह तुलना को बदलता है; तथा
• जटिलता: अगर मुझे 10,000 तत्वों को छाँटने में एक सेकंड लगता है, तो मुझे एक मिलियन को छाँटने में कितना समय लगेगा? इस उदाहरण में जटिलता कुछ और के लिए एक रिश्तेदार उपाय है।

जब आपने बाकी पढ़ा है, तो वापस आएं और ऊपर फिर से डालें।

बिग-ओ का सबसे अच्छा उदाहरण मैं सोच सकता हूं कि वह अंकगणित कर रहा है। दो नंबर (123456 और 789012) लें। बुनियादी अंकगणितीय ऑपरेशन जो हमने स्कूल में सीखे:

• इसके अलावा,
• घटाव;
• गुणन; तथा
• विभाजन।

इनमें से प्रत्येक एक ऑपरेशन या एक समस्या है। इन्हें हल करने की एक विधि को एक एल्गोरिथ्म कहा जाता है ।

इसके अलावा सबसे सरल है। आप संख्याओं को (दाईं ओर) लाइन करते हैं और परिणाम में उस संख्या की अंतिम संख्या लिखते हुए एक कॉलम में अंकों को जोड़ते हैं। उस संख्या का 'दहाई' भाग अगले कॉलम पर ले जाया जाता है।

मान लेते हैं कि इन संख्याओं का जोड़ इस एल्गोरिथ्म में सबसे महंगा ऑपरेशन है। यह इस कारण से है कि इन दोनों संख्याओं को एक साथ जोड़ने के लिए हमें 6 अंकों को एक साथ जोड़ना होगा (और संभवतः 7 वें स्थान पर ले जाना होगा)। यदि हम दो 100 अंकों की संख्याओं को जोड़ते हैं तो हमें 100 जोड़ करने होंगे। अगर हम दो 10,000 अंकों की संख्या जोड़ते हैं तो हमें 10,000 अतिरिक्त करने होंगे।

पैटर्न देखें? जटिलता (आपरेशन की संख्या जा रहा है) सीधे अंकों की संख्या के लिए आनुपातिक है एन बड़ी संख्या में। हम इसे O (n) या रैखिक जटिलता कहते हैं ।

घटाव समान है (सिवाय आपको ले जाने के बजाय उधार लेने की आवश्यकता हो सकती है)।

गुणन अलग है। आप संख्याओं को पंक्तिबद्ध करते हैं, पहले अंक को नीचे की संख्या में लेते हैं और इसे प्रत्येक अंक के विपरीत शीर्ष संख्या में और इसी तरह प्रत्येक अंक पर गुणा करते हैं। तो हमारे दो 6 अंकों की संख्या को गुणा करने के लिए हमें 36 गुणा करना होगा। अंतिम परिणाम प्राप्त करने के लिए हमें 10 या 11 कॉलम जोड़ने की आवश्यकता होगी।

अगर हमारे पास दो 100 अंकों की संख्या है, तो हमें 10,000 गुणा और 200 जोड़ करने की आवश्यकता है। दो मिलियन अंकों की संख्या के लिए हमें एक ट्रिलियन (10 ¹² ) गुणा और दो मिलियन अतिरिक्त करने की आवश्यकता है।

जैसा कि एल्गोरिथ्म n- वर्ग के साथ है , यह O (n ² ) या द्विघात जटिलता है । यह एक और महत्वपूर्ण अवधारणा पेश करने का अच्छा समय है:

हम केवल जटिलता के सबसे महत्वपूर्ण हिस्से की परवाह करते हैं।

अचरज ने महसूस किया होगा कि हम ऑपरेशन की संख्या को व्यक्त कर सकते हैं: n ² + 2n। लेकिन जैसा कि आपने हमारे उदाहरण से देखा कि एक मिलियन अंकों के दो अंकों के साथ, दूसरा शब्द (2n) महत्वहीन हो जाता है (उस चरण के कुल संचालन का 0.0002% के लिए लेखांकन)।

एक नोटिस कर सकता है कि हमने यहां सबसे खराब स्थिति का अनुमान लगाया है। 6 अंकों की संख्याओं को गुणा करते समय, यदि उनमें से एक के 4 अंक हैं और दूसरे के 6 अंक हैं, तो हमारे पास केवल 24 गुणा हैं। फिर भी, हम उस 'n' के लिए सबसे खराब स्थिति की गणना करते हैं, अर्थात जब दोनों 6 अंकों की संख्या होते हैं। इसलिए बिग-ओ नोटेशन एक एल्गोरिथ्म के सबसे खराब स्थिति के बारे में है।

टेलीफोन बुक

अगला सबसे अच्छा उदाहरण मैं सोच सकता हूं कि टेलीफोन बुक है, जिसे आम तौर पर व्हाइट पेज या समान कहा जाता है लेकिन यह देश से दूसरे देश में भिन्न होता है। लेकिन मैं उस व्यक्ति के बारे में बात कर रहा हूं जो उपनाम और फिर शुरुआती या पहले नाम, संभवतः पते और फिर टेलीफोन नंबर द्वारा लोगों को सूचीबद्ध करता है।

अब यदि आप एक टेलीफोन बुक में "जॉन स्मिथ" के लिए फोन नंबर देखने के लिए एक कंप्यूटर को निर्देश दे रहे थे जिसमें 1,000,000 नाम शामिल हैं, तो आप क्या करेंगे? इस तथ्य को अनदेखा करना कि आप अनुमान लगा सकते हैं कि S की शुरुआत में कितनी दूर है (मान लें कि आप नहीं कर सकते हैं), आप क्या करेंगे?

एक विशिष्ट कार्यान्वयन मध्य तक खुलने, 500,000 ^{वें स्थान पर रहने} और "स्मिथ" से तुलना करने के लिए हो सकता है । अगर ऐसा होता है "स्मिथ, जॉन", तो हम वास्तव में भाग्यशाली हैं। अधिक संभावना यह है कि "जॉन स्मिथ" उस नाम से पहले या बाद में होगा। अगर यह हमारे बाद है तो फोन बुक के आखिरी आधे हिस्से को आधा में विभाजित करें और दोहराएं। यदि यह पहले है, तो हम फोन बुक के पहले आधे हिस्से को आधा में विभाजित करते हैं और दोहराते हैं। और इसी तरह।

इसे बाइनरी खोज कहा जाता है और इसका उपयोग प्रोग्रामिंग में हर दिन किया जाता है चाहे आपको इसका एहसास हो या न हो।

इसलिए यदि आप एक लाख नामों की फोन बुक में नाम ढूंढना चाहते हैं तो आप वास्तव में 20 बार ऐसा कर किसी भी नाम का पता लगा सकते हैं। खोज एल्गोरिदम की तुलना में हम तय करते हैं कि यह तुलना हमारा 'एन' है।

• 3 नामों की एक फोन बुक के लिए यह 2 तुलना (सबसे अधिक) लेता है।
• 7 के लिए यह अधिकतम 3 पर लेता है।
• 15 के लिए यह 4 लेता है।
• ...
• 1,000,000 के लिए यह 20 लेता है।

यह बहुत अच्छा है, है ना?

बिग-ओ के संदर्भ में यह ओ (लॉग एन) या लॉगरिदमिक जटिलता है । अब प्रश्न में लघुगणक ln (आधार ई), लॉग ₁₀ , लॉग ₂ या कुछ अन्य आधार हो सकता है। इससे कोई फर्क नहीं पड़ता कि यह अभी भी O (2n ² ) की तरह O (log n ) है और O (100n ² ) अभी भी O (n ² ) दोनों हैं ।

इस बिंदु पर यह समझाना सार्थक है कि बिग ओ का उपयोग एल्गोरिदम के साथ तीन मामलों को निर्धारित करने के लिए किया जा सकता है:

• सर्वश्रेष्ठ मामला: टेलीफोन बुक खोज में, सबसे अच्छा मामला यह है कि हम एक तुलना में नाम पाते हैं। यह ओ (1) या निरंतर जटिलता है ;
• अपेक्षित मामला: जैसा कि ऊपर चर्चा की गई यह हे (लॉग एन) है; तथा
• सबसे खराब स्थिति: यह O (लॉग एन) भी है।

आम तौर पर हम सबसे अच्छे मामले की परवाह नहीं करते हैं। हम अपेक्षित और सबसे खराब स्थिति में रुचि रखते हैं। कभी-कभी इनमें से कोई एक या अधिक महत्वपूर्ण होगा।

वापस टेलीफोन की किताब पर।

यदि आपके पास एक फ़ोन नंबर है और एक नाम खोजना चाहते हैं तो क्या होगा? पुलिस के पास एक रिवर्स फोन बुक है, लेकिन आम जनता के लिए इस तरह के दिखावे से इनकार किया जाता है। या क्या वे? तकनीकी रूप से आप साधारण फोन बुक में एक नंबर को उल्टा कर सकते हैं। कैसे?

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

इसलिए फोन नंबर (रिवर्स लुकअप) दिया गया नाम खोजने के लिए:

• सर्वश्रेष्ठ मामला: ओ (1);
• अपेक्षित मामला: O (n) (500,000 के लिए); तथा
• सबसे खराब स्थिति: O (n) (1,000,000 के लिए)।

द ट्रैवलिंग सेल्समैन

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

सरल लगता है? फिर से विचार करना।

यदि आपके पास सभी जोड़े के बीच 3 शहर A, B और C हैं, तो आप जा सकते हैं:

• ए → बी → सी
• ए → सी → बी
• बी → सी → ए
• बी → ए → सी
• सी → ए → बी
• सी → बी → ए

ठीक है, वास्तव में इससे कम है क्योंकि इनमें से कुछ बराबर हैं (ए → बी → सी और सी → बी → ए बराबर हैं, उदाहरण के लिए, क्योंकि वे एक ही सड़कों का उपयोग करते हैं, बस रिवर्स में)।

वास्तविकता में, 3 संभावनाएं हैं।

• इसे 4 शहरों में ले जाएं और आपको (iirc) 12 संभावनाएं हैं।
• 5 के साथ यह 60 है।
• 6 360 हो जाता है।

यह एक गणितीय ऑपरेशन का एक कार्य है जिसे एक भाज्य कहा जाता है । मूल रूप से:

• 5! = 5 × 4 × 3 × 2 × 1 = 120
• 6! = 6 × 5 × 4 × 3 × 2 × 1 = 720
• 7! = 7 × 6 × 5 × 4 × 3 × 2 × 1 = 5040
• ...
• 25! = 25 × 24 ×… × 2 × 1 = 15,511,210,043,330,985,985,984,000,000
• ...
• 50! = 50 × 49 ×… × 2 × 1 = 3.04140932 × 10 ⁶⁴

तो ट्रैवलिंग सेल्समैन समस्या का बिग-ओ हे (एन!) या तथ्यात्मक या दहनशील जटिलता है ।

जब तक आप 200 शहरों में पहुंच जाते हैं, तब तक ब्रह्मांड में पर्याप्त समय नहीं बचा है, ताकि पारंपरिक कंप्यूटरों के साथ समस्या का समाधान किया जा सके।

कुछ चीजें सोचने के लिये।

बहुपदी समय फलन

एक और बात मैं की एक त्वरित उल्लेख करना चाहता था की एक जटिलता है कि किसी भी एल्गोरिथ्म है कि है (एन ओ ^एक ) कहा जाता है कि बहुपद जटिलता या में व्याख्या करने योग्य है बहुपद समय ।

O (n), O (n ² ) आदि सभी बहुपद काल हैं। कुछ समस्याओं को बहुपद समय में हल नहीं किया जा सकता है। इस वजह से दुनिया में कुछ चीजों का उपयोग किया जाता है। सार्वजनिक कुंजी क्रिप्टोग्राफी एक प्रमुख उदाहरण है। यह बहुत बड़ी संख्या के दो प्रमुख कारकों को खोजने के लिए कम्प्यूटेशनल रूप से कठिन है। यदि ऐसा नहीं होता, तो हम उन सार्वजनिक कुंजी प्रणालियों का उपयोग नहीं कर सकते जिनका हम उपयोग करते हैं।

वैसे भी, यह बिग ओ (संशोधित) की मेरी (उम्मीद के मुताबिक सादे अंग्रेजी) स्पष्टीकरण के लिए है।

Comments

जबकि अन्य उत्तर O (1), O (n ^ 2) et al .... के बीच अंतर को समझाने पर ध्यान केंद्रित करते हैं .... आपका वह विवरण है जो एल्गोरिदम को n ^ 2, nlog (n) आदि + में वर्गीकृत किया जा सकता है। 1 एक अच्छे उत्तर के लिए जिसने मुझे बिग ओ नोटेशन को समझने में मदद की

— यव लॉन्ग

कोई यह जोड़ना चाहता है कि बिग-ओ एक ऊपरी बाउंड (एक एल्गोरिथ्म द्वारा दिया गया) का प्रतिनिधित्व करता है, बिग-ओमेगा कम बाउंड देता है (आमतौर पर एक विशिष्ट एल्गोरिथ्म से स्वतंत्र प्रमाण के रूप में दिया जाता है) और बिग-थीटा का अर्थ है कि एक "इष्टतम" एल्गोरिथ्म उस निचली सीमा तक पहुंचना ज्ञात है।

— mdm

यह सबसे अच्छा है यदि आप सबसे लंबे उत्तर की तलाश में हैं, लेकिन उस उत्तर के लिए नहीं जो बिग-ओ को सरल तरीके से समझाता है।

— kirk.burleson

-1: यह स्पष्ट रूप से गलत है: _ "बिगओ एल्गोरिथ्म की जटिलता का सापेक्ष प्रतिनिधित्व है"। नहीं। BigOh एक स्पर्शोन्मुख ऊपरी बाध्य है और कंप्यूटर विज्ञान से काफी अच्छी तरह से स्वतंत्र है। O (n) रैखिक है। नहीं, आप थीटा के साथ बिगओ को भ्रमित कर रहे हैं। log n O (n) है। 1 O (n) है। इस उत्तर (और टिप्पणियों) तक की संख्या, जो थीटा को बिगओ के साथ भ्रमित करने की मूल गलती करती है, काफी शर्मनाक है ...

"जब तक आप 200 शहरों में पहुंच जाते हैं, तब तक पारंपरिक कंप्यूटर के साथ समस्या को हल करने के लिए ब्रह्मांड में पर्याप्त समय नहीं बचा है।" ब्रह्मांड कब खत्म होने वाला है?

— इसहाक

Answer 2

यह दिखाता है कि एक एल्गोरिथ्म इनपुट आकार के आधार पर कैसे मापता है।

O (n ² ) : द्विघात जटिलता के रूप में जाना जाता है

• 1 आइटम: 1 सेकंड
• 10 आइटम: 100 सेकंड
• 100 आइटम: 10000 सेकंड

ध्यान दें कि वस्तुओं की संख्या 10 के कारक से बढ़ जाती है, लेकिन समय 10 ^{2 के} कारक से बढ़ जाता है । असल में, n = 10 और इसलिए O (n ² ) हमें स्केलिंग कारक n ² देता है जो 10 ^{2 है} ।

O (n) : रैखिक जटिलता के रूप में जाना जाता है

• 1 आइटम: 1 सेकंड
• 10 आइटम: 10 सेकंड
• 100 आइटम: 100 सेकंड

इस बार वस्तुओं की संख्या 10 के कारक से बढ़ जाती है, और इसी तरह समय भी बढ़ता है। n = 10 और इसलिए O (n) का स्केलिंग फैक्टर 10 है।

O (1) : के रूप में जाना जाता है लगातार जटिलता के है

• 1 आइटम: 1 सेकंड
• 10 आइटम: 1 सेकंड
• 100 आइटम: 1 सेकंड

वस्तुओं की संख्या अभी भी 10 के एक कारक से बढ़ रही है, लेकिन ओ (1) का स्केलिंग कारक हमेशा 1 होता है।

O (लॉग एन) : लॉगरिदमिक जटिलता के रूप में जाना जाता है

• 1 आइटम: 1 सेकंड
• 10 आइटम: 2 सेकंड
• 100 आइटम: 3 सेकंड
• 1000 आइटम: 4 सेकंड
• 10000 आइटम: 5 सेकंड

अभिकलन की संख्या केवल इनपुट मान के लॉग द्वारा बढ़ाई जाती है। तो इस मामले में, प्रत्येक गणना को 1 सेकंड लगता है, इनपुट nका लॉग आवश्यक समय है, इसलिए log n।

यही इसका सार है। वे गणित को कम करते हैं, इसलिए यह वास्तव में n ² या जो कुछ भी वे कहते हैं, वह नहीं हो सकता है, लेकिन यह स्केलिंग में हावी कारक होगा।

Comments

इस परिभाषा का वास्तव में क्या मतलब है? (आइटमों की संख्या अभी भी 10 के कारक से बढ़ रही है, लेकिन ओ (1) का स्केलिंग फैक्टर हमेशा 1. है)

— Zach Smith

सेकंड नहीं, ऑपरेशन। इसके अलावा, आप तथ्यात्मक और लघुगणक समय से चूक गए।

— क्रिस चबरुक

यह बहुत अच्छी तरह से नहीं समझाता है कि O (n ^ 2) एक एल्गोरिथ्म का वर्णन कर सकता है जो ठीक .01 * n ^ 2 + 999999 * n + 999999 में चलता है। यह जानना महत्वपूर्ण है कि एल्गोरिदम की तुलना इस पैमाने का उपयोग करके की जाती है, और यह तुलना कार्य तब होता है जब n 'पर्याप्त रूप से बड़ा' होता है। पायथन का टाइमसॉर्ट वास्तव में सम्मिलन प्रकार (सबसे खराब / औसत केस O (n ^ 2)) का उपयोग छोटे सरणियों के लिए इस तथ्य के कारण करता है कि इसमें एक छोटा ओवरहेड है।

— केसी कुबाल

यह उत्तर बड़े ओ नोटेशन और थीटा नोटेशन को भी भ्रमित करता है। N का कार्य जो अपने सभी इनपुटों के लिए 1 रिटर्न करता है (आमतौर पर केवल 1 के रूप में लिखा जाता है) वास्तव में O (n ^ 2) में होता है (भले ही यह O (1) में भी हो)। इसी तरह, एक एल्गोरिथ्म जिसमें केवल एक कदम करना होता है जो निरंतर समय लेता है उसे O (1) एल्गोरिदम भी माना जाता है, लेकिन O (n) और O (n ^ 2) एल्गोरिथम भी माना जाता है। लेकिन शायद गणितज्ञ और कंप्यूटर वैज्ञानिक परिभाषा पर सहमत नहीं हैं: - / /।

— बजे जैकब अककरबूम

इस उत्तर में माना गया O (log n) लॉगरिदमिक जटिलता आधार 10 की है। आम तौर पर मानक आधार 2 के साथ गणना करने के लिए है। एक को इस तथ्य को ध्यान में रखना चाहिए और भ्रमित नहीं होना चाहिए। जैसा कि @ChrisCharabaruk द्वारा उल्लेख किया गया है कि जटिलता ऑपरेशनों की संख्या को दर्शाती है और सेकंड नहीं।

— अक्ष 1801

Answer 3

बिग-ओ नोटेशन (जिसे "एसिम्प्टोटिक ग्रोथ" नोटेशन भी कहा जाता है) तब होता है जब आप मूल कारकों के निकट स्थिर कारकों और सामानों को अनदेखा करते हैं, तो "लुक" जैसा होता है । हम इसका इस्तेमाल बात करने के पैमाने के बारे में बात करने के लिए करते हैं ।

---

मूल बातें

"पर्याप्त रूप से" बड़े इनपुट के लिए ...

• f(x) ∈ O(upperbound)इसका मतलब है f"से तेज नहीं बढ़ता है"upperbound
• f(x) ∈ Ɵ(justlikethis)मतलब f"बिल्कुल बढ़ता है"justlikethis
• f(x) ∈ Ω(lowerbound)इसका मतलब है f"से अधिक धीमी गति से बढ़ता है"lowerbound

बिग-ओ नोटेशन लगातार कारकों की परवाह नहीं करता है: फ़ंक्शन 9x²को "ठीक उसी तरह बढ़ने" के लिए कहा जाता है 10x²। न तो बिग-ओ एसिम्प्टोटिक नोटेशन गैर-एसिम्प्टोटिक सामान ("मूल के पास सामान" या "समस्या आकार छोटा होने पर क्या होता है") के बारे में परवाह करता 10x²है : फ़ंक्शन को "ठीक उसी तरह बढ़ने" के लिए कहा जाता है 10x² - x + 2।

आप समीकरण के छोटे हिस्सों को अनदेखा क्यों करना चाहेंगे? क्योंकि वे समीकरण के बड़े हिस्सों द्वारा पूरी तरह से बौने हो जाते हैं क्योंकि आप बड़े और बड़े पैमाने पर विचार करते हैं; उनका योगदान बौना और अप्रासंगिक हो जाता है। (उदाहरण अनुभाग देखें।)

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

actualAlgorithmTime(N) ∈ O(bound(N))
                                       e.g. "time to mergesort N elements 
                                             is O(N log(N))"

... इसका मतलब यह है कि "बड़े पर्याप्त" समस्या आकार एन के लिए (यदि हम मूल के पास सामान को अनदेखा करते हैं), तो कुछ स्थिर (जैसे 2.5, पूरी तरह से बना हुआ) मौजूद है जैसे:

actualAlgorithmTime(N)                 e.g. "mergesort_duration(N)       "
────────────────────── < constant            ───────────────────── < 2.5 
       bound(N)                                    N log(N)         

स्थिरांक के कई विकल्प हैं; अक्सर "सर्वश्रेष्ठ" विकल्प को एल्गोरिथ्म के "स्थिर कारक" के रूप में जाना जाता है ... लेकिन हम अक्सर इसे अनदेखा कर देते हैं जैसे हम गैर-सबसे बड़े शब्दों को अनदेखा करते हैं (देखें कि क्यों वे आम तौर पर कोई फर्क नहीं पड़ता है के लिए लगातार कारक अनुभाग)। आप उपरोक्त समीकरण को एक बाउंड के रूप में भी सोच सकते हैं, " सबसे खराब स्थिति में, जो समय लगता है वह कभी भी मोटे तौर पर इससे भी बदतर नहीं होगा N*log(N)। 2.5 के कारक के भीतर (एक स्थिर कारक जिसकी हमें ज्यादा परवाह नहीं है) " ।

सामान्य तौर पर, O(...)सबसे उपयोगी एक है क्योंकि हम अक्सर सबसे खराब स्थिति वाले व्यवहार की परवाह करते हैं। यदि f(x)प्रोसेसर या मेमोरी उपयोग जैसे कुछ "खराब" का प्रतिनिधित्व करता है, तो " f(x) ∈ O(upperbound)" का अर्थ है " upperboundप्रोसेसर / मेमोरी उपयोग का सबसे खराब स्थिति"।

---

अनुप्रयोग

विशुद्ध रूप से गणितीय निर्माण के रूप में, बिग-ओ अंकन प्रसंस्करण समय और स्मृति के बारे में बात करने तक सीमित नहीं है। आप इसका उपयोग किसी भी चीज के स्पर्शोन्मुख पर चर्चा करने के लिए कर सकते हैं, जहाँ स्केलिंग सार्थक है, जैसे:

• Nएक पार्टी में लोगों के बीच संभावित हैंडशेक की संख्या ( Ɵ(N²)विशेष रूप से N(N-1)/2, लेकिन क्या मायने रखता है कि यह "जैसे तराजू" N²)
• समय के एक समारोह के रूप में कुछ वायरल विपणन को देखा है, जो लोगों की संभावना संभावित संख्या
• कैसे सीपीयू या जीपीयू या कंप्यूटर क्लस्टर में प्रसंस्करण इकाइयों की संख्या के साथ वेबसाइट विलंबता तराजू
• कैसे सीपीयू पर गर्मी उत्पादन तराजू ट्रांजिस्टर गिनती, वोल्टेज, आदि के एक समारोह के रूप में मर जाता है।
• एक एल्गोरिथ्म को इनपुट आकार के एक फ़ंक्शन के रूप में चलाने के लिए कितना समय चाहिए
• एक एल्गोरिथ्म को इनपुट स्पेस के एक फंक्शन के रूप में कितनी जगह की जरूरत होती है

---

उदाहरण

ऊपर के हैंडशेक उदाहरण के लिए, एक कमरे में हर कोई हर किसी के हाथ हिलाता है। कि उदाहरण में, #handshakes ∈ Ɵ(N²)। क्यों?

थोड़ा बैक अप करें: हैंडशेक की संख्या बिल्कुल n-choose-2 है या N*(N-1)/2(N लोगों में से प्रत्येक ने N-1 अन्य लोगों के हाथों को हिलाया है, लेकिन यह डबल-काउंट हैंडशेक 2 से विभाजित होता है):

हालांकि, बहुत बड़ी संख्या में लोगों के लिए, रैखिक शब्द Nबौना है और प्रभावी रूप से 0 के अनुपात में योगदान देता है (चार्ट में: कुल बक्से के विकर्ण पर खाली बक्से का अंश छोटा हो जाता है क्योंकि प्रतिभागियों की संख्या बड़ी हो जाती है)। इसलिए स्केलिंग व्यवहार है order N², या हैंडशेक की संख्या "N। की तरह बढ़ती है"।

#handshakes(N)
────────────── ≈ 1/2
     N²

यह ऐसा है जैसे चार्ट के विकर्ण पर खाली बक्से (एन * (एन -1) / 2 चेकमार्क) भी नहीं थे (एन ² चेकमार्क एसिम्पोटिक रूप से)।

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

    N²/2 - N/2         (N²)/2   N/2         1/2
lim ────────── = lim ( ────── - ─── ) = lim ─── = 1/2
N→∞     N²       N→∞     N²     N²      N→∞  1
                               ┕━━━┙
             this is 0 in the limit of N→∞:
             graph it, or plug in a really large number for N

tl; dr: हैंडशेक की संख्या बड़े मानों के लिए 'x much की तरह दिखती है, कि अगर हमें अनुपात # हैंडशेक / x² लिखना है, तो इस तथ्य की हमें बिल्कुल भी जरूरत नहीं है कि हैंडशेक भी नहीं दिखेंगे। दशमलव में मनमाने ढंग से बड़े समय के लिए।

उदाहरण के लिए x = 1 मिलियन, अनुपात # हैंडशेक / x 0.4: 0.499999 ...

---

बिल्डिंग अंतर्ज्ञान

इससे हम जैसे बयान कर सकते हैं ...

"बड़े पर्याप्त इनपुट के लिए = एन, कोई फर्क नहीं पड़ता कि स्थिर कारक क्या है, अगर मैं इनपुट आकार को दोगुना करता हूं ...

• ... मैं ओ (एन) ("रैखिक समय") एल्गोरिथ्म लेता समय दोगुना करता हूं। "

  एन → (2 एन) = 2 ( एन )

• ... मैं दोहरा वर्ग (चौगुना) समय O (N () ("द्विघात समय") एल्गोरिथ्म लेता हूं। " (उदाहरण के लिए एक समस्या 100x जितनी बड़ी होती है 100 ... = 10000x जितनी लंबी ... संभवतः अस्थिर)

  N → (2N) 4 = 4 ( NN )

• ... I डबल-क्यूबेड (ऑक्टूपल) समय एक O (N () ("क्यूबिक टाइम") एल्गोरिथ्म लेता है। " (उदाहरण के लिए 100x बड़ी समस्या 100³ = 1000000x जितनी लंबी ... बहुत अस्थिर)

  cN c → c (2N) ³ = 8 ( cN ( )

• ... मैं एक ओ (लॉग (एन)) ("लॉगरिदमिक समय") एल्गोरिथ्म लेता समय के लिए एक निश्चित राशि जोड़ देता हूं। " (सस्ता!)

  सी लॉग (एन) → सी लॉग (2 एन) = (सी लॉग (2)) + ( सी लॉग (एन) ) = (निश्चित राशि) + ( सी लॉग (एन) )

• ... मैं समय को O (1) ("निरंतर समय") एल्गोरिथ्म में नहीं बदलता। " (सबसे सस्ता!)

  c * 1 → c * 1

• ... मैं "(मूल रूप से)" ओ (एन लॉग (एन)) एल्गोरिथ्म का समय दोगुना करता हूं। " (काफी सामान्य)।

  यह O (N ^1.000001 ) से कम है , जिसे आप मूल रूप से रैखिक कह सकते हैं

• ... मैं हास्यास्पद रूप से एक O (2 ^N ) ("घातीय समय") एल्गोरिथ्म समय बढ़ाता हूं । " (आप केवल एक इकाई द्वारा समस्या बढ़ाकर समय दोगुना (या तिगुना, आदि) करेंगे)

  2 ^एन → 2 2 ^एन = (4 ^एन ) ............ एक और रास्ता ...... 2 ^एन → 2 ^{एन + 1} = 2 ^एन 2 ¹ 2 2 ^एन

[गणितीय रूप से इच्छुक के लिए, आप नाबालिगों के लिए बिगाड़ने वाले माउस पर माउस ले जा सकते हैं]

(क्रेडिट के साथ https://stackoverflow.com/a/487292/711085 )

(तकनीकी रूप से स्थिर कारक शायद कुछ और गूढ़ उदाहरणों में बात कर सकता है, लेकिन मैंने ऊपर की चीज़ों को संक्षिप्त कर दिया है (जैसे कि लॉग (N) में) ऐसा नहीं है)

ये विकास के ब्रेड-एंड-बटर ऑर्डर हैं जो प्रोग्रामर और एप्लाइड कंप्यूटर वैज्ञानिक संदर्भ बिंदुओं के रूप में उपयोग करते हैं। वे हर समय ये देखते हैं। (इसलिए जब आप तकनीकी रूप से सोच सकते हैं "इनपुट दोगुना करने से O (algorithmN) एल्गोरिथ्म 1.414 गुना धीमा हो जाता है," इसके बारे में सोचना बेहतर है "यह लॉगरिदमिक से भी बदतर है लेकिन रैखिक से बेहतर है"।

---

लगातार कारक

आमतौर पर, हमें परवाह नहीं है कि विशिष्ट स्थिर कारक क्या हैं, क्योंकि वे कार्य के बढ़ने के तरीके को प्रभावित नहीं करते हैं। उदाहरण के लिए, दो एल्गोरिदम O(N)को पूरा होने में समय लग सकता है , लेकिन एक दूसरे की तुलना में दो गुना धीमा हो सकता है। हम आम तौर पर बहुत ज्यादा परवाह नहीं करते हैं जब तक कि कारक बहुत बड़ा न हो, क्योंकि ट्रिकी व्यवसाय बहुत अच्छा है ( जब समय से पहले अनुकूलन होता है? ); एक बेहतर बिग-ओ के साथ एक एल्गोरिथ्म को चुनने का मात्र कार्य अक्सर परिमाण के आदेशों द्वारा प्रदर्शन में सुधार करेगा।

कुछ asymptotically बेहतर एल्गोरिदम (जैसे एक गैर-तुलनात्मक O(N log(log(N)))प्रकार) में इतना बड़ा एक स्थिर कारक (जैसे 100000*N log(log(N))), या ओवरहेड हो सकता है जो O(N log(log(N)))एक छिपे हुए की तरह अपेक्षाकृत बड़ा है + 100*N, कि वे "बड़े डेटा" पर भी शायद ही कभी उपयोग करने लायक हैं।

---

क्यों ओ (एन) कभी-कभी सबसे अच्छा होता है जो आप कर सकते हैं, अर्थात हमें डेटास्ट्रक्चर की आवश्यकता क्यों है

O(N)एल्गोरिदम कुछ अर्थ में "सर्वश्रेष्ठ" एल्गोरिदम हैं यदि आपको अपने सभी डेटा को पढ़ने की आवश्यकता है। डेटा का एक गुच्छा पढ़ने का बहुत ही कार्य एक O(N)ऑपरेशन है। इसे मेमोरी में लोड करना आमतौर पर O(N)(या यदि आपके पास हार्डवेयर समर्थन है, या कोई समय नहीं है, यदि आप डेटा पहले से पढ़ चुके हैं)। हालाँकि, यदि आप डेटा के प्रत्येक टुकड़े (या यहाँ तक कि डेटा के हर दूसरे टुकड़े) को छूते हैं या देखते हैं , तो आपके एल्गोरिथ्म को O(N)इस खोज को करने में समय लगेगा । कोई फर्क नहीं पड़ता कि आपका वास्तविक एल्गोरिथ्म कितना समय लेता है, यह कम से कम होगा O(N)क्योंकि यह उस समय को सभी डेटा को देख रहा था।

लेखन के बहुत कार्य के लिए भी यही कहा जा सकता है । सभी एल्गोरिदम जो एन चीजों को प्रिंट करते हैं, उन्हें एन समय लगेगा क्योंकि आउटपुट कम से कम है (उदाहरण के लिए एन प्लेइंग कार्ड्स का एक सेट फैक्टरियल है O(N!)) सभी क्रमपरिवर्तन (तरीके को पुनर्व्यवस्थित करने के लिए) प्रिंट कर रहा है:) ।

यह डेटा संरचनाओं के उपयोग को प्रेरित करता है : एक डेटा संरचना को डेटा को केवल एक बार (आमतौर पर O(N)समय) पढ़ने की आवश्यकता होती है , साथ ही प्रीप्रोसेसिंग की कुछ मनमानी राशि (जैसे O(N)या O(N log(N))या O(N²)) जिसे हम छोटा रखने की कोशिश करते हैं। इसके बाद, डेटा संरचना (प्रविष्टि / विलोपन / आदि) को संशोधित करने और डेटा पर प्रश्न बनाने में बहुत कम समय लगता है, जैसे O(1)या O(log(N))। फिर आप बड़ी संख्या में क्वेरी करने के लिए आगे बढ़ते हैं! सामान्य तौर पर, जितना अधिक काम आप समय से पहले करने को तैयार होंगे, उतना ही कम काम आपको बाद में करना होगा।

उदाहरण के लिए, मान लें कि आपके पास लाखों सड़क खंडों के अक्षांश और देशांतर निर्देशांक हैं और सभी सड़क चौराहों को खोजना चाहते हैं।

• Naive विधि: यदि आपके पास एक सड़क चौराहे के निर्देशांक हैं, और पास की सड़कों की जांच करना चाहते हैं, तो आपको हर बार लाखों सेगमेंट से गुजरना होगा, और आसन्न के लिए हर एक की जांच करनी होगी।
• यदि आपको केवल एक बार ऐसा करने की आवश्यकता है, तो काम की भोली पद्धति को O(N)केवल एक बार करना एक समस्या नहीं होगी , लेकिन यदि आप इसे कई बार करना चाहते हैं (इस मामले में, Nसमय, प्रत्येक खंड के लिए एक बार), हम O(N²)काम करना है , या 1000000² = 1000000000000 संचालन करना है। अच्छा नहीं है (एक आधुनिक कंप्यूटर प्रति सेकंड एक बिलियन ऑपरेशन कर सकता है)।
• यदि हम एक हैश टेबल (एक त्वरित गति लुकअप तालिका, जिसे हैशमैप या शब्दकोश के रूप में भी जाना जाता है) नामक एक सरल संरचना का उपयोग करते हैं, तो हम O(N)समय में सब कुछ प्रीप्रोसेस करके एक छोटी सी लागत का भुगतान करते हैं । इसके बाद, इसकी कुंजी द्वारा किसी चीज़ को देखने के लिए औसतन केवल निरंतर समय लगता है (इस मामले में, हमारी कुंजी अक्षांश और देशांतर निर्देशांक है, एक ग्रिड में गोल है; हम आसन्न ग्रिड की खोज करते हैं जिनमें से सिर्फ 9 हैं, जो एक है लगातार)।
• हमारा काम O(N²)एक प्रबंधनीय से एक प्रबंधनीय के लिए चला गया O(N), और हम सभी को एक हैश टेबल बनाने के लिए मामूली लागत का भुगतान करना पड़ा।
• सादृश्य : इस विशेष मामले में सादृश्य एक पहेली है: हमने एक डेटा संरचना बनाई जो डेटा की कुछ संपत्ति का शोषण करती है। यदि हमारे सड़क खंड पहेली टुकड़ों की तरह हैं, तो हम उन्हें रंग और पैटर्न से मेल खाते हैं। फिर हम बाद में अतिरिक्त काम करने से बचने के लिए इसका फायदा उठाते हैं (पहेली के टुकड़ों को एक दूसरे से नहीं, बल्कि हर एक पहेली टुकड़े की तरह)।

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

---

व्यावहारिक उदाहरण: कोडिंग करते समय वृद्धि के आदेशों को देखना

स्पर्शोन्मुख संकेतन, इसके मूल में, प्रोग्रामिंग से काफी अलग है। असममित संकेतन यह सोचने के लिए एक गणितीय ढांचा है कि चीजों को किस तरह से स्केल किया जाता है और कई अलग-अलग क्षेत्रों में इसका उपयोग किया जा सकता है। उस ने कहा ... यह है कि आप कोडिंग को स्पर्शोन्मुख संकेतन कैसे लागू करते हैं।

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

(यहां, xs काम की निरंतर-समय इकाइयों, प्रोसेसर निर्देश, दुभाषिया opcodes का प्रतिनिधित्व करते हैं, जो भी हो)

for(i=0; i<A; i++)        // A * ...
    some O(1) operation     // 1

--> A*1 --> O(A) time

visualization:

|<------ A ------->|
1 2 3 4 5 x x ... x

other languages, multiplying orders of growth:
  javascript, O(A) time and space
    someListOfSizeA.map((x,i) => [x,i])               
  python, O(rows*cols) time and space
    [[r*c for c in range(cols)] for r in range(rows)]

उदाहरण 2:

for every x in listOfSizeA:   // A * (...
    some O(1) operation         // 1
    some O(B) operation         // B
    for every y in listOfSizeC: // C * (...
        some O(1) operation       // 1))

--> O(A*(1 + B + C))
    O(A*(B+C))        (1 is dwarfed)

visualization:

|<------ A ------->|
1 x x x x x x ... x

2 x x x x x x ... x ^
3 x x x x x x ... x |
4 x x x x x x ... x |
5 x x x x x x ... x B  <-- A*B
x x x x x x x ... x |
................... |
x x x x x x x ... x v

x x x x x x x ... x ^
x x x x x x x ... x |
x x x x x x x ... x |
x x x x x x x ... x C  <-- A*C
x x x x x x x ... x |
................... |
x x x x x x x ... x v

उदाहरण 3:

function nSquaredFunction(n) {
    total = 0
    for i in 1..n:        // N *
        for j in 1..n:      // N *
            total += i*k      // 1
    return total
}
// O(n^2)

function nCubedFunction(a) {
    for i in 1..n:                // A *
        print(nSquaredFunction(a))  // A^2
}
// O(a^3)

यदि हम कुछ जटिल करते हैं, तो आप अभी भी कल्पना कर सकते हैं कि क्या हो रहा है:

for x in range(A):
    for y in range(1..x):
        simpleOperation(x*y)

x x x x x x x x x x |
x x x x x x x x x   |
x x x x x x x x     |
x x x x x x x       |
x x x x x x         |
x x x x x           |
x x x x             |
x x x               |
x x                 |
x___________________|

यहाँ, सबसे छोटी पहचान योग्य रूपरेखा जो आप आकर्षित कर सकते हैं वह है; एक त्रिकोण एक दो आयामी आकार (0.5 ए ^ 2) है, जैसे एक वर्ग एक दो आयामी आकार (ए ^ 2) है; यहां दो का निरंतर कारक दोनों के बीच स्पर्शोन्मुख अनुपात में रहता है, हालांकि, हम इसे सभी कारकों की तरह अनदेखा करते हैं ... (इस तकनीक में कुछ दुर्भाग्यपूर्ण बारीकियां हैं जो मैं यहां नहीं जाता हूं; यह आपको भ्रमित कर सकती है।)

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

यहाँ एक और चीज़ है जिसे हम नेत्रहीन पहचान सकते हैं:

<----------------------------- N ----------------------------->
x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
x x x x x x x x x x x x x x x x
x x x x x x x x
x x x x
x x
x

हम इसे फिर से व्यवस्थित कर सकते हैं और देख सकते हैं कि यह O (N) है:

<----------------------------- N ----------------------------->
x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x x
x x x x x x x x x x x x x x x x|x x x x x x x x|x x x x|x x|x

या हो सकता है कि आप O (N * log (N)) कुल समय के लिए लॉग (N) डेटा पास करते हैं:

   <----------------------------- N ----------------------------->
 ^  x x x x x x x x x x x x x x x x|x x x x x x x x x x x x x x x x
 |  x x x x x x x x|x x x x x x x x|x x x x x x x x|x x x x x x x x
lgN x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x|x x x x
 |  x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x|x x
 v  x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x|x

असंबंधित लेकिन फिर से उल्लेख के लायक: यदि हम एक हैश करते हैं (जैसे एक शब्दकोश / हैशटेबल लुकअप), तो यह ओ (1) का एक कारक है। यह बहुत तेज है।

[myDictionary.has(x) for x in listOfSizeA]
 \----- O(1) ------/    

--> A*1 --> O(A)

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

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

---

परिशोधित और औसत-मामले की जटिलता

"परिशोधित" और / या "औसत मामला" की अवधारणा भी है (ध्यान दें कि ये अलग हैं)।

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

Amortized Worst-Case : कुछ डेटा संरचनाओं में सबसे खराब स्थिति हो सकती है जो बड़ी है, लेकिन गारंटी है कि यदि आप इनमें से कई ऑपरेशन करते हैं, तो आपके द्वारा किए जाने वाले काम की औसत राशि, खराब-केस से बेहतर होगी। उदाहरण के लिए, आपके पास एक डेटा संरचना हो सकती है जो सामान्य रूप से निरंतर O(1)समय लेती है । हालाँकि, कभी-कभी यह 'हिचकी' लेगा और O(N)एक यादृच्छिक ऑपरेशन के लिए समय लेगा , क्योंकि शायद इसे कुछ बहीखाता पद्धति या कचरा संग्रह या कुछ और करने की ज़रूरत है ... लेकिन यह आपसे वादा करता है कि यदि यह हिचकी करता है, तो यह फिर से एन के लिए हिचकी नहीं होगा। अधिक संचालन। सबसे खराब स्थिति की लागत अभी भी O(N)प्रति ऑपरेशन है, लेकिन कई रन से अधिक परिशोधन लागत हैO(N)/N =O(1)प्रति ऑपरेशन। क्योंकि बड़े ऑपरेशन पर्याप्त रूप से दुर्लभ हैं, कभी-कभार काम की भारी मात्रा को बाकी कार्यों के साथ स्थिर कारक के रूप में मिश्रण करने के लिए माना जा सकता है। हम कहते हैं कि काम पर्याप्त रूप से बड़ी संख्या में "amortized" है कि यह asymptotically गायब हो जाता है।

परिशोधित विश्लेषण के लिए सादृश्य:

आप एक कार चलाते हैं। कभी-कभी, आपको गैस स्टेशन पर जाने के लिए 10 मिनट खर्च करने की आवश्यकता होती है और फिर गैस के साथ टैंक को रीफिलिंग करने में 1 मिनट का समय लगता है। यदि आपने हर बार अपनी कार के साथ कहीं भी गए (गैस स्टेशन पर 10 मिनट ड्राइविंग करते हुए, गैलन के एक अंश को भरने में कुछ सेकंड खर्च करें), तो यह बहुत अक्षम होगा। लेकिन अगर आप हर कुछ दिनों में एक बार टैंक को भरते हैं, तो गैस स्टेशन पर ड्राइविंग में बिताए गए 11 मिनट पर्याप्त मात्रा में यात्राओं पर "amortized" होते हैं, कि आप इसे अनदेखा कर सकते हैं और दिखावा कर सकते हैं कि आपकी सभी यात्राएं शायद 5% लंबी थीं।

औसत-मामले और amortized सबसे खराब स्थिति के बीच तुलना:

• औसत-मामला: हम अपने इनपुट के बारे में कुछ धारणाएँ बनाते हैं; यानी यदि हमारे इनपुट में अलग-अलग संभावनाएं हैं, तो हमारे आउटपुट / रनटाइम में अलग-अलग संभावनाएं होंगी (जो हम औसत लेते हैं)। आमतौर पर, हम मानते हैं कि हमारे इनपुट सभी समान रूप से समान (समान संभावना) हैं, लेकिन अगर वास्तविक-दुनिया के इनपुट "औसत इनपुट" की हमारी मान्यताओं को फिट नहीं करते हैं, तो औसत आउटपुट / रनटाइम गणना बेकार हो सकती है। यदि आप समान रूप से यादृच्छिक इनपुट का अनुमान लगाते हैं, तो इस बारे में सोचना उपयोगी है!
• अमूर्त सबसे खराब स्थिति: यदि आप एक परिशोधित सबसे खराब स्थिति डेटा संरचना का उपयोग करते हैं, तो प्रदर्शन को सबसे खराब स्थिति के भीतर होने की गारंटी दी जाती है ... आखिरकार (भले ही इनपुट एक दुष्ट दानव द्वारा चुना जाता है जो सब कुछ जानता है और कोशिश कर रहा है आप पर शिकंजा)। आमतौर पर, हम इसका उपयोग एल्गोरिदम का विश्लेषण करने के लिए करते हैं जो अप्रत्याशित बड़ी हिचकी के साथ प्रदर्शन में बहुत 'तड़का हुआ' हो सकता है, लेकिन समय के साथ-साथ अन्य एल्गोरिदम का भी प्रदर्शन करता है। (हालाँकि जब तक आपकी डेटा संरचना में बहुत सारे उत्कृष्ट कार्यों के लिए ऊपरी सीमा नहीं होती है, यह उस पर शिथिलता करने के लिए तैयार है, एक दुष्ट हमलावर शायद आपको एक बार में शिथिल किए गए काम की अधिकतम मात्रा पर पकड़ने के लिए मजबूर कर सकता है।

हालांकि, यदि आप किसी हमलावर के बारे में उचित रूप से चिंतित हैं, तो परिशोधन और औसत-मामले के अलावा चिंता करने के लिए कई अन्य एल्गोरिदमिक हमले वैक्टर हैं।)

औसत-केस और परिशोधन दोनों ही दिमाग में स्केलिंग के साथ सोचने और डिजाइन करने के लिए अविश्वसनीय रूप से उपयोगी उपकरण हैं।

( औसत मामले और परिशोधित विश्लेषण के बीच अंतर देखें, अगर इस उप-विषय में रुचि है।)

---

बहुआयामी बड़ा-ओ

अधिकांश समय, लोगों को यह महसूस नहीं होता है कि काम पर एक से अधिक चर हैं। उदाहरण के लिए, एक स्ट्रिंग-खोज एल्गोरिथ्म में, आपके एल्गोरिथ्म में समय लग सकता है O([length of text] + [length of query]), अर्थात यह दो चर जैसे रैखिक है O(N+M)। अन्य अधिक भोले एल्गोरिदम O([length of text]*[length of query])या हो सकते हैं O(N*M)। कई चर को अनदेखा करना एल्गोरिथ्म विश्लेषण में मेरे द्वारा देखे जाने वाले सबसे आम निरीक्षणों में से एक है, और एल्गोरिथ्म को डिज़ाइन करते समय आपको बाधा पहुँचा सकता है।

---

पूरी कहानी

ध्यान रखें कि बड़ा-ओ पूरी कहानी नहीं है। आप कैशिंग का उपयोग करके कुछ एल्गोरिदम को तेजी से बढ़ा सकते हैं, उन्हें कैश-विस्मृत कर सकते हैं, डिस्क के बजाय रैम के साथ काम करके, समानांतर उपयोग करके या समय से पहले काम करने से बाधाओं से बच सकते हैं - ये तकनीक अक्सर ऑर्डर-ऑफ-ग्रोथ से स्वतंत्र होती हैं "बिग-ओ" अंकन, हालांकि आप अक्सर समानांतर एल्गोरिदम के बड़े-ओ अंकन में कोर की संख्या देखेंगे।

यह भी ध्यान रखें कि आपके कार्यक्रम की छिपी बाधाओं के कारण, आप वास्तव में स्पर्शोन्मुख व्यवहार के बारे में परवाह नहीं कर सकते हैं। आप उदाहरण के लिए बंधी हुई संख्या के साथ काम कर सकते हैं:

• यदि आप 5 तत्वों की तरह कुछ छांट रहे हैं, तो आप शीघ्र O(N log(N))एस्कॉर्ट का उपयोग नहीं करना चाहते हैं ; आप प्रविष्टि सॉर्ट का उपयोग करना चाहते हैं, जो छोटे इनपुट पर अच्छा प्रदर्शन करने के लिए होता है। ये स्थितियां अक्सर विभाजित और विजेता एल्गोरिदम में सामने आती हैं, जहां आप समस्या को छोटे और छोटे उपप्रोब्लेम्स में विभाजित करते हैं, जैसे कि पुनरावर्ती छंटाई, तेजी से फूरियर रूपांतरण, या मैट्रिक्स गुणन।
• यदि कुछ छिपे हुए तथ्य के कारण कुछ मान प्रभावी रूप से बंधे हुए हैं (उदाहरण के लिए औसत मानव नाम को शायद ४० अक्षरों में बांधा गया है, और मानव आयु को लगभग १५० पर बांधा गया है)। आप प्रभावी रूप से शर्तों को स्थिर बनाने के लिए अपने इनपुट पर सीमाएं भी लगा सकते हैं।

व्यवहार में, यहां तक ​​कि एल्गोरिदम के बीच जो समान या समान स्पर्शोन्मुख प्रदर्शन होता है, उनकी सापेक्ष योग्यता वास्तव में अन्य चीजों से प्रेरित हो सकती है, जैसे: अन्य प्रदर्शन कारक (क्विकर और मर्जर्ट दोनों हैं O(N log(N)), लेकिन एस्कॉर्ट सीपीयू कैश का लाभ उठाते हैं); गैर-निष्पादन विचार, जैसे कार्यान्वयन में आसानी; एक पुस्तकालय उपलब्ध है या नहीं, और पुस्तकालय कितना प्रतिष्ठित और रखरखाव योग्य है।

कार्यक्रम 500MHz कंप्यूटर बनाम 2GHz कंप्यूटर पर भी धीमी गति से चलेंगे। हम वास्तव में इसे संसाधन सीमा के हिस्से के रूप में नहीं मानते हैं, क्योंकि हम मशीन संसाधनों (जैसे प्रति घड़ी चक्र) के मामले में स्केलिंग के बारे में सोचते हैं, वास्तविक प्रति के अनुसार नहीं। हालांकि, इसी तरह की चीजें हैं जो प्रदर्शन को गुप्त रूप से प्रभावित कर सकती हैं, जैसे कि आप अनुकरण के तहत चल रहे हैं, या कंपाइलर अनुकूलित कोड है या नहीं। ये कुछ बुनियादी ऑपरेशनों को (यहां तक ​​कि एक-दूसरे के सापेक्ष भी) लंबे समय तक ले सकते हैं, या यहां तक ​​कि कुछ ऑपरेशनों को (यहां तक ​​कि एक-दूसरे के सापेक्ष भी) धीमा या धीमा कर सकते हैं। विभिन्न कार्यान्वयन और / या पर्यावरण के बीच प्रभाव छोटा या बड़ा हो सकता है। क्या आप उस छोटे से अतिरिक्त काम को निकालने के लिए भाषाओं या मशीनों को स्विच करते हैं? यह सौ अन्य कारणों पर निर्भर करता है (आवश्यकता, कौशल, सहकर्मी, प्रोग्रामर उत्पादकता,

उपरोक्त मुद्दों, जैसे कि प्रोग्रामिंग भाषा का उपयोग करने के विकल्प के प्रभाव को लगभग स्थिर कारक के रूप में कभी नहीं माना जाता है (न ही उन्हें करना चाहिए); अभी तक किसी को उनके बारे में पता होना चाहिए क्योंकि कभी-कभी (हालांकि शायद ही कभी) वे चीजों को प्रभावित कर सकते हैं। उदाहरण के लिए cpython में, मूल प्राथमिकता कतार कार्यान्वयन asymptotically गैर-इष्टतम ( प्रविष्टि या खोज-मिनट की आपकी पसंद के O(log(N))बजाय O(1)) है; क्या आप अन्य कार्यान्वयन का उपयोग करते हैं? शायद नहीं, चूंकि सी कार्यान्वयन शायद तेज है, और संभवतः अन्य समान मुद्दे कहीं और हैं। ट्रेडऑफ़ हैं; कभी-कभी वे मायने रखते हैं और कभी-कभी वे नहीं करते हैं।

---

( संपादित करें : "सादा अंग्रेजी" स्पष्टीकरण यहाँ समाप्त होता है।)

मठ का नशा

पूर्णता के लिए, बिग-ओ नोटेशन की सटीक परिभाषा निम्नानुसार है: f(x) ∈ O(g(x))इसका मतलब है कि "एफ असमान रूप से ऊपरी-बंधे हैं जो * कॉन्स्टेंस *": एक्स के कुछ परिमित मूल्य के नीचे की हर चीज को अनदेखा करते हुए, एक निरंतर मौजूद है |f(x)| ≤ const * |g(x)|। (अन्य प्रतीक इस प्रकार हैं: जैसे Oसाधन means, Ωमतलब There। इसमें लोअरकेस वेरिएंट हैं: oमतलब <और ( ωमतलब>।) का f(x) ∈ Ɵ(g(x))अर्थ है दोनों f(x) ∈ O(g(x))और f(x) ∈ Ω(g(x))(ऊपरी और निचले-जी द्वारा बाध्य): इसमें कुछ स्थिरांक मौजूद हैं जैसे कि f हमेशा के बीच "बैंड" में झूठ होगा const1*g(x)और const2*g(x)। यह सबसे मजबूत स्पर्शोन्मुख कथन है जिसे आप बना सकते हैं और लगभग बराबर कर सकते हैं== । (क्षमा करें, मैंने स्पष्टता के लिए अब तक निरपेक्ष-मूल्य प्रतीकों के उल्लेख में देरी करने के लिए चुना; विशेष रूप से इसलिए क्योंकि मैंने कभी भी नकारात्मक मूल्यों को कंप्यूटर विज्ञान के संदर्भ में नहीं देखा है।)

लोग अक्सर उपयोग करेंगे = O(...), जो शायद अधिक सही 'कॉम्प-साइंस' संकेतन है, और उपयोग करने के लिए पूरी तरह से वैध है; "f = O (...)" को पढ़ा जाता है "f is order ... / f is xxx-bounded by ..." और के रूप में माना जाता है "च कुछ अभिव्यक्ति है जिसकी विषमताएं हैं ..."। मुझे अधिक कठोर का उपयोग करना सिखाया गया था ∈ O(...)। ∈का अर्थ है "एक तत्व है" (अभी भी पहले की तरह पढ़ा जाता है)। इस विशेष मामले में, O(N²)जैसे {तत्व शामिल हैं 2 N², 3 N², 1/2 N², 2 N² + log(N), - N² + N^1.9, ...} और असीम बड़ी है, लेकिन यह अभी भी एक सेट है।

O और O सममित नहीं हैं (n = O (n,), लेकिन n not O (n) नहीं है), लेकिन, सममित है, और (चूंकि ये संबंध सभी सकर्मक और प्रतिवर्त हैं) Ɵ, इसलिए, सममित और सकर्मक और सकर्मक और प्रतिवर्त है , और इसलिए सभी वर्गों के सेट को समतुल्यता वर्गों में विभाजित करता है । एक समतुल्य वर्ग चीजों का एक समूह है जिसे हम समान मानते हैं। यह कहना है कि, आप जिस किसी भी फ़ंक्शन के बारे में सोच सकते हैं, आप कक्षा के एक कैनोनिकल / अद्वितीय 'विषम प्रतिनिधि' (आमतौर पर सीमा ... मुझे लगता है ) ले सकते हैं; जैसे आप सभी पूर्णांकों को ऑड्स या इवेंस में समूहित कर सकते हैं, वैसे ही आप सभी कार्यों को-x-ish, log (x) ^ 2-ish आदि के साथ समूहित कर सकते हैं ... मूल रूप से छोटे शब्दों को अनदेखा करके (लेकिन कभी-कभी आप के साथ फंस सकते हैं) अधिक जटिल कार्य जो स्वयं के लिए अलग कक्षाएं हैं)।

=अंकन अधिक आम एक हो सकता है और यहां तक कि विश्व प्रसिद्ध कंप्यूटर वैज्ञानिकों के कागजात में प्रयोग किया जाता है। इसके अतिरिक्त, यह अक्सर ऐसा होता है कि आकस्मिक सेटिंग में, लोग कहेंगे O(...)जब उनका मतलब होगा Ɵ(...); यह तकनीकी रूप से सच है क्योंकि चीजों Ɵ(exactlyThis)का सेट एक सबसेट है O(noGreaterThanThis)... और यह टाइप करना आसान है। ;-)

Comments

एक उत्कृष्ट गणितीय उत्तर, लेकिन ओपी ने एक सादा अंग्रेजी उत्तर मांगा। गणितीय विवरण के इस स्तर के उत्तर को समझने की आवश्यकता नहीं है, हालांकि लोगों के लिए विशेष रूप से गणितीय रूप से यह समझ में आता है कि यह "सादे अंग्रेजी" की तुलना में समझने में बहुत सरल हो सकता है। हालांकि ओपी ने बाद के लिए पूछा।

— एल जोर्को

संभवतः इस प्रश्न के उत्तर में ओपी के अलावा अन्य लोगों की रुचि हो सकती है। साइट का मार्गदर्शक सिद्धांत नहीं है?

— केसी

हालांकि मैं यह देख सकता हूं कि लोग मेरे उत्तर को क्यों रोक सकते हैं और सोचते हैं कि यह बहुत ज्यादा मैथी है (विशेषकर "गणित नया सादा अंग्रेजी है" स्नाइड टिप्पणी, हटाए जाने के बाद से), मूल प्रश्न बिग-ओ के बारे में पूछता है जो कार्यों के बारे में है, इसलिए मैं स्पष्ट रूप से होने की कोशिश करते हैं और इस तरह से कार्यों के बारे में बात करते हैं जो सादे-अंग्रेजी अंतर्ज्ञान को पूरक करते हैं। यहाँ के गणित को अक्सर देखा जा सकता है, या एक हाईस्कूल गणित पृष्ठभूमि के साथ समझा जा सकता है। मुझे लगता है कि लोग हालांकि, मैथ एडेंडा को अंत में देख सकते हैं, और मान लेते हैं कि यह उत्तर का हिस्सा है, जब यह देखने के लिए कि वास्तविक गणित कैसा दिखता है।

— निंजाजेको

यह एक शानदार जवाब है; सबसे बेहतर वोटों वाले आईएमओ से बेहतर। "ओ" के बाद कोष्ठक में अभिव्यक्तियों को समझने के लिए जो आवश्यक है, उससे परे "गणित" की आवश्यकता नहीं है, जो कि किसी भी उदाहरण का उपयोग करने वाला कोई उचित स्पष्टीकरण नहीं है।

— डेव अब्राहम

"f (x) (O (अपरबाउंड) का अर्थ है" f "इनबाउंड" इनबाउंड "की तुलना में तेजी से नहीं बढ़ता है, इन तीनों को सीधे शब्दों में कहा जाता है, लेकिन गणितीय रूप से बड़े ओह, थीटा और ओमेगा के उचित स्पष्टीकरण सुनहरे हैं। उन्होंने मुझे सादे अंग्रेजी में इस बात का वर्णन किया कि 5 विभिन्न स्रोत जटिल गणितीय अभिव्यक्तियों को लिखे बिना मुझे अनुवाद करने के लिए प्रतीत नहीं हो सकते। धन्यवाद दोस्त! :)

— टाइमब्रम

Answer 4

EDIT: त्वरित ध्यान दें, यह लगभग निश्चित रूप से थीटा संकेतन के साथ बिग ओ अंकन (जो कि एक ऊपरी बाध्य है) है (जो ऊपरी और निचले दोनों प्रकार की सीमा है)। मेरे अनुभव में यह वास्तव में गैर-शैक्षणिक सेटिंग्स में चर्चा का विषय है। किसी भी भ्रम के कारण क्षमा याचना।

एक वाक्य में: जैसे-जैसे आपकी नौकरी का आकार बढ़ता जाता है, इसे पूरा करने में कितना समय लगता है?

जाहिर है कि इनपुट के रूप में केवल "आकार" और आउटपुट के रूप में "लिया गया समय" का उपयोग किया जा रहा है - यदि आप स्मृति उपयोग आदि के बारे में बात करना चाहते हैं तो यही विचार लागू होता है।

यहां एक उदाहरण है जहां हमारे पास एन टी-शर्ट है जिसे हम सूखना चाहते हैं। हम इसे सुखाने की स्थिति में प्राप्त करने के लिए अविश्वसनीय रूप से जल्दी मान लेंगे (यानी मानव संपर्क नगण्य है)। असल जिंदगी में ऐसा नहीं है, बिल्कुल ...

• बाहर एक वाशिंग लाइन का उपयोग करना: यह मानते हुए कि आपके पास एक बड़ी बड़ी यार्ड है, ओ (1) समय में सूख जाता है। हालाँकि आपके पास इसका बहुत हिस्सा है, इसे सूरज और ताज़ी हवा मिलेगी, इसलिए आकार सूखने के समय को प्रभावित नहीं करता है।

• टंबल ड्रायर का उपयोग करना: आप प्रत्येक लोड में 10 शर्ट डालते हैं, और फिर वे एक घंटे बाद करते हैं। (यहां वास्तविक संख्या पर ध्यान न दें - वे अप्रासंगिक हैं।) इसलिए 50 शर्ट सूखने में 10 शर्ट सूखने में लगभग 5 गुना समय लगता है ।

• सब कुछ हवा में उड़ने वाली अलमारी में रखना: यदि हम सब कुछ एक बड़े ढेर में डालते हैं और बस सामान्य गर्मी करते हैं, तो मध्य शर्ट को सूखने में लंबा समय लगेगा। मैं विस्तार से अनुमान नहीं लगाना चाहूंगा, लेकिन मुझे संदेह है कि यह कम से कम हे (एन ^ 2) है - जैसा कि आप वॉश लोड बढ़ाते हैं, सुखाने का समय तेजी से बढ़ता है।

"बिग ओ" संकेतन का एक महत्वपूर्ण पहलू यह है कि यह नहीं कहता कि कौन सा एल्गोरिथ्म किसी दिए गए आकार के लिए तेज़ होगा। हैशटेबल (स्ट्रिंग कुंजी, पूर्णांक मान) बनाम जोड़े की एक सरणी (स्ट्रिंग, पूर्णांक) लें। क्या स्ट्रिंग पर आधारित हैशटेबल या एरे में एक तत्व को खोजने के लिए यह तेजी से है? (अर्थात सरणी के लिए, "पहले तत्व को ढूंढें जहां स्ट्रिंग भाग दी गई कुंजी से मेल खाती है।") हैशटेबल्स को आमतौर पर परिशोधित किया जाता है (~ = "औसतन") ओ (1) - एक बार जब वे सेट हो जाते हैं, तो इसके बारे में लेना चाहिए 100 एंट्री टेबल में एंट्री खोजने के लिए उसी समय जैसे कि 1,000,000 एंट्री टेबल में होता है। सरणी में एक तत्व ढूँढना (सूचकांक के बजाय सामग्री के आधार पर) रैखिक है, अर्थात ओ (एन) - औसतन, आपको आधे प्रविष्टियों को देखना होगा।

क्या यह लुकअप के लिए किसी हैशटेबल को सरणी से तेज बनाता है? जरुरी नहीं। यदि आपको प्रविष्टियों का एक बहुत छोटा संग्रह मिला है, तो एक सरणी अच्छी तरह से तेज़ हो सकती है - आप उस समय के सभी स्ट्रिंग्स की जांच करने में सक्षम हो सकते हैं, जिसे आप जिस व्यक्ति को देख रहे हैं उसके हैशकोड की गणना करने में समय लगता है। जैसे-जैसे डेटा सेट बड़ा होता जाता है, वैसे-वैसे हैशटेबल एरे को हरा देगा।

Comments

एक हैशटेबल को वास्तविक सरणी के सूचकांक (कार्यान्वयन के आधार पर) की गणना करने के लिए एक एल्गोरिथ्म चलाने की आवश्यकता होती है। और एक सरणी में सिर्फ O (1) है क्योंकि यह सिर्फ एक एड्रेस है। लेकिन इस सवाल से कोई लेना-देना नहीं है, सिर्फ एक :) :)

— फिलिप एकबर्ग

मुझे लगता है कि सवाल के साथ जोंस की व्याख्या बहुत ज्यादा है। यह ठीक है कि कोई इसे कुछ मम को कैसे समझा सकता है, और वह अंततः इसे समझेगी मुझे लगता है :) मुझे कपड़े का उदाहरण पसंद है (विशेष रूप से अंतिम, जहां यह जटिलता के घातीय विकास को समझाता है)

— जोहान्स स्काउब - लीब

फ़िलिप: मैं सूचकांक द्वारा किसी सरणी के पते के बारे में बात नहीं कर रहा हूँ, मैं एक सरणी में एक मिलान प्रविष्टि खोजने के बारे में बात कर रहा हूँ। क्या आप उत्तर को फिर से पढ़ सकते हैं और देख सकते हैं कि क्या यह अभी भी अस्पष्ट है?

— जॉन स्कीट

@ फिलिप एकबर्ग मुझे लगता है कि आप एक डायरेक्ट-एड्रेस टेबल के बारे में सोच रहे हैं जहाँ प्रत्येक इंडेक्स मैप्स की कुंजी में सीधे होता है इसलिए O (1) है, लेकिन मेरा मानना ​​है कि जॉन कुंजी / वैल जोड़े के एक अनसुने सरणी के बारे में बात कर रहे हैं जिसे आपको खोजना होगा रैखिक रूप से।

— ljs

@ आरबीटी: नहीं, यह बाइनरी लुक-अप नहीं है। यह सही हैश बाल्टी को तुरंत प्राप्त कर सकता है , बस हैश कोड से बाल्टी इंडेक्स में परिवर्तन के आधार पर। उसके बाद, बाल्टी में सही हैश कोड खोजना रेखीय हो सकता है या यह एक द्विआधारी खोज हो सकता है ... लेकिन उस समय तक आप शब्दकोश के कुल आकार के बहुत छोटे अनुपात में नीचे होंगे।

— जॉन स्कीट

Answer 5

बिग ओ एक फ़ंक्शन के विकास व्यवहार पर एक ऊपरी सीमा का वर्णन करता है, उदाहरण के लिए एक प्रोग्राम का रनटाइम, जब इनपुट बड़े हो जाते हैं।

उदाहरण:

• O (n): यदि मैं इनपुट आकार को दोगुना करता हूं तो रनटाइम दोगुना हो जाता है

• O (n ² ): यदि इनपुट आकार रनटाइम क्वाड्रुपल्स को दोगुना कर देता है

• O (लॉग एन): यदि इनपुट का आकार दोगुना हो जाता है तो रनटाइम एक से बढ़ जाता है

• O (2 ⁿ ): यदि इनपुट आकार एक से बढ़ता है, तो रनटाइम दोगुना हो जाता है

इनपुट आकार आमतौर पर इनपुट को दर्शाने के लिए आवश्यक बिट्स में स्थान होता है।

Comments

गलत! उदाहरण के लिए O (n): यदि मैं इनपुट आकार को दोगुना करता हूं, तो रनटाइम गुणा नॉन जीरो कंटिन्यू को परिमित करेगा। मेरा मतलब है ओ (एन) = ओ (एन + एन)

— अखाड़ा-आरयू

मैं f के बारे में f (n) = O (g (n)) के बारे में बात कर रहा हूं, न कि जिस तरह आप समझ रहे हैं।

— Starblue

मैंने उकसाया, लेकिन आखिरी वाक्य मेरे योगदान को महसूस नहीं करता। चर्चा करते समय या बिग (O) को मापने पर हम अक्सर "बिट्स" के बारे में बात नहीं करते हैं।

— cdiggins

आपको O (n log n) के लिए एक उदाहरण जोड़ना चाहिए।

— क्रिस्टोफ़र हैमरस्ट्रोम

यह इतना स्पष्ट नहीं है, अनिवार्य रूप से यह ओ (एन) की तुलना में थोड़ा खराब व्यवहार करता है। तो अगर n डबल्स, रनटाइम गुणा एक कारक से कुछ हद तक 2 से बड़ा है।

— Starblue

Answer 6

बिग ओ नोटेशन का उपयोग आमतौर पर प्रोग्रामर्स द्वारा अनुमानित माप के रूप में किया जाता है कि इनपुट सेट के आकार के एक फ़ंक्शन के रूप में व्यक्त की गई गणना (एल्गोरिथम) को कितना समय लगेगा।

बिग ओ तुलना करने के लिए उपयोगी है कि इनपुट की संख्या में वृद्धि के रूप में दो एल्गोरिदम कितने पैमाने पर होंगे।

अधिक सटीक रूप से बिग ओ नोटेशन का उपयोग किसी फ़ंक्शन के स्पर्शोन्मुख व्यवहार को व्यक्त करने के लिए किया जाता है। इसका मतलब है कि यह कार्य कैसे व्यवहार करता है क्योंकि यह अनंत से संपर्क करता है।

कई मामलों में एल्गोरिथम का "O" निम्नलिखित मामलों में से एक में आएगा:

• O (1) - पूरा करने का समय इनपुट सेट के आकार की परवाह किए बिना समान है। एक उदाहरण सूचकांक द्वारा एक सरणी तत्व तक पहुंच रहा है।
• O (लॉग एन) - पूरा करने का समय अनुरूप लगभग बढ़ जाता है। उदाहरण के लिए 1024 आइटम 32 वस्तुओं की तुलना में लगभग दो बार लगते हैं, क्योंकि Log2 (1024) = 10 और Log2 (32) = 5. एक उदाहरण द्विआधारी खोज ट्री (BST) में एक आइटम मिल रहा है ।
• O (N) - इनपुट सेट के आकार के साथ उस पैमाने को पूरा करने का समय। दूसरे शब्दों में, यदि आप इनपुट सेट में वस्तुओं की संख्या को दोगुना करते हैं, तो एल्गोरिथ्म लगभग दो बार लंबे समय तक ले जाता है। एक उदाहरण लिंक की गई सूची में आइटमों की संख्या गिन रहा है।
• O (एन लॉग एन) - लॉग 2 (एन) के परिणाम की वस्तुओं की संख्या से पूरा होने का समय। इसका एक उदाहरण ढेर प्रकार और है क्विक सॉर्ट है ।
• O (N ^ 2) - पूरा होने का समय लगभग वस्तुओं की संख्या के वर्ग के बराबर है। इसका एक उदाहरण है बबल सॉर्ट है ।
• O (N!) - पूरा होने का समय इनपुट सेट का भाज्य है। इसका एक उदाहरण है ट्रैवलिंग सेल्समैन समस्या ब्रूट-फोर्स सॉल्यूशन है ।

बिग ओ ऐसे कारकों की उपेक्षा करता है जो किसी फ़ंक्शन के विकास वक्र के लिए सार्थक तरीके से योगदान नहीं करते हैं क्योंकि इनपुट आकार अनंतता की ओर बढ़ता है। इसका अर्थ है कि फ़ंक्शन द्वारा जोड़े या बनाए गए स्थिरांक को केवल अनदेखा किया जाता है।

Comments

cdiggins, क्या होगा अगर मेरे पास O (N / 2) जटिलता है, तो क्या यह O (N) या O (N / 2) होना चाहिए, उदाहरण के लिए यदि मैं आधी स्ट्रिंग पर लूप करूंगा तो क्या जटिलता होगी।

— मेलाड बेसिलियस

@ मेलाड यह एक स्थिर (0.5) फ़ंक्शन के लिए गुणा होने का एक उदाहरण है। के रूप में यह एन के बहुत बड़े मूल्यों के लिए एक सार्थक प्रभाव वाला माना जाता है इस पर ध्यान नहीं दिया जाता है

— cdiggins

Answer 7

बिग ओ खुद को एक सामान्य तरीके से "एक्सप्रेस" करने का एक तरीका है, "मेरे कोड को चलाने में कितना समय / स्थान लगता है?"।

आप अक्सर O (n), O (n ² ) देख सकते हैं ), O (nlogn) और आगे देख सकते हैं, ये सब सिर्फ दिखाने के तरीके हैं; एक एल्गोरिथ्म कैसे बदलता है?

O (n) का अर्थ बिग O n है, और अब आप सोच सकते हैं, "n क्या है !?" खैर "एन" तत्वों की मात्रा है। इमेजिंग आप एक ऐरे में एक आइटम के लिए खोज करना चाहते हैं। आपको प्रत्येक तत्व को देखना होगा और "क्या आप सही तत्व / वस्तु हैं?" सबसे खराब स्थिति में, आइटम अंतिम सूचकांक में है, जिसका अर्थ है कि सूची में आइटम होने में उतना ही समय लगा है, इसलिए सामान्य होने के लिए, हम कहते हैं "ओह हे, एन एक उचित मूल्य की मात्रा दी गई है!" ।

तो फिर आप समझ सकते हैं कि क्या "एन ² " का अर्थ है, लेकिन इससे भी अधिक विशिष्ट होने के लिए, इस विचार के साथ खेलें कि आपके पास एक सरल है, सॉर्टिंग एल्गोरिदम का सबसे सरल; बबल शॅाट। इस एल्गोरिथ्म को प्रत्येक सूची के लिए, पूरी सूची के माध्यम से देखना होगा।

मेरी सूची

1. 1
2. 6
3. 3

यहाँ प्रवाह होगा:

• 1 और 6 की तुलना करें, जो सबसे बड़ा है? ओके 6 सही स्थिति में है, आगे बढ़ रहा है!
• 6 और 3 की तुलना करें, ओह, 3 कम है! चलो आगे बढ़ते हैं, ठीक है सूची बदल गई, हमें अब भीख मांगने से शुरू करने की आवश्यकता है!

यह O n ^{2 है} क्योंकि, आपको उस सूची में सभी वस्तुओं को देखना होगा जो "n" आइटम हैं। प्रत्येक आइटम के लिए, आप सभी वस्तुओं को एक बार फिर से देखते हैं, तुलना करने के लिए, यह "n" भी है, इसलिए प्रत्येक आइटम के लिए, आप "n" बार का अर्थ n * n = n ^{2 देखते हैं।}

मुझे उम्मीद है कि यह उतना ही सरल है जितना आप इसे चाहते हैं।

लेकिन याद रखें, बिग ओ केवल समय और स्थान के तरीके से खुद को विस्तार देने का एक तरीका है।

Comments

logN के लिए हम 0 से N / 2 पर चलने वाले लूप के बारे में विचार करते हैं जो O (लॉग लॉग एन) के बारे में क्या है? मेरा मतलब है कि प्रोग्राम कैसा दिखता है? शुद्ध गणित कौशल के लिए मुझे क्षमा करें

— गोविंदा सखारे

Answer 8

बिग ओ एक एल्गोरिथ्म की मौलिक स्केलिंग प्रकृति का वर्णन करता है।

बहुत सी जानकारी है कि बिग ओ आपको दिए गए एल्गोरिदम के बारे में नहीं बताता है। यह हड्डी को काटता है और एल्गोरिथ्म की स्केलिंग प्रकृति के बारे में केवल जानकारी देता है, विशेष रूप से "इनपुट आकार" के जवाब में एल्गोरिथ्म तराजू के संसाधन का उपयोग (समय या स्मृति) कैसे करें।

स्टीम इंजन और रॉकेट के बीच अंतर पर विचार करें। वे केवल एक ही चीज़ की अलग-अलग किस्में नहीं हैं (जैसे, कहते हैं, एक Prius इंजन बनाम एक लेम्बोर्गिनी इंजन) लेकिन वे नाटकीय रूप से विभिन्न प्रकार के प्रणोदन सिस्टम हैं, उनके मूल में। स्टीम इंजन टॉय रॉकेट की तुलना में तेज़ हो सकता है, लेकिन कोई स्टीम पिस्टन इंजन ऑर्बिटल लॉन्च वाहन की गति को प्राप्त करने में सक्षम नहीं होगा। ऐसा इसलिए है क्योंकि इन प्रणालियों में ईंधन की आवश्यकता के संबंध में विभिन्न स्केलिंग विशेषताओं ("संसाधन उपयोग") को दिए गए गति ("इनपुट आकार") तक पहुंचने की आवश्यकता है।

यह क्यों इतना महत्वपूर्ण है? क्योंकि सॉफ्टवेयर उन समस्याओं से निपटता है जो एक ट्रिलियन तक के कारकों द्वारा आकार में भिन्न हो सकती हैं। उस पर एक पल के लिए विचार करें। चंद्रमा की यात्रा करने के लिए आवश्यक गति और मानव चलने की गति के बीच का अनुपात 10,000: 1 से कम है, और इनपुट आकार के सॉफ्टवेयर की सीमा की तुलना में यह बिल्कुल छोटा है। और क्योंकि सॉफ्टवेयर इनपुट आकार में एक खगोलीय सीमा का सामना कर सकता है, किसी एल्गोरिदम के बिग ओ जटिलता के लिए क्षमता है, यह मौलिक स्केलिंग प्रकृति है, किसी भी कार्यान्वयन विवरण को ट्रम्प करने के लिए।

विहित छँटाई उदाहरण पर विचार करें। बबल-सॉर्ट O (n ² ) है जबकि मर्ज-सॉ O (n लॉग एन) है। मान लें कि आपके पास दो सॉर्टिंग एप्लिकेशन हैं, एप्लिकेशन ए जो बबल-सॉर्ट और एप्लिकेशन बी का उपयोग करता है जो मर्ज-सॉर्ट का उपयोग करता है, और मान लें कि लगभग 30 तत्वों के इनपुट आकारों के लिए ए ए सॉर्टिंग पर एप्लीकेशन बी की तुलना में 1,000x तेज है। यदि आपको कभी 30 से अधिक तत्वों को क्रमबद्ध नहीं करना है, तो यह स्पष्ट है कि आपको आवेदन ए पसंद करना चाहिए, क्योंकि यह इन इनपुट आकारों में बहुत तेज है। हालाँकि, यदि आप पाते हैं कि आपको दस मिलियन आइटम सॉर्ट करने पड़ सकते हैं, तो आपसे क्या अपेक्षा की जाएगी कि एप्लिकेशन B वास्तव में इस मामले में एप्लिकेशन A की तुलना में हजारों गुना तेज है, पूरी तरह से प्रत्येक एल्गोरिथ्म तराजू के कारण।

Answer 9

यहाँ पर सामान्य अंग्रेजी बेस्टरी है जिसका उपयोग मैं बिग-ओ की सामान्य किस्मों को समझाता हूँ

सभी मामलों में, सूची में उच्चतर एल्गोरिदम को सूची में कम करने वालों को प्राथमिकता दें। हालांकि, एक अधिक महंगी जटिलता वर्ग में जाने की लागत काफी भिन्न होती है।

हे (1):

कोई विकास नहीं। भले ही समस्या कितनी भी बड़ी हो, आप उसे उसी समय में हल कर सकते हैं। यह प्रसारण के लिए कुछ हद तक अनुरूप है जहां प्रसारण दूरी के भीतर झूठ बोलने वाले लोगों की संख्या की परवाह किए बिना किसी दूरी पर प्रसारित करने के लिए ऊर्जा की समान मात्रा लेता है।

O (लॉग एन ):

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

ओ ( n ):

समस्या को हल करने की लागत समस्या के आकार के अनुपात में है। यदि आपकी समस्या आकार में दोगुनी हो जाती है, तो समाधान की लागत दोगुनी हो जाती है। चूंकि अधिकांश समस्याओं को कंप्यूटर में किसी तरह से स्कैन किया जाना है, क्योंकि डेटा प्रविष्टि, डिस्क रीड, या नेटवर्क ट्रैफ़िक, यह आमतौर पर एक सस्ती स्केलिंग कारक है।

ओ ( एन लॉग एन ):

यह जटिलता O ( n ) के समान है । सभी व्यावहारिक उद्देश्यों के लिए, दोनों समान हैं। जटिलता का यह स्तर आम तौर पर अभी भी स्केलेबल माना जाएगा। कुछ ओ ( एन लॉग एन ) एल्गोरिदम को मान्य करने से एल्गोरिदम को ओ ( एन ) एल्गोरिदम में बदल दिया जा सकता है। उदाहरण के लिए, कुंजियों के आकार को बांटने से O ( n log n ) से O ( n ) तक छंटनी कम हो जाती है ।

ओ ( एन ^२) ):

एक वर्ग के रूप में बढ़ता है, जहां n एक वर्ग के पक्ष की लंबाई है। यह "नेटवर्क प्रभाव" के समान विकास दर है, जहां एक नेटवर्क में हर कोई नेटवर्क में बाकी सभी को जान सकता है। विकास महंगा है। अधिकांश स्केलेबल समाधान महत्वपूर्ण जिमनास्टिक किए बिना जटिलता के इस स्तर के साथ एल्गोरिदम का उपयोग नहीं कर सकते हैं। यह आम तौर पर अन्य सभी बहुपद जटिलताओं पर लागू होता है - ओ ( एन ^के ) - साथ ही।

ओ (2 ^एन ):

पैमाना नहीं है। आपको किसी भी गैर-तुच्छ आकार की समस्या को हल करने की कोई उम्मीद नहीं है। बचने के लिए जानने के लिए उपयोगी है, और विशेषज्ञों को अनुमानित एल्गोरिदम खोजने के लिए जो ओ ( एन ^के ) में हैं ।

Comments

क्या आप कृपया O (1) के लिए एक अलग सादृश्य पर विचार कर सकते हैं? मुझ में अभियंता रुकावटों के कारण आरएफ प्रतिबाधा के बारे में चर्चा करना चाहता है।

— जॉन्हबीरड

Answer 10

बिग ओ एक उपाय है कि एल्गोरिथ्म अपने इनपुट के आकार के सापेक्ष कितना समय / स्थान का उपयोग करता है।

यदि एक एल्गोरिथ्म O (n) है तो उसके इनपुट के समय / स्थान उसी दर से बढ़ेगा।

यदि एक एल्गोरिथ्म हे (n ²⁾ ) है तो उसके इनपुट की दर पर समय / स्थान बढ़ता है।

और इसी तरह।

Comments

यह अंतरिक्ष के बारे में नहीं है। यह जटिलता के बारे में है जिसका अर्थ है समय।

— एस.लॉट

मैंने हमेशा माना है कि यह समय या स्थान के बारे में हो सकता है। लेकिन एक ही समय में दोनों के बारे में नहीं।

— रोक्को

जटिलता निश्चित रूप से अंतरिक्ष के बारे में हो सकती है। इस पर एक नज़र डालें: en.wikipedia.org/wiki/PSPACE

— टॉम क्रोकेट

यह उत्तर यहाँ सबसे "सादा" है। पहले वाले वास्तव में मानते हैं कि पाठक उन्हें समझने के लिए पर्याप्त जानते हैं लेकिन लेखकों को इसकी जानकारी नहीं है। उन्हें लगता है कि उनका जीवन सरल और सादा है, जो बिल्कुल नहीं हैं। सुंदर प्रारूप के साथ एक बहुत अधिक पाठ लिखना और फैंसी कृत्रिम उदाहरण बनाना जो गैर-सीएस लोगों के लिए कठिन हैं, सादे और सरल नहीं हैं, यह स्टैकओवरफ्लॉवर के लिए आकर्षक है, जो ज्यादातर सीएस लोग वोट करने के लिए हैं। सादे अंग्रेजी में सीएस शब्द की व्याख्या कोड और गणित के बारे में कुछ भी नहीं की जरूरत है। इस जवाब के लिए +1 हालांकि यह अभी भी पर्याप्त नहीं है।

— W.Sun

यह उत्तर यह मानने की त्रुटि करता है कि f = O (g) का अर्थ है कि f और g आनुपातिक हैं।

— पॉल हैंकिन

Answer 11

बिग ओ का सादा अंग्रेजी स्पष्टीकरण क्या है? संभव और सरल गणित के रूप में थोड़ी औपचारिक परिभाषा के साथ।

बिग-ओ नोटेशन की आवश्यकता का एक सादा अंग्रेजी स्पष्टीकरण :

जब हम कार्यक्रम करते हैं, तो हम एक समस्या को हल करने की कोशिश कर रहे हैं। जिसे हम कोड कहते हैं उसे एल्गोरिथ्म कहा जाता है। बिग ओ नोटेशन हमें एक मानकीकृत तरीके से हमारे एल्गोरिदम के बदतर मामले के प्रदर्शन की तुलना करने की अनुमति देता है। हार्डवेयर चश्मा समय के साथ बदलता रहता है और हार्डवेयर में सुधार उस समय को कम कर सकता है, जिसे चलाने के लिए एक एल्गोरिदम लगता है। लेकिन हार्डवेयर को बदलने का मतलब यह नहीं है कि हमारा एल्गोरिथ्म समय के साथ बेहतर या बेहतर है, क्योंकि हमारा एल्गोरिथ्म अभी भी वैसा ही है। इसलिए हमें अलग-अलग एल्गोरिदम की तुलना करने की अनुमति देने के लिए, यह निर्धारित करने के लिए कि कोई बेहतर है या नहीं, हम बिग ओ नोटेशन का उपयोग करते हैं।

एक सादा अंग्रेजी स्पष्टीकरण क्या हैबिग ओ नोटेशन :

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

Answer 12

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

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

क्योंकि वे सन्निकटन हैं, हम अभिव्यक्ति में "ओ" (बिग ओह) अक्षर का उपयोग करते हैं, पाठक को संकेत देने के लिए एक सम्मेलन के रूप में कि हम एक स्थूल निरीक्षण कर रहे हैं। (और यह सुनिश्चित करने के लिए कि कोई भी गलती से नहीं सोचता है कि अभिव्यक्ति किसी भी तरह से सटीक है)।

यदि आप "ओह" को "या" लगभग "के आदेश पर" अर्थ के रूप में पढ़ते हैं तो आप बहुत गलत नहीं होंगे। (मुझे लगता है कि बिग-ओह का चुनाव हास्य का एक प्रयास हो सकता है)।

केवल एक चीज जो इन "बिग-ओह" अभिव्यक्तियों को करने की कोशिश करती है, यह वर्णन करने के लिए कि सॉफ्टवेयर कितना धीमा हो जाता है क्योंकि हम उस डेटा की मात्रा को बढ़ाते हैं जो सॉफ्टवेयर को संसाधित करना है। यदि हमें संसाधित किए जाने वाले डेटा की मात्रा दोगुनी हो जाती है, तो क्या यह काम करने के लिए सॉफ़्टवेयर को दो बार आवश्यकता होती है? दस बार कब तक? व्यवहार में, बहुत ही सीमित संख्या में बड़े-ओह भाव हैं जिनका आप सामना करेंगे और इसके बारे में चिंता करने की आवश्यकता है:

अच्छा:

• O(1) लगातार : प्रोग्राम को इनपुट को कितना भी बड़ा करने के लिए एक ही समय लगता है।
• O(log n) लॉगरिदमिक : प्रोग्राम रन-टाइम केवल धीरे-धीरे बढ़ता है, यहां तक ​​कि इनपुट के आकार में बड़ी वृद्धि के साथ।

खराब:

• O(n) रैखिक : प्रोग्राम रन-टाइम इनपुट के आकार के अनुपात में बढ़ता है।
• O(n^k) बहुपद : - प्रसंस्करण समय तेजी से और तेजी से बढ़ता है - एक बहुपद के रूप में - इनपुट का आकार बढ़ने पर।

... और बदसूरत:

• O(k^n) एक्सपोनेंशियल प्रोग्राम रन-टाइम समस्या के आकार में मामूली वृद्धि के साथ बहुत तेज़ी से बढ़ता है - एक्सपोनेंशियल एल्गोरिदम के साथ छोटे डेटा सेट को संसाधित करने के लिए केवल व्यावहारिक है।
• O(n!) फैक्टरियल कार्यक्रम रन-टाइम तब होगा जब आप किसी भी चीज़ के लिए इंतजार कर सकते हैं, लेकिन बहुत छोटी और सबसे मामूली प्रतीत होने वाले डेटासेट।

Comments

मैंने लिनियरिथमिक शब्द भी सुना है - O(n log n)जिसे अच्छा माना जाएगा।

— जेसन डाउन

Answer 13

एक सीधा सरल उत्तर हो सकता है:

बिग ओ उस एल्गोरिथ्म के लिए सबसे खराब समय / स्थान का प्रतिनिधित्व करता है। एल्गोरिथ्म उस सीमा से अधिक स्थान / समय कभी नहीं लेगा। बिग ओ चरम मामले में समय / अंतरिक्ष जटिलता का प्रतिनिधित्व करता है।

Answer 14

ठीक है, मेरे 2 सेंट।

बिग-ओ, वृद्धि की दर है प्रोग्राम द्वारा खपत संसाधन की , wrt समस्या-उदाहरण-आकार है

संसाधन: कुल-सीपीयू समय हो सकता है, अधिकतम रैम स्थान हो सकता है। डिफ़ॉल्ट रूप से सीपीयू समय को संदर्भित करता है।

समस्या यह है कि "योग खोजें"

int Sum(int*arr,int size){
      int sum=0;
      while(size-->0) 
         sum+=arr[size]; 

      return sum;
}

समस्या-उदाहरण = {5,10,15} ==> समस्या-उदाहरण-आकार = 3, पुनरावृत्तियों-इन-लूप - 3

समस्या-उदाहरण = {५,१०,१५,२०,२५} ==> समस्या-उदाहरण-आकार = ५ पुनरावृत्ति-इन-पाश = ५:

आकार "n" के इनपुट के लिए कार्यक्रम सरणी में "n" पुनरावृत्तियों की गति से बढ़ रहा है। इसलिए बिग-ओ को एन (ओ) के रूप में व्यक्त किया गया है

समस्या यह है कि "संयोजन खोजें",

    void Combination(int*arr,int size)
    { int outer=size,inner=size;
      while(outer -->0) {
        inner=size;
        while(inner -->0)
          cout<<arr[outer]<<"-"<<arr[inner]<<endl;
      }
    }

समस्या-उदाहरण = {5,10,15} ==> समस्या-उदाहरण-आकार = 3, कुल पुनरावृत्तियों = 3 * 3 = 9

समस्या-उदाहरण = {5,10,15,20,25} ==> समस्या-उदाहरण-आकार = 5, कुल-पुनरावृत्तियों = 5 * 5 = 25

आकार "n" के इनपुट के लिए कार्यक्रम सरणी में "n * n" पुनरावृत्तियों की गति से बढ़ रहा है। इसलिए बिग-ओ को एन ^{2 के} रूप में व्यक्त किया जाता है ओ (एन ² )

Comments

while (size-->0)मुझे उम्मीद है कि यह फिर से नहीं पूछेगा।

— mr5

Answer 15

बिग ओ नोटेशन अंतरिक्ष या चलने के समय के संदर्भ में एक एल्गोरिथ्म की ऊपरी सीमा का वर्णन करने का एक तरीका है। N समस्या में तत्वों की संख्या है (जैसे कि एक सरणी का आकार, एक पेड़ में नोड्स की संख्या, आदि) हम चल रहे समय का वर्णन करने में रुचि रखते हैं क्योंकि n बड़ा हो जाता है।

जब हम कहते हैं कि कुछ एल्गोरिथ्म O (f (n)) है तो हम कह रहे हैं कि उस एल्गोरिथ्म द्वारा चलने का समय (या स्थान आवश्यक है) हमेशा कुछ निरंतर समय f (n) से कम होता है।

यह कहने के लिए कि बाइनरी सर्च में O (logn) का रनिंग टाइम है, यह कहना है कि कुछ निरंतर c मौजूद है, जिसे आप कई बार लॉग (n) कर सकते हैं, जो कि बाइनरी सर्च के रनिंग टाइम से हमेशा बड़ा होगा। इस मामले में आपके पास लॉग (एन) तुलना के कुछ निरंतर कारक होंगे।

दूसरे शब्दों में जहाँ g (n) आपके एल्गोरिथ्म का चलन समय है, हम कहते हैं कि g (n) = O (f (n)) जब g (n) <= c * f (n) जब n> k, कहाँ c और k कुछ स्थिरांक हैं।

Comments

हम बिग केस और औसत मामले को मापने के लिए बिगओ नोटेशन का उपयोग कर सकते हैं। en.wikipedia.org/wiki/Big_O_notation

— cdiggins

Answer 16

" बिग ओ का सादा अंग्रेजी स्पष्टीकरण क्या है? संभव और सरल गणित के रूप में थोड़ी औपचारिक परिभाषा के साथ। "

इस तरह के एक सुंदर सरल और लघु प्रश्न कम से कम समान रूप से संक्षिप्त उत्तर देने के लिए लगता है, जैसे एक छात्र ट्यूशन के दौरान प्राप्त कर सकता है।

बिग ओ नोटेशन केवल बताता है कि कितना समय * एक एल्गोरिथ्म के भीतर चल सकता है, केवल इनपुट डेटा की मात्रा के संदर्भ में **।

(* समय की एक अद्भुत, यूनिट-मुक्त भावना में!)
(** जो मायने रखता है, क्योंकि लोग हमेशा अधिक चाहते हैं , चाहे वे आज या कल रहें)

खैर, बिग ओ अंकन के बारे में इतना अद्भुत है कि अगर यह क्या करता है?

• व्यावहारिक रूप से बोलना, बिग ओ विश्लेषण इसलिए उपयोगी और महत्वपूर्ण है क्योंकि बिग ओ एल्गोरिदम की स्वयं की जटिलता पर ध्यान केंद्रित करता है और पूरी तरह से किसी भी चीज की उपेक्षा करता है जो केवल आनुपातिकता निरंतर है - जैसे जावास्क्रिप्ट इंजन, सीपीयू की गति, आपका इंटरनेट कनेक्शन, और वे सभी चीजें जो मॉडल टी के रूप में जल्दी से पुरानी हो गई हैं । बिग ओ केवल उसी तरीके से प्रदर्शन पर ध्यान केंद्रित करता है जो वर्तमान या भविष्य में रहने वाले लोगों के लिए समान रूप से मायने रखता है।

• बिग ओ नोटेशन भी कंप्यूटर प्रोग्रामिंग / इंजीनियरिंग के सबसे महत्वपूर्ण सिद्धांत पर सीधे स्पॉटलाइट को चमकता है, यह तथ्य जो सभी अच्छे प्रोग्रामर को सोचने और सपने देखने के लिए प्रेरित करता है: प्रौद्योगिकी के धीमे आगे मार्च से परे परिणाम प्राप्त करने का एकमात्र तरीका एक बेहतर आविष्कार करना है एल्गोरिथ्म ।

Comments

गणित के बिना कुछ गणित की व्याख्या करने के लिए कहा जाना मेरे लिए हमेशा एक व्यक्तिगत चुनौती होती है, क्योंकि एक पीएच.डी. गणितज्ञ और शिक्षक जो मानते हैं कि ऐसा वास्तव में संभव है। और साथ ही एक प्रोग्रामर होने के नाते, मुझे उम्मीद है कि कोई भी दिमाग जिसे मैंने इस विशेष प्रश्न का उत्तर दिया, गणित के बिना, एक चुनौती है जो पूरी तरह से अप्रतिरोध्य था।

— जोसेफ मायर्स

Answer 17

एल्गोरिथ्म उदाहरण (जावा):

// given a list of integers L, and an integer K
public boolean simple_search(List<Integer> L, Integer K)
{
    // for each integer i in list L
    for (Integer i : L)
    {
        // if i is equal to K
        if (i == K)
        {
            return true;
        }
    }

    return false;
}

एल्गोरिथम विवरण:

• यह एल्गोरिथ्म एक सूची खोजता है, आइटम द्वारा आइटम, एक कुंजी की तलाश में,

• सूची में प्रत्येक आइटम पर Iterating, यदि यह कुंजी है तो True पर लौटें,

• यदि लूप कुंजी को खोजने के बिना समाप्त हो गया है, तो गलत लौटें।

बिग-ओ नोटेशन जटिलता (समय, स्थान, ..) पर ऊपरी-सीमा का प्रतिनिधित्व करता है

समय जटिलता पर बिग-ओ खोजने के लिए:

• सबसे खराब स्थिति में कितना समय लगता है (इनपुट आकार के बारे में):

• सबसे खराब मामला: सूची में कुंजी मौजूद नहीं है।

• समय (सबसे खराब स्थिति) = 4 एन + 1

• समय: O (4n + 1) = O (n) | बिग-ओ में, स्थिरांक उपेक्षित हैं

• O (n) ~ रेखीय

बिग-ओमेगा भी है, जो बेस्ट-केस की जटिलता का प्रतिनिधित्व करता है:

• बेस्ट-केस: कुंजी पहला आइटम है।

• समय (उत्तम-प्रकरण) = ४

• समय: ~ (4) = O (1) ~ इंस्टेंट \ कॉन्स्टेंट

Comments

आपका निरंतर 4 कहां से आता है?

— रॉड

@ रोड इटिअटर इनिट, इटरेटर कम्पेरिजन, इटेरेटर रीड, की कम्पेरिजन .. मुझे लगता है Cकि बेहतर होगा

— खालिद.के।

Answer 18

बड़ा हे

f (x) = O ( g (x)) जब x a (उदाहरण के लिए, a = + ∞) जाता है, तो इसका मतलब है कि एक फंक्शन k है जैसे:

1. f (x) = k (x) g (x)

2. k किसी के पड़ोस में बसा हुआ है (यदि a = + this, तो इसका मतलब है कि संख्याएँ N और M हैं जैसे कि हर x> N, | k (x) | <M) के लिए।

दूसरे शब्दों में, सादे अंग्रेजी में: f (x) = O ( g (x)), x → a, का अर्थ है कि a के पड़ोस में f , g के उत्पाद में विघटित हो जाता है और कुछ बंधे हुए कार्य करता है।

छोटा ओ

वैसे, यहां छोटे ओ की परिभाषा की तुलना के लिए है।

f (x) = o ( g (x)) जब x का अर्थ होता है कि कोई फ़ंक्शन k है जैसे:

1. f (x) = k (x) g (x)

2. k (x) 0 पर जाता है जब x a के पास जाता है।

उदाहरण

• sin x = O (x) जब x → 0।

• पाप x = O (1) जब x → + 1,

• x ² + x = O (x) जब x → 0,

• x ² + x = O (x ² ) जब x → + O ,

• ln (x) = o (x) = O (x) जब x → + =।

ध्यान! समान चिह्न "=" के साथ संकेतन "नकली समानता" का उपयोग करता है: यह सच है कि ओ (जी (एक्स)) = ओ (जी (एक्स)), लेकिन गलत है कि ओ (जी (एक्स)) = ओ (जी) (एक्स))। इसी प्रकार, जब x → + ∞ "जब" ln (x) = o (x) लिखना ठीक है, लेकिन सूत्र "o (x) = ln (x)" का कोई अर्थ नहीं होगा।

और ज्यादा उदाहरण

• O (1) = O (n) = O (n ² ) जब n → + but (लेकिन आसपास कोई दूसरा रास्ता नहीं है, तो समानता "नकली" है)

• O (n) + O (n ² ) = O (n ² ) जब n → + O

• O (O (n ² )) = O (n ² ) जब n → + ²

• O (n ² ) O (n ³ ) = O (n ⁵ ) जब n → + O

---

यहाँ विकिपीडिया लेख है: https://en.wikipedia.org/wiki/Big_O_notation

Comments

आप "बिग ओ" और "स्मॉल ओ" बताए बिना बता रहे हैं कि वे क्या हैं, बहुत सारी गणितीय अवधारणाओं को यह बताए बिना कि वे क्यों महत्वपूर्ण हैं और विकिपीडिया का लिंक इस तरह के प्रश्न के लिए बहुत स्पष्ट हो सकता है।

— आदित्य सक्सेना

@ AditSaxena क्या मतलब है "बिना यह बताए कि वे क्या हैं"? मैंने बिल्कुल समझाया कि वे क्या हैं। यही है, "बड़ा ओ" और "छोटा ओ" अपने आप से कुछ भी नहीं हैं, केवल "एफ (एक्स) = ओ (जी (एक्स))" जैसे एक सूत्र का एक अर्थ है, जिसे मैंने समझाया (सादे अंग्रेजी में, लेकिन परिभाषित किए बिना बेशक एक पथरी पाठ्यक्रम से सभी आवश्यक चीजें)। कभी-कभी "ओ (एफ (एक्स))" को सभी कार्यों "जी (एक्स)" के वर्ग (वास्तव में सेट) के रूप में देखा जाता है, जैसे कि "जी (एक्स) = ओ (एफ (एक्स))", लेकिन यह है एक अतिरिक्त कदम, जो मूल बातें समझने के लिए आवश्यक नहीं है।

— एलेक्सी

ठीक है, ठीक है, ऐसे शब्द हैं जो सादे अंग्रेजी नहीं हैं, लेकिन यह अपरिहार्य है, जब तक कि मुझे गणितीय विश्लेषण से सभी आवश्यक परिभाषाओं को शामिल नहीं करना होगा।

— एलेक्सी

हाय # एलेक्सी, कृपया स्वीकृत उत्तर पर एक नज़र डालें: यह लंबा है लेकिन यह अच्छी तरह से निर्मित और अच्छी तरह से स्वरूपित है। यह एक सरल परिभाषा के साथ शुरू होता है जिसमें कोई गणितीय पृष्ठभूमि की आवश्यकता नहीं होती है। ऐसा करते समय वह थ्री 3 "तकनीकी" शब्दों का परिचय देता है जिसे वह तुरंत (सापेक्ष, प्रतिनिधित्व, जटिलता) समझाता है। इस क्षेत्र में खुदाई करते समय यह कदम दर कदम आगे बढ़ता जाता है।

— आदित्य सक्सेना

Big O का उपयोग एल्गोरिदम के स्पर्शोन्मुखी व्यवहार को समझने के लिए किया जाता है उसी कारण से इसका उपयोग कार्यों के स्पर्शोन्मुखी व्यवहार को समझने के लिए किया जाता है (asymptotic behavior is infinity के पास व्यवहार)। यह एक जटिल फ़ंक्शन (एल्गोरिथ्म में वास्तविक समय या स्थान लेता है) की तुलना करने के लिए एक सुविधाजनक संकेतन है, अनन्तता के पास (या कुछ भी सरल, आमतौर पर एक पावर फंक्शन)। मैंने केवल समझाया कि यह क्या है (परिभाषा दी)। बड़े ओ के साथ गणना कैसे करें एक अलग कहानी है, शायद मैं कुछ उदाहरण जोड़ूंगा, क्योंकि आप रुचि रखते हैं।

— एलेक्सी

Answer 19

बिग ओ नोटेशन यह वर्णन करने का एक तरीका है कि कितनी जल्दी एक एल्गोरिथ्म एक अनियंत्रित संख्या इनपुट मापदंडों को चलाएगा, जिसे हम "एन" कहेंगे। यह कंप्यूटर विज्ञान में उपयोगी है क्योंकि अलग-अलग मशीनें अलग-अलग गति से काम करती हैं, और बस यह कहते हुए कि एक एल्गोरिथ्म 5 सेकंड का समय लेता है, आपको ज्यादा नहीं बताता क्योंकि जब आप 4.5 Ghz ऑक्टो-कोर प्रोसेसर के साथ एक सिस्टम चला रहे होंगे, तो मैं चल सकता हूं एक 15 वर्षीय, 800 मेगाहर्ट्ज प्रणाली, जो एल्गोरिथम की परवाह किए बिना अधिक समय ले सकती है। इसलिए यह निर्दिष्ट करने के बजाय कि समय के संदर्भ में एक एल्गोरिथ्म कितनी तेजी से चलता है, हम कहते हैं कि इनपुट मापदंडों की संख्या, या "एन" के संदर्भ में यह कितनी तेजी से चलता है। इस तरह से एल्गोरिदम का वर्णन करके, हम कंप्यूटर की गति को ध्यान में रखे बिना एल्गोरिदम की गति की तुलना करने में सक्षम हैं।

Answer 20

मुझे यकीन नहीं है कि मैं इस विषय में आगे योगदान कर रहा हूं, लेकिन फिर भी मैंने सोचा कि मैं साझा करूंगा: मुझे एक बार इस ब्लॉग पोस्ट में कुछ मददगार (हालांकि बहुत ही बुनियादी) स्पष्टीकरण और बिग ओ पर उदाहरण हैं:

उदाहरण के लिए, इससे मेरी कछुआ-जैसी खोपड़ी में नंगे मूल को प्राप्त करने में मदद मिली, इसलिए मुझे लगता है कि यह आपको सही दिशा में ले जाने के लिए 10 मिनट का एक सुंदर वंश है।

Comments

@William ... और लोग बुढ़ापे से मर जाते हैं, प्रजातियां विलुप्त हो जाती हैं, ग्रह बंजर हो जाते हैं आदि

— Priidu Neemre

Answer 21

आप सब जानना चाहते हैं कि बड़े ओ का पता है? मैं भी ऐसा करूँ।

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

अब, आप और मैं काम की बात करते हैं। ज्यादातर समय, मुझे काम पसंद नहीं है। क्या आपको काम पसंद है? यह ऐसा मामला हो सकता है जो आप करते हैं, लेकिन मुझे यकीन है कि मैं नहीं हूं।

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

अब कई बार मुझे काम पर जाना पड़ता है। यह दुख की बात है लेकिन सच है। इसलिए, जब मैं काम पर हूं, मेरे पास एक नियम है: मैं कम काम करने की कोशिश करता हूं। पास के किसी काम के रूप में मैं कर सकता हूँ। फिर मैं खेलता हूँ!

तो यहाँ बड़ी खबर है: बड़ा ओ मुझे काम नहीं करने में मदद कर सकता है! मैं अधिक समय खेल सकता हूं, अगर मुझे बड़ा ओ पता है। कम काम, अधिक खेल! यही कारण है कि बड़ा हे मुझे मदद करता है।

अब मुझे कुछ काम है। मेरे पास यह सूची है: एक, दो, तीन, चार, पांच, छह। मुझे इस सूची में सभी चीजों को जोड़ना होगा।

वाह, मुझे काम से नफरत है। लेकिन ओह ठीक है, मुझे यह करना है। इसलिए यहां जाता हूं।

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

तो चलिए काम नहीं करते हैं। चलिए आप और मैं बस सोचते हैं कि यह कितना कठिन है। छह नंबर जोड़ने के लिए मुझे कितना काम करना होगा?

अच्छा चलो देखते हैं। मुझे एक और दो जोड़ना होगा, और फिर उस तीन को जोड़ना होगा, और फिर उस चार को जोड़ना होगा ... सभी में, मैं छह जोड़ता हूं। मुझे इसे हल करने के लिए छह जोड़ करने होंगे।

यहाँ बड़ा ओ आता है, हमें यह बताने के लिए कि यह गणित कितना कठिन है।

बिग ओ कहते हैं: हमें इसे हल करने के लिए छह जोड़ करने चाहिए। एक चीज, प्रत्येक चीज के लिए एक से छह तक। काम के छह छोटे बिट्स ... प्रत्येक बिट काम एक ऐड है।

खैर, उन्हें जोड़ने का काम मैं अब नहीं करूंगा। लेकिन मुझे पता है कि यह कितना कठिन होगा। यह छह जोड़ होगा।

अरे नहीं, अब मेरे पास और काम हैं। शीश। इस तरह का सामान कौन बनाता है ?!

अब वे मुझे एक से दस तक जोड़ने के लिए कहते हैं! मैं ऐसा क्यों करूंगा? मैं एक से छह जोड़ना नहीं चाहता था। एक से दस तक जोड़ने के लिए ... अच्छी तरह से ... यह और भी कठिन होगा!

कितना अधिक कठिन होगा? मुझे और कितना काम करना होगा? क्या मुझे अधिक या कम चरणों की आवश्यकता है?

ठीक है, मुझे लगता है कि मुझे एक से दस तक प्रत्येक चीज़ के लिए दस अतिरिक्त करने होंगे। दस छह से अधिक है। मुझे एक से छह तक एक से छह तक जोड़ने के लिए इतना काम करना होगा!

मैं अभी जोड़ना नहीं चाहता। मैं सिर्फ यह सोचना चाहता हूं कि इसे कितना जोड़ना मुश्किल हो सकता है। और, मुझे आशा है, मैं जितनी जल्दी हो सके खेलूं।

एक से छह तक जोड़ने के लिए, वह कुछ काम है। लेकिन क्या आप देखते हैं, एक से दस तक जोड़ने के लिए, यह अधिक काम है?

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

अब हमें नया काम करना होगा। अरे नहीं। मुझे यह काम बिल्कुल पसंद नहीं है।

नया काम है: एक से n तक सभी चीजों को जोड़ना।

रुको! N क्या है? क्या मुझे वह याद आया? यदि आप मुझे यह नहीं बताते हैं कि मैं एक से n में कैसे जोड़ सकता हूं?

खैर, मुझे नहीं पता कि n क्या है। मुझे नहीं बताया गया था। क्या तुम? नहीं? ओह अच्छा। इसलिए हम काम नहीं कर सकते। वाह।

लेकिन हालांकि हम अब काम नहीं करेंगे, हम अनुमान लगा सकते हैं कि यह कितना कठिन होगा, अगर हम n जानते थे। हम n चीजें जोड़ना होगा, है ना? बेशक!

अब यहाँ बड़ा ओ आता है, और वह हमें बताएगा कि यह काम कितना कठिन है। वह कहता है: एक से एक तक सभी चीजों को जोड़ने के लिए, एक ओ (एन) है। इन सभी चीजों को जोड़ने के लिए, [मुझे पता है कि मुझे n बार जोड़ना होगा।] [1] यह बड़ा हे! वह बताता है कि किसी प्रकार का काम करना कितना कठिन है।

मेरे लिए, मैं एक बड़े, धीमे, बॉस आदमी की तरह बड़े ओ के बारे में सोचता हूं। वह काम पर सोचता है, लेकिन वह ऐसा नहीं करता है। वह कह सकता है, "यह काम जल्दी है।" या, वह कह सकता है, "यह काम इतना धीमा और कठिन है!" लेकिन वह काम नहीं करता है। वह बस काम को देखता है, और फिर वह हमें बताता है कि इसमें कितना समय लग सकता है।

मुझे बड़े ओ की बहुत परवाह है। क्यों? मुझे काम करना पसंद नहीं है! किसी को काम करना पसंद नहीं है। यही कारण है कि हम सभी बड़े हे प्यार करते हैं! वह बताता है कि हम कितनी तेजी से काम कर सकते हैं। वह हमें यह सोचने में मदद करता है कि कितनी मेहनत है।

उह ओह, अधिक काम। अब, चलो काम नहीं करते हैं। लेकिन, चलो इसे करने के लिए एक योजना बनाएं, कदम से कदम।

उन्होंने हमें दस कार्ड का एक डेक दिया। वे सभी मिश्रित हैं: सात, चार, दो, छह… बिल्कुल सीधे नहीं। और अब ... हमारा काम उन्हें सुलझाना है।

Ergh। जो बहुत काम की लगती है!

हम इस डेक को कैसे सॉर्ट कर सकते हैं? मेरे पास एक योजना है।

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

जब डेक किया जाता है, तो मैं पूछता हूं: क्या मैंने उस पास में कार्ड स्वैप किया था? यदि हां, तो मुझे यह सब एक बार और करना चाहिए, ऊपर से।

किसी बिंदु पर, किसी समय, कोई स्वैप नहीं होगा, और हमारी तरह का डेक किया जाएगा। बहुत सारा कार्य!

खैर, उन नियमों के साथ कार्ड को छाँटने के लिए कितना काम होगा?

मेरे पास दस कार्ड हैं। और, ज्यादातर समय - यानी, अगर मेरे पास बहुत सारी किस्मत नहीं है - मुझे पूरे डेक के माध्यम से दस बार तक जाना होगा, डेक के माध्यम से हर बार दस कार्ड स्वैप तक।

बिग ओ, मेरी मदद करो!

बिग ओ अंदर आता है और कहता है: एन कार्ड के एक डेक के लिए, इसे सॉर्ट करने के लिए इस तरह से ओ (एन स्क्वार्ड) समय में किया जाएगा।

क्यों वह n चुकता कहता है?

ठीक है, आपको पता है कि n चुकता n है n समय n। अब, मुझे यह मिल गया: n कार्ड की जाँच की, डेक के माध्यम से n बार क्या हो सकता है। यह दो छोरों है, प्रत्येक एन चरणों के साथ। यह n चुकता करने के लिए बहुत काम किया जाना है। बहुत काम, पक्का!

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

अब यहाँ है जहाँ बड़ा हे हमारे दोस्त है।

बिग ओ इसे बताते हैं: जैसा कि n बड़ा हो जाता है, जब हम कार्ड को सॉर्ट करते हैं, तो नौकरी पुराने पुराने ऐड-इन-जॉब जॉब की तुलना में बहुत अधिक मिलती है। हम इसके बारे में कैसे जानते हैं?

खैर, अगर n वास्तविक बड़ा हो जाता है, तो हमें परवाह नहीं है कि हम n या n वर्ग में क्या जोड़ सकते हैं।

बड़े n के लिए, n वर्ग, n की तुलना में अधिक बड़ा है।

बिग ओ हमें बताता है कि चीजों को जोड़ने के लिए चीजों को जोड़ना ज्यादा कठिन है। O (n वर्ग) बड़े n के लिए O (n) से अधिक है। इसका मतलब है: यदि n वास्तविक बड़ी हो जाती है, तो n मिश्रित चीजों को जोड़ने के लिए, केवल n मिश्रित चीजों को जोड़ने में अधिक समय लगना चाहिए।

बिग ओ हमारे लिए काम हल नहीं करता है। बिग ओ हमें बताते हैं कि काम कितना कठिन है।

मेरे पास ताश का एक डेक है। मैंने उन्हें छांटा। आपने मदद की। धन्यवाद।

क्या कार्डों को क्रमबद्ध करने का एक और अधिक तेज़ तरीका है? क्या बड़ा ओ हमारी मदद कर सकता है?

हाँ, एक और तेज़ तरीका है! सीखने में कुछ समय लगता है, लेकिन यह काम करता है ... और यह काफी तेजी से काम करता है। आप इसे भी आजमा सकते हैं, लेकिन प्रत्येक चरण के साथ अपना समय लें और अपनी जगह न खोएं।

एक डेक सॉर्ट करने के इस नए तरीके में, हम कार्डों के जोड़े की जांच नहीं करते हैं जिस तरह से हमने थोड़ी देर पहले की थी। इस डेक को सॉर्ट करने के लिए आपके नए नियम यहां दिए गए हैं:

एक: मैं अब हम काम डेक के हिस्से में एक कार्ड का चयन करें। आप चाहें तो मेरे लिए एक चुन सकते हैं। (पहली बार हम ऐसा करते हैं, "डेक का हिस्सा जिस पर हम काम करते हैं" वह निश्चित रूप से पूरा डेक है।)

दो: मैंने आपके द्वारा चुने गए कार्ड पर डेक को अलग कर दिया। यह कैसा दिखावा है; मैं कैसे छपता हूँ? खैर, मैं एक-एक करके स्टार्ट कार्ड से नीचे जाता हूं, और मैं एक ऐसे कार्ड की तलाश करता हूं जो स्प्ले कार्ड से ज्यादा ऊंचा हो।

तीन: मैं अंत कार्ड से ऊपर जाता हूं, और मैं एक ऐसे कार्ड की तलाश करता हूं जो स्प्ले कार्ड से कम हो।

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

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

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

मैं भागों में डेक को तोड़ता हूं, और प्रत्येक भाग को छांटता हूं, अधिक छोटे और अधिक छोटे, और कुछ समय में मेरे पास करने के लिए अधिक काम नहीं होता है। अब यह सभी नियमों के साथ धीमी लग सकती है। लेकिन मेरा विश्वास करो, यह बिल्कुल भी धीमा नहीं है। यह चीजों को छांटने के पहले तरीके की तुलना में बहुत कम काम है!

इस प्रकार को क्या कहा जाता है? इसे क्विक सॉर्ट कहा जाता है! इस तरह की कार होरे नामक एक व्यक्ति द्वारा बनाई गई थी और उन्होंने इसे क्विक सॉर्ट कहा था। अब, Quick Sort को हर समय उपयोग किया जाता है!

त्वरित सॉर्ट छोटे में बड़े डेक को तोड़ता है। यह कहना है, यह छोटे लोगों में बड़े कार्यों को तोड़ता है।

हममम। वहाँ एक नियम हो सकता है, मुझे लगता है। बड़े कार्यों को छोटा बनाने के लिए, उन्हें तोड़ दें।

यह सॉर्ट काफी तेज है। कितनी जल्दी? बिग ओ हमें बताता है: इस प्रकार को ओ (एन लॉग एन) काम करने की जरूरत है, इस मामले में।

क्या यह पहली तरह से कम या ज्यादा तेज है? बिग ओ, कृपया मदद करें!

पहला प्रकार O (n वर्ग) था। लेकिन क्विक सॉर्ट O (n log n) है। आप जानते हैं कि n लॉग एन, बड़े वर्ग के लिए n वर्ग से कम है, है ना? खैर, यह है कि हम कैसे जानते हैं कि त्वरित क्रमबद्ध तेजी है!

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

मैं त्वरित सॉर्ट क्यों चुनूं? मुझे काम करना पसंद नहीं है, बिल्कुल! मैं चाहता हूं कि काम जल्द से जल्द पूरा हो।

मुझे कैसे पता चलेगा क्विक सॉर्ट कम काम है? मुझे पता है कि O (n log n) O (n वर्ग) से कम है। O का आकार अधिक छोटा है, इसलिए Quick Sort कम काम है!

अब आप मेरे दोस्त बिग ओ को जानते हैं। वह हमें कम काम करने में मदद करता है। और यदि आप बड़े ओ जानते हैं, तो आप कम काम भी कर सकते हैं!

तुमने मेरे साथ वो सब सीखा! तुम बहुत ही स्मार्ट हो! आपको बहुत - बहुत धन्यवाद!

अब वह काम पूरा हो गया है, चलो खेलते हैं!

---

[१]: एक समय में एक से n तक सभी चीजों को धोखा देने और जोड़ने का एक तरीका है। गौस नाम के कुछ बच्चे को यह पता चला कि जब वह आठ साल का था। मैं हालांकि वह स्मार्ट नहीं हूं, इसलिए मुझसे मत पूछो कि उसने यह कैसे किया ।

Answer 22

मैंने समय जटिलता को समझने के लिए और अधिक सरल तरीका अपनाया है वह समय जटिलता की गणना के लिए सबसे आम मीट्रिक बिग ओ नोटेशन है। यह सभी स्थिर कारकों को हटा देता है ताकि एन के संबंध में चलने के समय का अनुमान लगाया जा सके क्योंकि एन अनंतता के निकट आता है। सामान्य तौर पर आप इसे इस तरह से सोच सकते हैं:

statement;

स्थिर है। कथन के चलने का समय N के संबंध में नहीं बदलेगा

for ( i = 0; i < N; i++ )
  statement;

रैखिक है। लूप का रनिंग टाइम N के समानुपाती होता है। जब N डबल्स करता है, तो रनिंग टाइम होता है।

for ( i = 0; i < N; i++ ) 
{
for ( j = 0; j < N; j++ )
  statement;
}

द्विघात है। दो छोरों का रनिंग टाइम N के वर्ग के समानुपाती होता है। जब N डबल्स होता है, तो रनिंग टाइम N * N से बढ़ जाता है।

while ( low <= high ) 
{
 mid = ( low + high ) / 2;
 if ( target < list[mid] )
 high = mid - 1;
 else if ( target > list[mid] )
  low = mid + 1;
else break;
}

लघुगणक है। एल्गोरिथ्म का रनिंग समय N की संख्या से विभाजित किया जा सकता है 2 के आनुपातिक है। ऐसा इसलिए है क्योंकि एल्गोरिथ्म कार्य क्षेत्र को प्रत्येक पुनरावृत्ति के साथ आधे में विभाजित करता है।

void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

एन * लॉग (एन) है। रनिंग टाइम में एन लूप्स (पुनरावृत्त या पुनरावर्ती) होते हैं जो लॉगरिदमिक होते हैं, इस प्रकार एल्गोरिथ्म रैखिक और लॉगरिदमिक का एक संयोजन है।

सामान्य तौर पर, प्रत्येक वस्तु के साथ एक आयाम में कुछ करना रैखिक होता है, दो आयामों में प्रत्येक वस्तु के साथ कुछ करना द्विघात होता है, और कार्य क्षेत्र को आधा भाग में विभाजित करना लघुगणक है। घन, घातीय और वर्गमूल जैसे अन्य बिग ओ उपाय हैं, लेकिन वे लगभग आम नहीं हैं। बिग ओ नोटेशन को ओ () के रूप में वर्णित किया गया है जहां माप है। Quicksort एल्गोरिथ्म को O (N * log (N)) के रूप में वर्णित किया जाएगा।

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

• और देखें: यहाँ

Answer 23

मान लीजिए कि आप हैरी पॉटर का ऑर्डर करते हैं: अमेज़न से 8-फिल्म कलेक्शन [ब्लू-रे] को पूरा करें और उसी समय ऑनलाइन उसी फिल्म का कलेक्शन डाउनलोड करें। आप परीक्षण करना चाहते हैं कि कौन सी विधि तेज है। डिलीवरी आने में लगभग एक दिन लगता है और डाउनलोड लगभग 30 मिनट पहले पूरा हो जाता है। महान! तो यह एक तंग दौड़ है।

क्या होगा अगर मैं द लॉर्ड ऑफ द रिंग्स, ट्वाइलाइट, द डार्क नाइट ट्रिलॉजी आदि जैसी कई ब्लू-रे फिल्में ऑर्डर करता हूं और एक ही समय में सभी फिल्में डाउनलोड करता हूं? इस बार, वितरण पूरा होने में अभी भी एक दिन है, लेकिन ऑनलाइन डाउनलोड पूरा होने में 3 दिन लगते हैं। ऑनलाइन शॉपिंग के लिए, खरीदी गई वस्तु (इनपुट) की संख्या डिलीवरी के समय को प्रभावित नहीं करती है। आउटपुट स्थिर है। हम इसे O (1) कहते हैं ।

ऑनलाइन डाउनलोडिंग के लिए, डाउनलोड का समय सीधे फिल्म फ़ाइल आकार (इनपुट) के लिए आनुपातिक है। हम इसे O (n) कहते हैं ।

प्रयोगों से, हम जानते हैं कि ऑनलाइन शॉपिंग, ऑनलाइन डाउनलोडिंग से बेहतर है। बड़े ओ नोटेशन को समझना बहुत महत्वपूर्ण है क्योंकि यह एल्गोरिदम की मापनीयता और दक्षता का विश्लेषण करने में आपकी मदद करता है।

नोट: बिग ओ नोटेशन एक एल्गोरिथ्म के सबसे खराब स्थिति का प्रतिनिधित्व करता है। मान लेते हैं कि O (1) और O (n) उपरोक्त उदाहरण के सबसे खराब स्थिति हैं।

संदर्भ : http://carlcheo.com/compsci

Answer 24

मान लें कि हम एक एल्गोरिथ्म ए के बारे में बात कर रहे हैं , जिसे आकार n के डेटासेट के साथ कुछ करना चाहिए ।

फिर O( <some expression X involving n> )इसका मतलब है, सरल अंग्रेजी में:

यदि आप A को निष्पादित करते समय अशुभ होते हैं, तो इसे पूरा करने के लिए X (n) संचालन जितना हो सकता है।

जैसा कि होता है, कुछ कार्य हैं ( एक्स (एन) के कार्यान्वयन के रूप में उनके बारे में सोचो ) जो अक्सर होते हैं। ये अच्छी तरह से जाना जाता है और आसानी से तुलना कर रहे हैं (उदाहरण: , , , , , आदि ..)1Log NNN^2N!

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

सामान्य तौर पर, हमारा लक्ष्य एक एल्गोरिथम ए को इस तरह से खोजना या संरचना करना होगा कि इसमें एक फ़ंक्शन होगा जो X(n)संभव के रूप में कम संख्या में लौटता है।

Answer 25

यदि आपके सिर में अनंतता की उपयुक्त धारणा है, तो एक बहुत ही संक्षिप्त विवरण है:

बिग ओ नोटेशन आपको एक असीम बड़ी समस्या को हल करने की लागत बताता है।

और इसके अलावा

लगातार कारक नगण्य हैं

यदि आप एक ऐसे कंप्यूटर में अपग्रेड करते हैं, जो आपके एल्गोरिथ्म को दो बार तेज गति से चला सकता है, तो बड़ा O नोटेशन उस पर ध्यान नहीं देगा। लगातार कारक सुधार उस पैमाने पर भी ध्यान देने के लिए बहुत छोटे हैं जो बड़े ओ संकेतन के साथ काम करता है। ध्यान दें कि यह बड़े ओ नोटेशन के डिजाइन का एक जानबूझकर हिस्सा है।

हालांकि एक स्थिर कारक की तुलना में "बड़ा" कुछ भी पता लगाया जा सकता है, हालांकि।

जब अभिकलन करने में रुचि रखते हैं जिसका आकार "बड़ा" होता है जिसे लगभग अनंत माना जाता है, तो बड़ी O संकेतन लगभग आपकी समस्या को हल करने की लागत है।

---

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

Answer 26

"बिग ओ" अंकन की एक स्पष्ट अंग्रेजी व्याख्या क्या है?

बहुत जल्दी नोट:

"बिग ओ" में ओ का अर्थ "ऑर्डर" (या ठीक "ऑर्डर ऑफ") के रूप में है,
इसलिए आप इसका विचार शाब्दिक रूप से प्राप्त कर सकते हैं कि उनकी तुलना करने के लिए कुछ ऑर्डर करने के लिए इसका उपयोग किया जाता है।

• "बिग ओ" दो काम करता है:

  1. अनुमान लगाता है कि किसी कार्य को पूरा करने के लिए आपके कंप्यूटर की विधि के कितने चरण हैं।
  2. यह निर्धारित करने के लिए दूसरों के साथ तुलना करने के लिए प्रक्रिया की सुविधा दें कि क्या यह अच्छा है या नहीं?
  3. "बिग ओ 'मानकीकृत के साथ उपरोक्त दोनों को प्राप्त करता है Notations।

• सात सबसे ज्यादा इस्तेमाल किए जाने वाले नोटेशन हैं

  1. O (1), का अर्थ है कि आपके कंप्यूटर को 1चरणबद्ध तरीके से कार्य मिलता है , यह उत्कृष्ट है, क्रम संख्या 1
  2. O (logN), का अर्थ है आपका कंप्यूटर logNचरणों के साथ एक कार्य पूरा करता है , इसका अच्छा, क्रम संख्या 2
  3. O (N), Nचरणों के साथ एक कार्य समाप्त करें, इसका उचित, क्रम संख्या 3
  4. O (NlogN), O(NlogN)चरणों के साथ एक कार्य समाप्त करता है , यह अच्छा नहीं है, क्रम संख्या 4
  5. O (N ^ 2), N^2चरणों के साथ एक कार्य करें, यह खराब है, क्रम संख्या 5
  6. O (2 ^ N), 2^Nचरणों के साथ एक कार्य करें, यह भयानक है, क्रम संख्या 6
  7. ओ (एन!), N!चरणों के साथ एक कार्य करें, यह भयानक है, ऑर्डर नंबर 7

मान लीजिए कि आपको नोटेशन मिलता है O(N^2), न केवल आप स्पष्ट हैं कि विधि किसी कार्य को पूरा करने के लिए N * N कदम उठाती है, बल्कि आप यह भी देखते हैं कि यह O(NlogN)उसकी रैंकिंग से अच्छी नहीं है ।

कृपया अपनी बेहतर समझ के लिए कृपया पंक्ति के अंत में ऑर्डर पर ध्यान दें। यदि सभी संभावनाओं पर विचार किया जाए तो 7 से अधिक अंक हैं।

सीएस में, किसी कार्य को पूरा करने के लिए चरणों के सेट को एल्गोरिदम कहा जाता है।
शब्दावली में, बिग ओ संकेतन का उपयोग एल्गोरिथ्म के प्रदर्शन या जटिलता का वर्णन करने के लिए किया जाता है।

इसके अलावा, बिग ओ सबसे खराब स्थिति स्थापित करता है या ऊपरी-बाध्य चरणों को मापता है।
आप सर्वश्रेष्ठ मामले के लिए बिग-Ω (बिग-ओमेगा) का उल्लेख कर सकते हैं।

बिग-((बिग-ओमेगा) अंकन (लेख) | खान अकादमी

• सारांश
  "बिग ओ" एल्गोरिथम के प्रदर्शन का वर्णन करता है और इसका मूल्यांकन करता है।

  या इसे औपचारिक रूप से संबोधित करते हैं, "बिग ओ" एल्गोरिदम को वर्गीकृत करता है और तुलना प्रक्रिया को मानकीकृत करता है।

Answer 27

इसे देखने का सबसे सरल तरीका (सादे अंग्रेजी में)

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

उपरोक्त कथन एक अच्छी शुरुआत है लेकिन पूरी तरह से सच नहीं है।

एक अधिक सटीक व्याख्या (गणितीय)

मान लीजिए

n = इनपुट मापदंडों की संख्या

टी (एन) = वास्तविक फ़ंक्शन जो एल्गोरिथ्म के चलने के समय को एन के एक समारोह के रूप में व्यक्त करता है

सी = एक स्थिर

f (n) = एक अनुमानित फ़ंक्शन जो एल्गोरिथ्म के चलने के समय को n के फ़ंक्शन के रूप में व्यक्त करता है

फिर जहां तक ​​बिग ओ का संबंध है, तब तक सन्निकटन f (n) को काफी अच्छा माना जाता है, जब तक कि नीचे की स्थिति सत्य है।

lim     T(n) ≤ c×f(n)
n→∞

समीकरण को n के रूप में पढ़ा जाता है। n अनंत के करीब आता है, n का n, c के f के बराबर या उससे कम होता है।

बड़े ओ संकेतन में यह लिखा है

T(n)∈O(n)

इसे T के रूप में पढ़ा जाता है n n के बड़े O में है।

वापस अंग्रेजी में

उपरोक्त गणितीय परिभाषा के आधार पर, यदि आप कहते हैं कि आपका एल्गोरिथ्म n का एक बड़ा O है, तो इसका मतलब है कि यह n (इनपुट मापदंडों की संख्या) या तेज़ी से कार्य है । यदि आपका एल्गोरिथ्म n का बड़ा O है, तो यह स्वतः n वर्ग का भी बड़ा O है।

N का बड़ा O का अर्थ है कि मेरा एल्गोरिथ्म कम से कम उतना ही तेज चलता है। आप अपने एल्गोरिथ्म के बिग ओ अंकन को नहीं देख सकते हैं और इसकी धीमी गति को कह सकते हैं। आप केवल इसका व्रत कह सकते हैं।

यूसी बर्कले से बिग ओ पर एक वीडियो ट्यूटोरियल के लिए इसे देखें । यह वास्तव में एक सरल अवधारणा है। यदि आप प्रोफेसर शेवचुक (उर्फ भगवान स्तर के शिक्षक) को यह समझाते हुए सुनते हैं, तो आप कहेंगे "ओह, यह सब है!"।

Answer 28

मुझे बड़े ओ नोटेशन के बारे में वास्तव में बहुत अच्छा स्पष्टीकरण मिला, खासकर किसी ऐसे व्यक्ति के लिए जो गणित में बहुत अधिक नहीं है।

https://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/

एल्गोरिथ्म के प्रदर्शन या जटिलता का वर्णन करने के लिए कंप्यूटर विज्ञान में बिग ओ नोटेशन का उपयोग किया जाता है। बिग ओ विशेष रूप से सबसे खराब स्थिति का वर्णन करता है, और इसका उपयोग एल्गोरिदम द्वारा आवश्यक निष्पादन समय या उपयोग किए गए स्थान (जैसे मेमोरी या डिस्क में) का वर्णन करने के लिए किया जा सकता है।

जो भी लोग प्रोग्रामिंग पर्ल या किसी अन्य कंप्यूटर साइंस की किताबें पढ़ते हैं और गणित में ग्राउंडिंग नहीं करते हैं, वे एक दीवार से टकराएंगे, जब वे अध्यायों तक पहुंच जाते हैं जो ओ (एन लॉग एन) या अन्य प्रतीत होता है पागल सिंटैक्स का उल्लेख करते हैं। उम्मीद है कि यह लेख आपको बिग ओ और लॉगरिथम की मूल बातें समझने में मदद करेगा।

एक प्रोग्रामर के रूप में पहला और एक गणितज्ञ दूसरा (या शायद तीसरा या चौथा) मुझे बिग ओ को अच्छी तरह से समझने का सबसे अच्छा तरीका कोड में कुछ उदाहरणों का उत्पादन करना था। तो, नीचे विवरणों और उदाहरणों के साथ विकास के कुछ सामान्य आदेश दिए गए हैं जहां संभव हो।

हे (1)

O (1) एक एल्गोरिथ्म का वर्णन करता है जो इनपुट डेटा सेट के आकार की परवाह किए बिना हमेशा एक ही समय (या स्थान) में निष्पादित होगा।

bool IsFirstElementNull(IList<string> elements) {
    return elements[0] == null;
}

पर)

O (N) एक एल्गोरिथम का वर्णन करता है जिसका प्रदर्शन रैखिक रूप से और इनपुट डेटा सेट के आकार के प्रत्यक्ष अनुपात में बढ़ेगा। नीचे दिए गए उदाहरण से यह भी पता चलता है कि बिग ओ सबसे खराब स्थिति के प्रदर्शन के पक्षधर हैं; लूप के लिए किसी भी पुनरावृत्ति के दौरान एक मिलान स्ट्रिंग पाया जा सकता है और फ़ंक्शन जल्दी वापस आ जाएगा, लेकिन बिग ओ अंकन हमेशा ऊपरी सीमा को ग्रहण करेगा जहां एल्गोरिदम अधिकतम संख्या में पुनरावृत्तियों का प्रदर्शन करेगा।

bool ContainsValue(IList<string> elements, string value) {
    foreach (var element in elements)
    {
        if (element == value) return true;
    }

    return false;
} 

ओ (एन ² )

O (N ² ) एक एल्गोरिथ्म का प्रतिनिधित्व करता है जिसका प्रदर्शन सीधे इनपुट डेटा सेट के आकार के वर्ग के समानुपाती होता है। यह एल्गोरिदम के साथ आम है जो डेटा सेट पर नेस्टेड पुनरावृत्तियों को शामिल करता है। डीप नेस्टेड पुनरावृत्तियों का परिणाम O (N ³ ), O (N ⁴ ) आदि होगा।

bool ContainsDuplicates(IList<string> elements) {
    for (var outer = 0; outer < elements.Count; outer++)
    {
        for (var inner = 0; inner < elements.Count; inner++)
        {
            // Don't compare with self
            if (outer == inner) continue;

            if (elements[outer] == elements[inner]) return true;
        }
    }

    return false;
}

ओ (2 ^एन )

O (2 ^N ) एक एल्गोरिथ्म को दर्शाता है जिसका विकास इनपुट डेटा सेट के प्रत्येक एडिटॉन के साथ दोगुना हो जाता है। ओ (2 ^एन ) फ़ंक्शन का विकास वक्र घातीय है - बहुत उथले से शुरू होता है, फिर मौसम के अनुसार बढ़ रहा है। O (2 ^N ) फ़ंक्शन का एक उदाहरण फाइबोनैचि संख्याओं की पुनरावर्ती गणना है:

int Fibonacci(int number) {
    if (number <= 1) return number;

    return Fibonacci(number - 2) + Fibonacci(number - 1);
}

लघुगणक

Logarithms समझाने के लिए थोड़ा पेचीदा मामला है इसलिए मैं एक सामान्य उदाहरण का उपयोग करूँगा:

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

इस प्रकार के एल्गोरिथ्म को ओ (लॉग एन) के रूप में वर्णित किया गया है। बाइनरी सर्च उदाहरण में वर्णित डेटा सेटों की पुनरावृत्ति रुकने से एक विकास वक्र उत्पन्न होता है जो शुरुआत में चोटियों और डेटा सेटों के आकार के बढ़ने के साथ धीरे-धीरे बाहर निकलता है जैसे कि 10 आइटम वाले इनपुट डेटा सेट को पूरा होने में एक सेकंड लगता है, एक डेटा सेट 100 आइटम वाले को दो सेकंड लगते हैं, और 1000 आइटम वाले डेटा सेट में तीन सेकंड लगेंगे। इनपुट डेटा सेट के आकार को दोगुना करने से इसकी वृद्धि पर बहुत कम प्रभाव पड़ता है क्योंकि एल्गोरिथ्म के एकल पुनरावृत्ति के बाद डेटा सेट आधा हो जाएगा और इसलिए एक इनपुट डेटा के साथ सममूल्य पर आधा आकार निर्धारित होता है। यह बाइनरी डेटा जैसे बड़े डेटा सेट के साथ काम करते समय एल्गोरिदम को बेहद कुशल बनाता है।

Answer 29

यह एक बहुत ही सरल स्पष्टीकरण है, लेकिन मुझे आशा है कि यह सबसे महत्वपूर्ण विवरण को कवर करता है।

मान लीजिए कि समस्या से निपटने के लिए आपका एल्गोरिथ्म कुछ 'कारकों' पर निर्भर करता है, उदाहरण के लिए आइए इसे N और X बनाते हैं।

एन और एक्स के आधार पर, आपके एल्गोरिथ्म को कुछ ऑपरेशनों की आवश्यकता होगी, उदाहरण के लिए यह 3(N^2) + log(X)काम कर रहे केस में उदाहरण के लिए ।

चूंकि बिग-ओ लगातार कारक (उर्फ 3) के बारे में बहुत ज्यादा परवाह नहीं करता है, आपके एल्गोरिथ्म का बिग-ओ है O(N^2 + log(X))। यह मूल रूप से 'आपके एल्गोरिथ्म को इस मामले में सबसे खराब स्थिति के लिए आवश्यक संचालन की मात्रा' का अनुवाद करता है।

Answer 30

प्रस्तावना

एल्गोरिथ्म : एक समस्या को हल करने के लिए प्रक्रिया / सूत्र

---

एल्गोरिदम का विश्लेषण कैसे करते हैं और हम एक दूसरे के खिलाफ एल्गोरिदम की तुलना कैसे कर सकते हैं?

उदाहरण: आपको और एक मित्र को 0 से N तक संख्याओं को योग करने के लिए एक फ़ंक्शन बनाने के लिए कहा जाता है। आप f (x) के साथ आते हैं और आपका मित्र g (x) के साथ आता है। दोनों कार्यों का एक ही परिणाम है, लेकिन एक अलग एल्गोरिथ्म। एल्गोरिदम की दक्षता की तुलनात्मक रूप से तुलना करने के लिए हम बिग-ओ नोटेशन का उपयोग करते हैं ।

बिग-ओ नोटेशन: वर्णन करता है कि इनपुट के सापेक्ष कितनी जल्दी रनटाइम बढ़ेगा क्योंकि इनपुट मनमाने ढंग से बड़े हो जाते हैं।

3 मुख्य टेकअवे:

1. तुलना करें कि रनटाइम कैसे बढ़ता है, सटीक रनटाइम की तुलना नहीं करता है (हार्डवेयर पर निर्भर करता है)
2. केवल रनटाइम से संबंधित इनपुट के सापेक्ष बढ़ते हैं (n) के
3. जैसा कि n मनमाने ढंग से बड़ा हो जाता है, उन शब्दों पर ध्यान केंद्रित करें जो सबसे तेजी से बढ़ेंगे क्योंकि n बड़ी हो जाती है (अनन्तता सोचो) AKA asptptotic विश्लेषण

अंतरिक्ष की जटिलता: समय की जटिलता से अलग, हम अंतरिक्ष की जटिलता (एक मेमोरी / अंतरिक्ष एक एल्गोरिथ्म का उपयोग करता है) के बारे में भी परवाह करते हैं। संचालन के समय की जांच करने के बजाय, हम मेमोरी के आवंटन के आकार की जांच करते हैं।