क्या एल्गोरिथ्म के कारण O (लॉग एन) जटिलता होगी?

Question

बिग-ओ का मेरा ज्ञान सीमित है, और जब लॉग शब्द समीकरण में दिखाई देते हैं तो यह मुझे और भी अधिक फेंक देता है।

क्या कोई मुझे सरल शब्दों में समझा सकता है कि O(log n)एल्गोरिथ्म क्या है? लघुगणक कहाँ से आता है?

यह विशेष रूप से तब सामने आया जब मैं इस मध्यावधि अभ्यास प्रश्न को हल करने की कोशिश कर रहा था:

X (1..n) और Y (1..n) पूर्णांकों की दो सूचियाँ सम्‍मिलित करते हैं, प्रत्येक क्रमबद्ध तरीके से क्रमबद्ध होती हैं। सभी 2n संयुक्त तत्वों के माध्य (या nth सबसे छोटे पूर्णांक) को खोजने के लिए O (लॉग एन) -टाइम एल्गोरिथ्म दें। पूर्व के लिए, X = (4, 5, 7, 8, 9) और Y = (3, 5, 8, 9, 10), तो 7 संयुक्त सूची का माध्यिका है (3, 4, 5, 5, 7) , 8, 8, 9, 9, 10)। [संकेत: द्विआधारी खोज की अवधारणाओं का उपयोग करें]

Comments

O(log n)के रूप में देखा जा सकता है: यदि आप समस्या का आकार दोगुना करते हैं n, तो आपके एल्गोरिथ्म को केवल निरंतर चरणों की आवश्यकता होती है।

— फिमुमे 20

इस वेबसाइट ने मुझे udnerstand Big O नोटेशन की मदद की: recursive-design.com/blog/2010/12/07/…

— ब्रैड

मैं सोच रहा हूँ कि 7 ऊपर के उदाहरण का मध्यक्रम क्यों है, fwiw यह 8 भी हो सकता है। उदाहरण का इतना अच्छा नहीं है?

— 21

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

— क्रिज़ीस्टोफ़ कोज़िएल्स्की

धन्यवाद दोस्तों, एक पिछली समस्या पर काम कर रहे हैं और जल्द ही इस के लिए मिल जाएगा, बहुत जवाब की सराहना करते हैं! यह अध्ययन करने के लिए बाद में वापस

— आएगा

Answer 1

मुझे इस बात से सहमत होना होगा कि जब आप O (log n) एल्गोरिथम देखते हैं तो यह बहुत अजीब होता है ... पृथ्वी पर वह लघुगणक कहाँ से आता है? हालाँकि, यह पता चला है कि कई अलग-अलग तरीके हैं जिनसे आप बिग-ओ नोटेशन में दिखा सकते हैं। यहाँ कुछ है:

एक निरंतर द्वारा विभाजित

कोई भी संख्या n लें; कहते हैं, 16. इससे पहले कि आप संख्या को एक से कम या एक के बराबर कितनी बार विभाजित कर सकते हैं? 16 के लिए, हमारे पास वह है

16 / 2 = 8
 8 / 2 = 4
 4 / 2 = 2
 2 / 2 = 1

ध्यान दें कि यह पूरा होने के लिए चार कदम उठाता है। दिलचस्प बात यह है कि हमारे पास वह लॉग ₂ 16 = 4. हम्म् ... 128 क्या है?

128 / 2 = 64
 64 / 2 = 32
 32 / 2 = 16
 16 / 2 = 8
  8 / 2 = 4
  4 / 2 = 2
  2 / 2 = 1

इसने सात कदम उठाए, और लॉग ₂ 128 = 7. क्या यह एक संयोग है? नहीं! इसके लिए एक अच्छा कारण है। मान लीजिए कि हम एक संख्या n को 2 i बार से विभाजित करते हैं। फिर हम संख्या n / 2 मिलता है ^मैं । यदि हम i के मूल्य के लिए हल करना चाहते हैं, जहां यह मान अधिकतम 1 पर है, तो हम प्राप्त करते हैं

n / 2 ^i। 1

एन ⁱ 2 ^मैं

₂ n ≤ i लॉग करें

दूसरे शब्दों में, यदि हम एक पूर्णांक को ऐसे लेते हैं जैसे कि मैं n लॉग ₂ एन, तो n को आधे i समय में विभाजित करने के बाद हमारा मान 1 होगा जो कि सबसे अधिक है। सबसे छोटा i जिसके लिए यह गारंटी है वह लगभग ₂ लॉग है n, इसलिए यदि हमारे पास एक एल्गोरिथ्म है जो 2 तक विभाजित होता है जब तक कि संख्या पर्याप्त रूप से छोटा नहीं हो जाती है, तो हम कह सकते हैं कि यह O (लॉग एन) चरणों में समाप्त हो जाता है।

एक महत्वपूर्ण विवरण यह है कि इससे कोई फर्क नहीं पड़ता कि आप किस एन को विभाजित कर रहे हैं (जब तक कि यह एक से अधिक हो); यदि आप निरंतर k से विभाजित करते हैं, तो यह 1. तक पहुँचने के लिए लॉग _k n कदम उठाएगा। इस प्रकार किसी भी एल्गोरिथ्म को बार-बार कुछ अंश द्वारा इनपुट आकार को विभाजित करने पर O (लॉग एन) पुनरावृत्तियों को समाप्त करने की आवश्यकता होगी। उन पुनरावृत्तियों में बहुत समय लग सकता है और इसलिए शुद्ध रनटाइम को O (log n) की आवश्यकता नहीं होगी, लेकिन चरणों की संख्या लघुगणक होगी।

तो यह कहां से आता है? एक क्लासिक उदाहरण द्विआधारी खोज है , एक मूल्य के लिए एक क्रमबद्ध सरणी की खोज के लिए एक तेज एल्गोरिथ्म। एल्गोरिथ्म इस तरह काम करता है:

• यदि सरणी खाली है, तो वापस लौटें जो तत्व सरणी में मौजूद नहीं है।
• अन्यथा:
  • सरणी के मध्य तत्व को देखें।
  • यदि यह उस तत्व के बराबर है जिसे हम खोज रहे हैं, तो सफलता लौटें।
  • यदि यह उस तत्व से अधिक है जिसे हम खोज रहे हैं:
    • सरणी के दूसरे भाग को फेंक दें।
    • दोहराना
  • यदि यह उस तत्व से कम है जिसे हम खोज रहे हैं:
    • सरणी के पहले भाग को फेंक दें।
    • दोहराना

उदाहरण के लिए, सरणी में 5 को खोजने के लिए

1   3   5   7   9   11   13

हम पहले मध्य तत्व को देखेंगे:

1   3   5   7   9   11   13
            ^

चूंकि Since> ५, और चूंकि सरणी को क्रमबद्ध किया गया है, इसलिए हम एक तथ्य के लिए जानते हैं कि संख्या ५ सरणी के पिछले भाग में नहीं हो सकती है, इसलिए हम इसे छोड़ सकते हैं। यह छोड़ देता है

1   3   5

तो अब हम यहां मध्य तत्व को देखते हैं:

1   3   5
    ^

3 <5 के बाद से, हम जानते हैं कि 5 सरणी की पहली छमाही में दिखाई नहीं दे सकते हैं, इसलिए हम छोड़ने के लिए पहले आधे सरणी को फेंक सकते हैं

        5

फिर से हम इस सरणी के मध्य को देखते हैं:

        5
        ^

चूंकि यह ठीक वह संख्या है जिसकी हम तलाश कर रहे हैं, हम रिपोर्ट कर सकते हैं कि 5 वास्तव में सरणी में है।

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

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

प्रोसेसिंग का मान एक बार में एक अंक होता है

आधार -10 नंबर n में कितने अंक हैं? ठीक है, अगर संख्या में k अंक हैं, तो हमारे पास सबसे बड़ा अंक 10 ^k का कुछ ^{गुणन होगा} । सबसे बड़ा k- अंकों की संख्या 999 ... 9, k समय है, और यह 10 ^{k + 1} - ^{1 के} बराबर है । नतीजतन, अगर हम जानते हैं कि n में k अंक हैं, तो हम जानते हैं कि n का मान है अधिकतम 10 ^{k + 1} - 1. यदि हम n के संदर्भ में k को हल करना चाहते हैं, तो हम प्राप्त करते हैं

n ⁺ 10 ^{k + 1} - 1

n + 1 ≤ 10 ^{k + 1}

लॉग ₁₀ (n + 1) + k + 1

(लॉग ₁₀ (n + 1)) - 1 + k

जिससे हमें पता चलता है कि k लगभग n का आधार -10 लघुगणक है। दूसरे शब्दों में, n में अंकों की संख्या O (लॉग एन) है।

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

    1  3  3  7
+   2  0  6  5
==============

हम अंतिम अंक जोड़ते हैं और 1 ले जाते हैं:

          1
    1  3  3  7
+   2  0  6  5
==============
             2

फिर हम दूसरे-से-अंतिम ("पारंगत") अंकों को जोड़ते हैं और 1 ले जाते हैं:

       1  1
    1  3  3  7
+   2  0  6  5
==============
          0  2

अगला, हम तीसरे-से-अंतिम ("एंटीपेनल्टीमेट") अंक जोड़ते हैं:

       1  1
    1  3  3  7
+   2  0  6  5
==============
       4  0  2

अंत में, हम चौथे-से-अंतिम ("उपदेशात्मक" ... I love English) अंक जोड़ते हैं:

       1  1
    1  3  3  7
+   2  0  6  5
==============
    3  4  0  2

अब, हमने कितना काम किया? हम कुल O (1) कार्य प्रति अंक (जो कि एक स्थिर राशि है) करते हैं, और O (अधिकतम {log n, log m}) कुल अंक हैं जिन्हें संसाधित करने की आवश्यकता है। यह कुल ओ (अधिकतम {लॉग एन, लॉग एम}) जटिलता देता है, क्योंकि हमें दो अंकों में प्रत्येक अंक पर जाने की आवश्यकता है।

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

---

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

उम्मीद है की यह मदद करेगा!

Answer 2

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

हम कहते हैं कि एक समस्या "(एन के कुछ फंक्शन) की बड़ी-ओह है" अगर और केवल अगर :

सभी N> कुछ अनियंत्रित N_0 के लिए, कुछ स्थिर c है, जैसे कि एल्गोरिथ्म का रनटाइम उस निरंतर c समय (N के कुछ फ़ंक्शन) से कम है ।

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

संक्षेप में, वह फ़ंक्शन एक ऊपरी बाउंड है, एक स्थिर कारक तक।

तो, "बिग-ओह ऑफ़ लॉग (एन)" का मतलब वही है जो मैंने ऊपर कहा था, सिवाय "एन के कुछ फ़ंक्शन" को "लॉग (एन)" से बदल दिया गया है।

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

आप सी = 10 होने के लिए उस मनमाने ढंग से स्थिर को चुन सकते हैं, और यदि आपकी सूची में एन = 32 तत्व हैं, तो आप ठीक हैं: 10 * लॉग (32) = 50, जो कि 32 के रनटाइम से अधिक है। लेकिन अगर एन = 64 , 10 * लॉग (64) = 60, जो 64 के रनटाइम से कम है। आप सी = 100, या 1000, या गजिलियन चुन सकते हैं, और आप अभी भी कुछ एन को खोजने में सक्षम होंगे जो उस आवश्यकता का उल्लंघन करते हैं। दूसरे शब्दों में, कोई N_0 नहीं है।

यदि हम एक द्विआधारी खोज करते हैं, हालांकि, हम मध्य तत्व को चुनते हैं, और तुलना करते हैं। फिर हम आधा संख्याओं को बाहर फेंक देते हैं, और इसे फिर से, और फिर से, और इसी तरह करते हैं। यदि आपका N = 32 है, तो आप केवल 5 बार कर सकते हैं, जो लॉग (32) है। यदि आपका एन = 64, आप केवल 6 बार, आदि के बारे में ऐसा कर सकते हैं, तो अब आप उस मनमाने ढंग से निरंतर सी चुन सकते हैं , इस तरह से आवश्यकता हमेशा एन के बड़े मूल्यों के लिए पूरी होती है।

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

(नोट: लगभग हमेशा, लॉग (एन) का मतलब लॉग-बेस-टू है, जो कि मैं ऊपर मानता हूं।)

Answer 3

निम्नलिखित समाधान में, एक्स और वाई के उप-सरणियों के दिए गए आकारों के आधे हिस्से पर एक पुनरावर्ती कॉल के साथ सभी लाइनें एक निरंतर समय में की जाती हैं। पुनरावर्ती कार्य T (2n) = T (2n / 2) + c = T (n) + c = O (lg (2n)) = O (lgn) है।

आप MEDIAN (X, 1, n, Y, 1, n) से शुरू करें।

MEDIAN(X, p, r, Y, i, k) 
if X[r]<Y[i]
    return X[r]
if Y[k]<X[p]
    return Y[k]
q=floor((p+r)/2)
j=floor((i+k)/2)
if r-p+1 is even
    if X[q+1]>Y[j] and Y[j+1]>X[q]
        if X[q]>Y[j]
            return X[q]
        else
            return Y[j]
    if X[q+1]<Y[j-1]
        return MEDIAN(X, q+1, r, Y, i, j)
    else
        return MEDIAN(X, p, q, Y, j+1, k)
else
    if X[q]>Y[j] and Y[j+1]>X[q-1]
        return Y[j]
    if Y[j]>X[q] and X[q+1]>Y[j-1]
        return X[q]
    if X[q+1]<Y[j-1]
        return MEDIAN(X, q, r, Y, i, j)
    else
        return MEDIAN(X, p, q, Y, j, k)

Answer 4

एल्गोरिथ्म जटिलता विश्लेषण में लॉग शब्द बहुत बार पॉप अप होता है। यहाँ कुछ स्पष्टीकरण दिए गए हैं:

1. आप एक संख्या का प्रतिनिधित्व कैसे करते हैं?

आइए X = 245436 नंबर लें। "245436" के इस अंकन में निहित जानकारी है। उस जानकारी को स्पष्ट करना:

X = 2 * 10 ^ 5 + 4 * 10 ^ 4 + 5 * 10 ^ 3 + 4 * 10 ^ 2 + 3 * 10 ^ 1 + 6 * 10 ^ 0

जो संख्या का दशमलव विस्तार है। इसलिए, हमें इस संख्या को दर्शाने के लिए न्यूनतम जानकारी 6 अंकों की है। यह कोई संयोग नहीं है, क्योंकि 10 ^ d से कम किसी भी संख्या को d अंकों में दर्शाया जा सकता है ।

तो X का प्रतिनिधित्व करने के लिए कितने अंक आवश्यक हैं? X प्लस 1 में 10 के सबसे बड़े प्रतिपादक के बराबर है।

==> 10 ^ डी> एक्स
==> लॉग (10 ^ डी)> लॉग (एक्स)
==> डी * लॉग (10)> लॉग (एक्स)
==> डी> लॉग (एक्स) // और लॉग दिखाई देता है फिर से ...
==> डी = मंजिल (लॉग (x)) + 1

यह भी ध्यान दें कि इस सीमा में संख्या को निरूपित करने का यह सबसे संक्षिप्त तरीका है। किसी भी कमी से सूचना का नुकसान होगा, क्योंकि लापता अंक को 10 अन्य नंबरों पर मैप किया जा सकता है। उदाहरण के लिए: 12 * को 120, 121, 122,…, 129 पर मैप किया जा सकता है।

2. आप एक नंबर (0, N - 1) की खोज कैसे करते हैं?

N = 10 ^ d लेते हुए, हम अपने सबसे महत्वपूर्ण अवलोकन का उपयोग करते हैं:

0 से N - 1 = लॉग (N) अंकों के बीच किसी श्रेणी में मान को विशिष्ट रूप से पहचानने के लिए न्यूनतम जानकारी।

इसका तात्पर्य यह है कि, जब पूर्णांक रेखा पर संख्या की खोज करने के लिए कहा जाता है, तो 0 से N - 1 तक, हमें कम से कम लॉग (N) को खोजने की कोशिश करता है। क्यों? किसी भी खोज एल्गोरिथ्म को संख्या की खोज में एक के बाद एक अंक चुनने की आवश्यकता होगी।

यह चुनने के लिए आवश्यक अंकों की न्यूनतम संख्या लॉग (N) है। इसलिए एन के आकार के स्थान में संख्या की खोज के लिए किए गए संचालन की न्यूनतम संख्या लॉग (एन) है।

क्या आप द्विआधारी खोज, टर्नरी खोज या डेका खोज के आदेश की जटिलताओं का अनुमान लगा सकते हैं?
इसका ओ (लॉग (एन))!

3. आप संख्याओं के समूह को कैसे क्रमबद्ध करते हैं?

जब A को किसी सरणी B में संख्याओं के समूह को क्रमबद्ध करने के लिए कहा जाता है, तो यहां ऐसा दिखता है ->

अनुमति तत्व

मूल सरणी में प्रत्येक तत्व को छांटे गए सरणी में संबंधित सूचकांक में मैप किया जाना है। तो, पहले तत्व के लिए, हमारे पास n स्थिति है। इस रेंज में 0 से n - 1 तक संबंधित इंडेक्स को सही ढंग से खोजने के लिए, हमें ... (n) ऑपरेशंस की आवश्यकता है।

अगले तत्व को लॉग (n-1) संचालन, अगला लॉग (n-2) इत्यादि की आवश्यकता है। कुल होने के लिए आता है:

==> लॉग (एन) + लॉग (एन - 1) + लॉग (एन - २) +… + लॉग (१)

लॉग (ए) + लॉग (बी) = लॉग (एक * बी),

==> लॉग का उपयोग करना (एन!)

इसे nlog (n) - n से अनुमानित किया जा सकता है ।
जो O (n * log (n)) है!

इसलिए हम निष्कर्ष निकालते हैं कि कोई छँटाई एल्गोरिथ्म नहीं हो सकता है जो ओ (एन * लॉग (एन)) से बेहतर कर सकता है। और इस जटिलता वाले कुछ एल्गोरिदम लोकप्रिय मर्ज सॉर्ट और हीप सॉर्ट हैं!

ये कुछ कारण हैं जिनके कारण हम एल्गोरिदम के जटिलता विश्लेषण में लॉग (एन) को इतनी बार देखते हैं। वही बाइनरी नंबर तक बढ़ाया जा सकता है। मैंने उस पर एक वीडियो बनाया है।
एल्गोरिथम जटिलता विश्लेषण के दौरान लॉग (एन) इतनी बार क्यों दिखाई देता है?

चीयर्स!

Answer 5

हम समय जटिलता ओ (लॉग एन) कहते हैं, जब समाधान एन पर पुनरावृत्तियों पर आधारित होता है, जहां प्रत्येक पुनरावृत्ति में किया गया कार्य पिछले पुनरावृत्ति का एक अंश होता है, जैसा कि एल्गोरिथ्म समाधान की दिशा में काम करता है।

Answer 6

अभी तक कोई टिप्पणी नहीं कर सकता ... यह है! एवी कोहेन का जवाब गलत है, कोशिश करें:

X = 1 3 4 5 8
Y = 2 5 6 7 9

शर्तों में से कोई भी सत्य नहीं है, इसलिए माध्य (एक्स, पी, क्यू, वाई, जे, के) दोनों पत्नियों को काट देगा। ये गैर-अनुक्रमिक अनुक्रम हैं, सभी मूल्य अलग-अलग नहीं हैं।

अलग-अलग मानों के साथ यह समान-लंबाई उदाहरण भी आज़माएँ:

X = 1 3 4 7
Y = 2 5 6 8

अब MEDIAN (X, p, q, Y, j + 1, k) चारों को काट देगा।

इसके बजाय मैं इस एल्गोरिथ्म की पेशकश करता हूं, इसे MEDIAN (1, n, 1, n) के साथ कॉल करें:

MEDIAN(startx, endx, starty, endy){
  if (startx == endx)
    return min(X[startx], y[starty])
  odd = (startx + endx) % 2     //0 if even, 1 if odd
  m = (startx+endx - odd)/2
  n = (starty+endy - odd)/2
  x = X[m]
  y = Y[n]
  if x == y
    //then there are n-2{+1} total elements smaller than or equal to both x and y
    //so this value is the nth smallest
    //we have found the median.
    return x
  if (x < y)
    //if we remove some numbers smaller then the median,
    //and remove the same amount of numbers bigger than the median,
    //the median will not change
    //we know the elements before x are smaller than the median,
    //and the elements after y are bigger than the median,
    //so we discard these and continue the search:
    return MEDIAN(m, endx, starty, n + 1 - odd)
  else  (x > y)
    return MEDIAN(startx, m + 1 - odd, n, endy)
}