निर्धारित करना कि क्या एल्गोरिथ्म हे (लॉग एन)

Question

मैं अपने सीएस सिद्धांत को ताज़ा कर रहा हूं, और मैं जानना चाहता हूं कि कैसे एक एल्गोरिथ्म ओ (लॉग एन) जटिलता की पहचान की जाए। विशेष रूप से, क्या इसकी पहचान करने का एक आसान तरीका है?

मुझे ओ (एन) के साथ पता है, आपके पास आमतौर पर एक ही लूप है; ओ (एन ^ 2) एक डबल लूप है; O (n ^ 3) एक ट्रिपल लूप है, आदि O (लॉग एन) के बारे में कैसे?

Comments

stackoverflow.com/questions/749819/… या यह वास्तव में लंबा पढ़ा: stackoverflow.com/questions/487258/…

— wkl

आह, वह एक जगह है जो मैंने नहीं

— देखी

Answer 1

मुझे ओ (एन) के साथ पता है, आपके पास आमतौर पर एक ही लूप है; ओ (एन ^ 2) एक डबल लूप है; O (n ^ 3) एक ट्रिपल लूप है, आदि O (लॉग एन) के बारे में कैसे?

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

for (i = 0; i < log2(input.count); i++) {
    doSomething(...);
}

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

क्या यह अनुभव से जानने में मदद करता है कि एल्गोरिदम जो अपने इनपुट को बार-बार विभाजित करते हैं, उनके प्रदर्शन के घटक के रूप में 'लॉग एन' होता है? ज़रूर। लेकिन विभाजन के लिए मत देखो और इस निष्कर्ष पर कूदो कि एल्गोरिथ्म का प्रदर्शन ओ (लॉग एन) है - यह ओ (एन लॉग एन) जैसा कुछ हो सकता है, जो काफी अलग है।

Comments

ध्यान दें कि "आकार के लघुगणक के आदेश पर" कहने के लिए एक अधिक बोलचाल का तरीका "आकार में अंकों की संख्या के क्रम पर" है।

जब स्केलिंग की बात की जाती है तो @Caleb लॉगरिदम का वास्तविक आधार महत्वहीन होता है।

@ कालेब की बात निरपेक्षता का बड़े-ओ से कोई मतलब नहीं है। एक शब्दांकन आपको बेहतर लग सकता है: जब अंकों की संख्या दोगुनी हो जाती है, तो चरणों की संख्या दोगुनी हो जाती है।

@ कालेब की बात निरपेक्षता का बड़े-ओ से कोई मतलब नहीं है। एक शब्दांकन आपको बेहतर लग सकता है: जब अंकों की संख्या दोगुनी हो जाती है, तो चरणों की संख्या दोगुनी हो जाती है।

@ ThorbjørnRavnAndersen हां, यही "आकार का लघुगणक" है। मुझे यकीन नहीं है कि वाक्यांश के साथ आपकी समस्या क्या है, सिवाय इसके कि आपने इसे अलग तरीके से कहने के लिए चुना होगा। मौलिक रूप से, मुझे लगता है कि हम सहमत हैं।

— कालेब

Answer 2

विचार यह है कि एक एल्गोरिथ्म है O(log n)यदि 1 से 1 संरचना के माध्यम से स्क्रॉल करने के बजाय, आप संरचना को आधे से अधिक बार में विभाजित करते हैं और प्रत्येक विभाजन के लिए लगातार संचालन करते हैं। खोज एल्गोरिदम जहां उत्तर स्थान को अलग रखता है, विभाजित होते हैं O(log n)। इसका एक उदाहरण द्विआधारी खोज है , जहां आप एक क्रमबद्ध सरणी को आधे से अधिक बार विभाजित करते रहते हैं और जब तक आप संख्या नहीं पाते हैं।

नोट: आपको जरूरी नहीं कि यहां तक ​​कि हिस्सों में विभाजित होना चाहिए।

Comments

क्या होगा यदि मैं इनपुट को दो में विभाजित करता हूं और फिर इसे विभाजित करने से पहले शेष पर 2 ^ (n / 2) बार पुनरावृत्ति करता हूं? (बेशक मुझे पता है कि तब, मैं सिर्फ एक उदाहरण दिखाना चाहता था जहां यह सरल दृष्टिकोण विफल हो जाता है)।

— तमसे सजेलेई

@ माफिश वह दुर्लभ किस्म है। खोज करते समय यह शानदार रूप से दुर्लभ है।

— डोनाल्ड फेलो

@ डॉनलफ़ेलोज़ एल्गोरिथम सिद्धांत एक अनुभवजन्य विज्ञान नहीं है। और सवाल खोज के बारे में नहीं था, यह सिर्फ इतना है कि log nलोगों में ट्रिगर बाइनरी सर्च रिफ्लेक्स का उल्लेख है ।

— तमसे सजेलेई

विभाजन एल्गोरिथ्म हे (लॉग एन) नहीं बनाता है, यह (आमतौर पर) लॉग एन के कारक को बड़े-ओ सीमा में जोड़ता है। भारी और मर्जर्ट जैसे पुनरावर्ती प्रकार इसके आदर्श उदाहरण हैं: वे इनपुट का विभाजन करते हैं, लेकिन फिर वे परिणामी दोनों स्थितियों का पुनरावर्ती विभाजन करते हैं। परिणाम ओ (एन लॉग एन) प्रदर्शन है।

— कालेब

@ आतिश: अच्छी बात है। इस उत्तर के साथ मेरा लक्ष्य यह है कि प्रश्न की प्रकृति को देखते हुए इसे यथासंभव सरल रखा जाए। मैंने लाइन को "आप संरचना को आधे में विभाजित करते हैं ..." को "आप संरचना को आधे में विभाजित करते हैं ... और प्रत्येक विभाजन के लिए लगातार संचालन करें" बस इस बिंदु को प्राप्त करने का प्रयास करें।

— केसी पैटन

Answer 3

विशिष्ट उदाहरण वे हैं जो द्विआधारी खोज से निपटते हैं। उदाहरण के लिए, एक द्विआधारी खोज एल्गोरिथ्म आमतौर पर है O(log n)।

यदि आपके पास एक बाइनरी सर्च ट्री है , तो लुकअप, इंसर्ट और डिलीट सभी O(log n)जटिलताएं हैं।

किसी भी स्थिति में जहां आप अंतरिक्ष को लगातार विभाजित करते हैं, अक्सर एक log nघटक शामिल होगा । यही कारण है कि कई सॉर्टिंग एल्गोरिदम में O(nlog n)जटिलता होती है, क्योंकि वे अक्सर एक सेट और सॉर्ट करते हैं जैसे वे जाते हैं।

Answer 4

यदि आप इसे "सिंगल लूप -> ओ (एन), डबल लूप -> ओ (एन ^ 2)" के रूप में सरल चाहते हैं, तो इसका उत्तर संभवतः "ट्री -> ओ (लॉग एन)" है। अधिक सटीक रूप से एक पेड़ को जड़ से एक (सभी नहीं!) पत्ती या दूसरे तरीके से चक्कर लगाना। हालाँकि, ये सभी ओवरसिम्प्लीफिकेशन हैं।

Comments

तो, मेरे जवाब में क्या गलत है? मैं रचनात्मक आलोचना के लिए खुला हूं।

— स्कारफ्रिज

Answer 5

आप जानना चाहते हैं कि क्या एक एल्गोरिथ्म ओ (लॉग एन) है, तो पहचानने का एक आसान तरीका है।

ठीक है: बस इसे चलाने और समय। इसे इनपुट के लिए 1.000, 10.000, 100.000 और एक मिलियन में चलाएं।

यदि आप 3,4,5,6 सेकंड (या कुछ एकाधिक) के चलने के समय की तरह देखते हैं, तो आप सुरक्षित रूप से कह सकते हैं कि यह O (लॉग एन) है। यदि यह अधिक पसंद है: 1,10,100,1000 सेकंड तो यह शायद O (N) है। और अगर यह 3,40,500,6000 सेकंड की तरह है तो यह ओ (एन लॉग एन) है।

Comments

हर किसी को यह उत्तर एक अपवोट और एक

— डाउनवोट