मर्जर्ट ओ (लॉग एन) क्यों है?

27

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

algorithms big-o

— दृढ़ता
स्रोत

33

यह O (n log n) है

— Esben Skov Pedersen

18

यहां तक कि भगवान की छँटाई एल्गोरिथ्म (एक काल्पनिक छँटाई एल्गोरिथ्म जिसमें एक दैव तक पहुँच होती है जो यह बताता है कि प्रत्येक तत्व कहाँ है) में ओ (एन) का रनटाइम है क्योंकि इसे प्रत्येक तत्व को स्थानांतरित करने की आवश्यकता है जो कम से कम एक बार गलत स्थिति में है।

— फिलीपींस

59

यह O (n * लॉग (n)) है, O (लॉग (n)) नहीं है। जैसा कि आपने सटीक रूप से बताया है, संपूर्ण इनपुट के माध्यम से पुनरावृत्त होना चाहिए, और यह O (लॉग (n)) बार होना चाहिए (इनपुट केवल O (लॉग (n)) बार आधा किया जा सकता है)। n आइटम iterated log (n) बार O (n लॉग (n)) देता है।

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

— DeadMG
स्रोत

3

s / तेज / कम जटिलता के साथ /

— jk।

33

मर्ज सॉर्ट की जटिलता हे (nlogn) और NOT O (logn)।

मर्ज सॉर्ट एक विभाजित और एल्गोरिथ्म को जीतना है। इसे 3 चरणों के संदर्भ में सोचें -

विभाजन कदम प्रत्येक उप-सरणियों के मध्य बिंदु की गणना करता है। इस चरण में से प्रत्येक में केवल O (1) समय लगता है।
विजेता कदम n / 2 के दो उप-प्रकारों को क्रमबद्ध करता है (प्रत्येक n के लिए) प्रत्येक तत्व।
मर्ज स्टेप n तत्वों को मर्ज करता है जो O (n) समय लेता है।

अब, चरण 1 और 3 के लिए अर्थात O (1) और O (n) के बीच, O (n) अधिक है। चलो चरण 1 और 3 पर विचार करते हैं कुल में O (n) समय। कहो कि यह कुछ निरंतर c के लिए cn है।

इन चरणों को कितनी बार निष्पादित किया जाता है?

इसके लिए, नीचे दिए गए पेड़ को देखें - प्रत्येक स्तर के लिए ऊपर से नीचे तक स्तर 2 कॉल की विधि 2 उप-सरणियों पर लंबाई n / 2 प्रत्येक। यहाँ जटिलता 2 * (cn / 2) = cn स्तर 3 है कॉल विधि 4 उप-सरणियों की लंबाई n / 4 प्रत्येक पर है। यहाँ जटिलता 4 * (cn / 4) = cn वगैरह है ...

अब, इस पेड़ की ऊंचाई दिए गए n के लिए (logn + 1) है। इस प्रकार समग्र जटिलता (logn + 1) * (cn) है। मर्ज सॉर्ट एल्गोरिथम के लिए O (nlogn) है।

चित्र साभार: खान एकेडमी

— शांतनु अलशी
स्रोत

9

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

T (n) = 2T (n / 2) + n (n)

उपरोक्त पुनरावृत्ति को पुनरावृत्ति ट्री विधि या मास्टर विधि का उपयोग करके हल किया जा सकता है। यह मास्टर विधि के मामले II में आता है और पुनरावृत्ति का समाधान n (एन लॉग एन) है।

मर्ज सॉर्ट की समय जटिलता सभी 3 मामलों (सबसे खराब, औसत और सर्वोत्तम) में ɵ (nLogn) है क्योंकि मर्ज सॉर्ट हमेशा सरणी को दो हिस्सों में विभाजित करता है और दो हिस्सों को विलय करने के लिए रैखिक समय लेता है।

यह इनपुट एरे को दो हिस्सों में बांटता है, खुद को दो हिस्सों के लिए कहता है और फिर दो हलकों को जोड़ देता है। दो हिस्सों को मर्ज करने के लिए मर्ग () फ़ंक्शन का उपयोग किया जाता है। मर्ज (गिरफ्तारी, l, m, r) वह महत्वपूर्ण प्रक्रिया है जो मानती है कि गिरफ्तार [l..m] और गिरफ्तारी [m + 1..r] को सॉर्ट किया जाता है और दो सॉर्ट किए गए उप-सरणियों को एक में मिला देता है। विवरण के लिए निम्नलिखित सी कार्यान्वयन देखें।

MergeSort(arr[], l,  r)
If r > l
     1. Find the middle point to divide the array into two halves:  
             middle m = (l+r)/2
     2. Call mergeSort for first half:   
             Call mergeSort(arr, l, m)
     3. Call mergeSort for second half:
             Call mergeSort(arr, m+1, r)
     4. Merge the two halves sorted in step 2 and 3:
             Call merge(arr, l, m, r)

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

— निशांत सेठी
स्रोत

1

क्या आप इसके मर्ज वाले हिस्से की प्रकृति के बारे में विस्तार से बता सकते हैं और यह ओ (एन लॉग एन) प्रदर्शन में कैसे योगदान देता है?

मर्ज फ़ंक्शन की जटिलता ओ (एन) है, क्योंकि यह एक इनपुट के रूप में 2 सरणियों लेता है, उनकी तुलना करें और नए में आउटपुट दें। जैसा कि यह सरणी में प्रत्येक तत्व की हर दूसरे तत्व से तुलना कर रहा है, इस मर्ज फ़ंक्शन की जटिलता O (n) होती है।

— निशांत सेठी

1

मुझे इस तरह के दृश्य पसंद हैं!

— स्पाकार्की

0

तुलना आधारित सॉर्ट एल्गोरिदम की सीमा कम होती है 𝞨(n*log(n)), जिसका अर्थ है कि O(log(n))समय जटिलता के साथ तुलना आधारित सॉर्टिंग एल्गोरिदम होना संभव नहीं है ।

वैसे, मर्ज सॉर्ट है O(n*log(n))। इसे इस तरह से सोचें।

[ a1,a2,         a3,a4,         a5,a6,          a7,a8     .... an-3,an-2,     an-1, an ] 
   \ /            \  /           \ /             \  /            \  /            \  /    
    a1'            a3'            a5'             a7'            an-3'           an-1'    
      \            /                \             /                 \             /
            a1''                          a5''                       an-3''
             \                             /                         /
                          a1'''                                     /
                           \
                                              a1''''

यह एक उल्टा बाइनरी ट्री दिखता है।

इनपुट साइज होने दें n।

प्रत्येक a_nतत्वों की एक सूची का प्रतिनिधित्व करता है। पहली पंक्ति a_nमें केवल एक तत्व है।

प्रत्येक स्तर पर, औसत पर मर्ज लागत का योग है n(वहाँ कोने के मामले मौजूद हैं जो लागत कम है [1])। और पेड़ की ऊंचाई है log_2(n)।

तो, मर्ज सॉर्ट की समय जटिलता है O(n*log_2(n))।

[१] यदि पहले से हल की गई सूची को छाँट लिया जाए, जिसे सबसे अच्छा मामला कहा जाता है। लागत कम हो गई n/2 + n/4 + n/8 + .... + 1 = 2^log_2(n) -1 ~ O(n)। (मान लें कि लंबाई nदो की शक्ति है)

— डब्ल्यू। पीसी
स्रोत

-2

छंटनी कंप्यूटर विज्ञान में एक एनपी-पूर्ण समस्या है (गैर बहुपद समस्या)। इसका मतलब यह है कि, जब तक गणितीय रूप से सिद्ध नहीं किया जाता है, तब तक आप तत्वों की सूची को सॉर्ट करते समय O (n log n) से नीचे नहीं जा सकते।

इस लेख को विकिपीडिया ( https://en.wikipedia.org/wiki/P_versus_NP_problem ) में देखें

मूल रूप से अब तक कोई भी यह साबित करने में कामयाब नहीं हुआ है कि (पी == एनपी) और यदि आप करते हैं, तो आप पहले करोड़पति बन जाते हैं, दूसरे आप विश्व युद्ध III को इस तथ्य के कारण शुरू करते हैं कि आप उपयोग किए गए सभी पब / निजी कुंजी सुरक्षा तंत्र को तोड़ने में सक्षम होंगे हर जगह आजकल :)

— slux83
स्रोत

2

एनपी का मतलब यह नहीं है। यहां तक कि BubbleSort पी में है तुम पी (जैसे BogoSort) में एक तरह से thats नहीं रखने का भरसक प्रयास करने के लिए है

— Caleth